Home Page Home Page Articoli Costruire un client FTP usando il .NET Framework 2.0

Costruire un client FTP usando il .NET Framework 2.0

In questo articolo tratteremo una delle novità più attese del .NET Framework 2.0, le classi per l'utilizzo del protocollo FTP. Realizzeremo un mini client FTP con alcune fra le funzionalità più comuni.
Autore: Giovanni Ferron Livello:

Introduzione


Fin dalla prima versione del Framework chiunque avesse voluto creare un client FTP o comunque interagire con il protocolli, doveva costruirsi una propria classe (oppure utilizzare i componenti già pronti) … e l'FTP non è conosciuto come il protocollo più semplice del web.
Ora con l'avvento del Framework 2.0 mamma Microsoft ha pensato anche a quei poveri sviluppatori che hanno perso nottate a colpi di socket, introducendo due nuove classi FtpWebRequest e FtpWebResponse.



N.B. Per l'articolo sono stati utlizzati esempi in C#, il progetto allegato all'articolo è anche in versione VB.NET.

WebRequest & WebResponse


Per implementare le nuove classi Microsoft ha utilizzato delle classi già presenti nelle versioni precedenti, infatti le classi FtpWebRequest / FtpWebResponse sono derivate rispettivamente da WebRequest / WebResponse. Questa dipendenza comporta:

1. Modello programmazione URI Based: ogni comando effettuato su una cartella o un file deve essere identificato tramite URI (Uniform Resource Identifier), come se fosse una qualsiasi pagina web, ad esempio ftp://mioserver/miacartella/miofile.txt

2. Richieste indipendenti: Ogni richiesta è indipendente dalle altre, quindi ad ogni comando è necessario creare una nuova richiesta e fornire delle credenziali per l'accesso.

3. Standard Stream: In upload e in download è possibile utilizzare classi già implementate nel .NET framework come StreamReader e StreamWriter.

4. Opzioni avanzate: Sono state implementate alcune funzionalità avanzate come la possibilità di specificare il proxy o utilizzare l'FTP over SSL.

Prima connessione


Incominciamo a vedere un po' di codice per capire come funziona in pratica la nuova classe. Prima di tutto bisogna creare una nuova richiesta:

Codice .NET n°1
FtpWebRequest _FtpRequest  = (FtpWebRequest) WebRequest.Create("ftp://mioserver/”);



A questo punto è stata creata una nuova richiesta FTP, alla quale assoceremo delle credenziali per l'autenticazione al server:

Codice .NET n°2
_FtpRequest.Credentials = new NetworkCredential(_UserName, _Password);


Ora dovremo allegare alla nostra richiesta il comando che vogliamo eseguire, ad esempio l'elenco dei file e delle cartelle:

Codice .NET n°3
_FtpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;


L'elemento ListDirectoryDetails fa parte della classe WebRequestMethods.Ftp, che al suo interno contiene tutti i comandi FTP implementati, di seguito l’elenco:

- AppendFile (Comando FTPAPPE, append a un file esistente sul server)
- DeleteFile (Comando FTPDELE, elimina un file sul server)
- DownloadFile (Comando FTPRETR, download di un file sul server)
- GetDateTimestamp (Data/ora server)
- GetFileSize (Comando FTPSIZE, dimensione file)
- ListDirectory (Comando FTPNLIST, lista breve di file e directory)
- ListDirectoryDetails (Comando FTPLIST, lista dettagliata di file e directory)
- MakeDirectory (Comando FTPMKD, crea cartella sul server)
- PrintWorkingDirectory (Comando FTPPWD, ritorna il nome della directory di lavoro)
- RemoveDirectory (Comando FTPRMD, elimina la directory)
- Rename (Comando FTPRENAME, rinomina)
- UploadFile (Comando FTPSTOR, upload di un file)
- UploadFileWithUniqueName (Comando FTPSTOU, carica un file nome univoco sul server)

Allegata la richiesta, eseguiamo la GetResponse, che ritornerà uno Stream con la risposta del server:

Codice .NET n°4
FtpWebResponse  _FtpResponse = (FtpWebResponse) _FtpRequest.GetResponse();


Per poter "leggere" la risposta del server dobbiamo implementare un oggetto StreamReader, specificando anche il tipo di encoding (in questo caso ASCII):

Codice .NET n°5
StreamReader sr = new StreamReader(_FtpResponse.GetResponseStream(), System.Text.Encoding.ASCII);


Ed infine stampiamo la stringa con la risposta del server

Codice .NET n°6
Console. WriteLine(sr.ReadToEnd());


Eccezioni & Opzioni


Nel caso si scateni un'ecezione è possibile intercettare l'errore e visualizzare al posto di un errore standard 500, troppo generico, con un messaggio che interpreta lo status code inviato dal server, utilizzando la proprietà StatusDescription, in questo modo:

Codice .NET n°7
catch (WebException e)
{
Console.WriteLine(((FtpWebResponse)e.Response).StatusDescription);
}


Inoltre come illustrato nell'introduzione è possibile utilizzare alcune opzioni avanzate, come proxy e SSL:

Codice .NET n°8
//Utilizzo Proxy
_FtpRequest.Proxy = new WebProxy("http://myproxy");

//FTP over SSL
_FtpRequest.EnableSSL = true;


Download file via FTP


Dopo aver visualizzato l'elenco dei file e delle cartelle, vediamo come scaricare un file. Quindi dobbiamo creare una nuova richiesta FTP, elencare le nostre credenziali e selezionare come comando WebRequestMethods.Ftp.DownloadFile:

Codice .NET n°9
FtpWebRequest  _FtpRequest = (FtpWebRequest)WebRequest.Create("ftp://mioserver/file.txt”);


_FtpRequest.Credentials = new NetworkCredential(_UserName, _Password);
_FtpRequest.Method = WebRequestMethods.Ftp.DownloadFile;
FtpWebResponse _FtpResponse = (FtpWebResponse)_FtpRequest.GetResponse();


Ora creo un oggetto FileStream per poter creare il file in locale:

Codice .NET n°10
FileStream  _FileStream = new FileStream(“file.txt”, FileMode.Create, FileAccess.Write);


Dopo di che creo l’oggetto FtpWebResponse per poter ricavare lo stream del server e passarlo al FileStream e creare il file:

Codice .NET n°11
//ricavo lo stream FTP
_FtpResponse = (FtpWebResponse)_FtpRequest.GetResponse();
//converto lo stram FTP in un oggetto standard Stream
Stream _ResponseStream = _FtpResponse.GetResponseStream();

//Creo l’array di byte
byte[] buffer = new byte[1024];
//Carico la prima serie di byte nell’array
int bytesRead = _ResponseStream.Read(buffer, 0, 1024);
//ciclo fino alla fine dello stream di byte
while (bytesRead != 0)
{
//Scrivo l’array di byte
_FileStream.Write(buffer, 0, bytesRead);
bytesRead = _ResponseStream.Read(buffer, 0, 1024);
}
//Chiudo gli oggetti
_FileStream.Close();
_ResponseStream.Close();


Una feature che si può implementare è il Resume del download del file, ad esempio mandare in pausa il download e poi riprenderlo in un secondo tempo, utilizzando la proprietà ContentOffset, che indica da quale byte riprendere la lettura dello stream:

Codice .NET n°12
//creo un oggetto fileInfo
FileInfo _File = new FileInfo(“file.txt”);

// Ricavo la lunghezza del mio file in locale, e la imposto come offset,
// in modo che la scrittura parta dalla fine del file.
_FtpRequest.ContentOffset = _File.Length;
//Apro lo Stream in Append
_FileStream = new FileStream(_File.FullName, FileMode.Append, FileAccess.Write);


Upload di un file via FTP


Altra operazione irrinunciabile per un client FTP che si voglia definire tale è l'upload di un file. La procedura è molto simile al download, a parte il comando FTP che sarà WebRequestMethods.Ftp.UploadFile, e l'uso dello stream che sarà invertito. Quindi dopo aver ricreato una nuova richiesta con le credenziali annesse, dobbiamo specificare il nuovo comando:

Codice .NET n°13
FtpWebRequest _FtpRequest.Method = WebRequestMethods.Ftp.UploadFile;


Dopo di che andremo a creare un array di byte lungo quanto la grandezza del nostro file, che riempiremo con un FileStream:

Codice .NET n°14
//creo array di byte
byte[] _fileContents = new byte[_File.Length];
//apro il fileStream
FileStream fr = _File.OpenRead();
//Riempio l’array
fr.Read(_fileContents, 0, Convert.ToInt32(_File.Length));
//chiudo lo stream
fr.Close();


Ottenuto il nostro array non ci resterà altro da fare che creare uno stream FTP e andare a scrivere il contenuto del nostro array sullo stream:

Codice .NET n°15
//ricavo lo stream FTP
Stream writer = _FtpRequest.GetRequestStream();
//Vado a scrivere il contenuto del mio array
writer.Write(_fileContents, 0, _fileContents.Length);
//Chiudo lo stream
writer.Close();


Eliminare un file


Visto che l'eliminazione di un file non richiede l'utilizzo di Stream, ma esclusivamente lesecuzione di un comando, non dovremmo far altro che eseguire una FtpWebResponse, in questo modo:

Codice .NET n°16
//Creo la richiesta
FtpWebRequest _FtpRequest = (FtpWebRequest)WebRequest.Create("ftp://mioserver/file.txt”);
//Passo le credenziali
_FtpRequest.Credentials = new NetworkCredential(_UserName, _Password);
//Imposto il comando
_FtpRequest.Method = WebRequestMethods.Ftp.DeleteFile;


A questo punto ricavo lo stream FTP:

Codice .NET n°17
_FtpResponse = (FtpWebResponse)_FtpRequest.GetResponse();
Stream _ResponseStream = _FtpResponse.GetResponseStream();
_ResponseStream.Close();


Conclusioni


Ora non avrete più scuse se il vostro Project Manager vi chiederà di creare un client FTP, con le nuove classi del Framework 2.0 non avrete più limiti. Come abbiamo visto con poche righe di codice è possibile creare un client FTP, unico neo, a mio modesto parere, il dover specificare per ogni comando l'URI e le credenziali, ma a caval donato non si guarda in bocca ;)
Voto medio articolo: 4.3 Numero Voti: 9

File allegati


FTP_VBNET.zip (105 Kbyte)
FTP_CSharp.zip (61 Kbyte)
FTP_Solution.zip (172 Kbyte)
Giovanni Ferron

Giovanni Ferron

Sviluppatore dal 2000. Collabora a grandi progetti nella creazione di portali e intranet aziendali. Attualmente ha lasciato la terra natia per una nuova avventura in Australia, dove lavora come programmatore web per una emittente radio Australiana. Profilo completo

Articoli collegati

Importare dati di Excel con .NET tramite ODBC o OLEDB e Drag & Drop
Spesso in ambito aziendale è necessario adattare le proprie applicazioni e consentire che possano leggere e operare su file e dati provenienti dai tools della suite di Office fra cui uno dei più usati è Excel. Vediamo quindi come importare dati da file XLS tramite ODBC/OLEDB e Drag & Drop.
Autore: Marco Farina | Difficoltà:
Gestire le Access Control List (ACL) NTFS di file e directory con .NET
Scopriamo come nel .NET Framework 2.0 sia diventato facile recuperare e modificare la lista controllo accessi dei file e directory e in generale come gestire le ACL.
Autore: Marco Caruso | Difficoltà: | Commenti: 1 | Voto:
Alla scoperta di WMI, questo sconosciuto
WMI o Windows Management Instrumentation è un componente fondamentale del sistema operativo Windows. La sua utilità è permettere l'accesso a informazioni fondamentali del sistema, come informazioni sull'hardware, software, servizi, ecc. Vediamo come sfruttarlo con .NET.
Autore: Giovanni Ferron | Difficoltà: | Commenti: 2
Gestire e sfruttare i campi BLOB usando .NET
I database server sono software con una potenza elevata e offrono una vasta gamma di features che spesso non vengono utilizzate. Una di queste sono i campi BLOB (campi per contenere dati in formato binario). Vediamo in questo articolo come utilizzarli con .NET.
Autore: David De Giacomi | Difficoltà: | Commenti: 13
Catturare immagini da una Webcam con .NET
In questo articolo mostreremo come è possibile costruire una applicazione per catturare immagini da una Webcam, utilizzando componenti già presenti in Windows, in questo caso l' Avicap32.dll
Autore: Giovanni Ferron | Difficoltà: | Commenti: 22 | Voto:
Usare il protocollo POP3 per creare un Client di posta
Volete costruirvi un client di posta? Volete costruire una Web Mail ? Ecco un articolo che vi introduce al protocollo POP3 e vi insegna come costruire un mini client di posta elettronica.
Autore: Giovanni Ferron | Difficoltà: | Commenti: 2 | Voto:
La stampa di una Win Form
Vedremo in questo articolo i passi necessari per creare una stampa sia di testo che di grafica di una WinForm attraverso .NET.
Autore: Marco Caruso | Difficoltà: | Commenti: 9 | Voto:
Creare un Setup di un progetto con Visual Studio .NET
Ecco delle semplici ma dettagliate istruzioni passo-passo per costruire un pacchetto di Setup (Setup Package) per le nostre Applicazioni WinForms.
Autore: Marco Caruso | Difficoltà: | Commenti: 18
Creare un?icona nella Taskbar di Windows con .NET
Scoprirete come potenziare la vostra applicazione aggiungendo un'icona nella barra di Windows nella famosa Tray Area a fianco dell'orologio del sistema. Disponibile sia codice VB.NET che C#.
Autore: Giovanni Ferron | Difficoltà: | Commenti: 1 | Voto:
Costruire un Servizio di Windows usando .NET
Un avanzato tutorial che vi spiegherà passo passo e in modo dettagliato le istruzioni per costruire un Servizio Windows, utilizzando ciò che il .NET Framework ci mette a disposizione. Disponibile sia codice C# che VB.NET.
Autore: Giovanni Ferron | Difficoltà: | Commenti: 13 | Voto:
Windows XP Visual Styles con .NET e Win Forms
Come usare lo stile XP nelle vostre applicazioni .NET ? Questo articolo vi spiega come applicare a Buttons, Textbox, ListViews (ai controlli di Windows in genere) lo stile/tema grafico della GUI introdotto dal sistema operativo Windows XP.
Autore: David De Giacomi | Difficoltà: | Commenti: 7
Come sfruttare le funzioni di una DLL unmanaged esterna creata in C/C++
Come usare la classe DllImportAttribute messa a disposizione dal namespace System.Runtime.InteropServices per sfruttare le funzioni di una DLL unmanaged Win32 old-style scritta con Visual C++ 6.0
Autore: David De Giacomi | Difficoltà: | Commenti: 4 | Voto:
Creare una DLL in Visual C++ 6.0
Vedremo in questo articolo come creare una Dynamic Link Link Library, comunemente chiamata DLL con Visual C++ 6.0. Questo passo è necessario per poi dimostrare l'utilizzo di librerie C/C++ in .NET tramite il package System.Runtime.InteropServices
Autore: David De Giacomi | Difficoltà: | Commenti: 11 | Voto:
Copyright © dotNetHell.it 2002-2017
Running on Windows Server 2008 R2 Standard, SQL Server 2012 & ASP.NET 3.5