C# – Un FtpHelper allégé

J’ai réalisé il y a quelques temps une petite classe simple permettant d’effectuer des manipulations de base sur un serveur FTP (Suppression, Upload, Download, Listing, etc. …) dans un environnement WPF / Silverlight (non compatible dans un environnement Windows Phone 7 pour le moment, il faudrait utiliser des requêtes HTTP).

Quelles classes choisir ?

C’est vrai qu’il existe plusieurs méthodes différentes pour parvenir à réaliser ce genre de classe (on peut penser à la classe WebClient qui propose des méthodes de transferts asynchrones par exemple), mais j’ai privilégié l’utilisation des classes Ftp* (FtpWebRequest, FtpWebResponse) et ce, pour plusieurs raisons :

  • Utiliser des objets communs pour l’ensemble des opérations qui seront réalisées sur le FTP. La classe WebClient ne permet que d’envoyer et recevoir des données : il n’est pas possible de lister un répertoire distant, supprimer des ressources distantes, etc. … Si j’utilisais cette classe, j’aurais quand même dû utiliser FtpWebRequest et FtpWebResponse pour lister, supprimer, etc. …
  • Liberté de gestion des transferts asynchrones (par exemple pour gérer plusieurs actions lors des transferts ou encore désactiver des contrôles, etc. …)
  • Gestion de l’état des transferts

Si votre besoin est lié uniquement à un simple transfert sans attente quelconque en retour, vous pouvez bien entendu utiliser la classe WebClient.

Classe FtpHelper

La classe FtpHelper est simple et allégée. Voici son code :

public class FtpHelper : INotifyPropertyChanged
{
#region Private Fields
const int bufferLength = 2048;
private readonly string[] _separators = new string[] { "\r\n" };
private String _Url;
private String _Login;
private String _Password;
private Boolean _IsRequestCompleted;
private int _currentPercentage;
#endregion

#region Ctors

public FtpHelper() { }

public FtpHelper(String url, String login, String password)
{
_Url = url;
_Login = login;
_Password = password;
}

#endregion

#region Public Methods

///
/// Get File Size
///
///
///
public long GetFileSize(String file)
{
try
{
var ftpFullFilePath = GetFileFtpUrl(file);
var request = Request(ftpFullFilePath);
request.Method = WebRequestMethods.Ftp.GetFileSize;

long size;
using (var response = (FtpWebResponse)request.GetResponse()) {
size = response.ContentLength;
}
return size;
}
catch { throw new Exception("Could not Get File Size"); }
}

///
/// Check if a file exist
///
///
///
public bool FileExists(String file)
{
try {
var ftpFullFilePath = GetFileFtpUrl(file);
var request = Request(ftpFullFilePath);
request.Method = WebRequestMethods.Ftp.GetFileSize;
var response = (FtpWebResponse)request.GetResponse();
return true;
}
catch (WebException ex)
{
var response = (FtpWebResponse)ex.Response;
if (response.StatusCode == FtpStatusCode.ActionNotTakenFileUnavailable) {
return false;
}
throw new Exception("Can not determine if file exists or not");
}
}

///
/// Deletes file on ftp
///
///
///
public bool Delete(String file)
{
try
{
var ftpFullFilePath = GetFileFtpUrl(file);
var request = Request(ftpFullFilePath);
request.Method = WebRequestMethods.Ftp.DeleteFile;
var response = (FtpWebResponse)request.GetResponse();
return true;
}
catch (WebException ex)
{
var response = (FtpWebResponse)ex.Response;
if (response.StatusCode == FtpStatusCode.ActionNotTakenFileUnavailable) {
return false;
}
throw new Exception("Can not delete file exists or not");
}
}

///
/// Upload file
///
///
public void Upload(String file)
{
IsRequestCompleted = false;
var ftpFile = GetFileFtpUrl(file);

try
{
if (FileExists(file)) {
Delete(file);
}

var request = Request(ftpFile);
request.Method = WebRequestMethods.Ftp.UploadFile;
request.ContentLength = new FileInfo(file).Length;
Stream requestStream = request.GetRequestStream();

//const int bufferLength = 2048;
byte[] buffer = new byte[bufferLength];
int count = 0;
int readBytes = 0;
CurrentPercentage = 0;

using (FileStream stream = File.OpenRead(file))
{
do
{
readBytes = stream.Read(buffer, 0, bufferLength);
requestStream.Write(buffer, 0, readBytes);
count += readBytes;

//You can upload a 0 bytes file but, we must not process percentage
//which is base on length
if (request.ContentLength > 0)
{
var currentP = (decimal)((count / request.ContentLength) * 100);
if (CurrentPercentage < 100)
{
CurrentPercentage = (int)Math.Round(currentP, MidpointRounding.ToEven);
}
}
}
while (readBytes != 0);
}
requestStream.Close();
CurrentPercentage = 100;
}
catch(Exception ex) {
throw new Exception("Could not upload file properly.", ex);
}

IsRequestCompleted = true;
}

///
/// Download File
///
///
public void Download(String file)
{
Download(file, null);
}

///
/// Download file
///
///
///
public void Download(String file, String outputPath)
{
//throw new NotImplementedException("Download has not already been implemented");
IsRequestCompleted = false;
var ftpFile = GetFileFtpUrl(file);

if (String.IsNullOrEmpty(outputPath)) {
outputPath = Environment.CurrentDirectory;
}

var outputFile = Path.Combine(outputPath, Path.GetFileName(file));

try {

var request = Request(ftpFile);
request.Method = WebRequestMethods.Ftp.DownloadFile;
request.ContentLength = GetFileSize(file);
Stream responseStream = request.GetResponse().GetResponseStream();

byte&#91;&#93; buffer = new byte&#91;bufferLength&#93;;
int count = 0;
int readBytes = 0;
CurrentPercentage = 0;

using (FileStream stream = File.Create(outputFile))
{
do
{
readBytes = responseStream.Read(buffer, 0, buffer.Length);
stream.Write(buffer, 0, readBytes);
count += readBytes;

//You can download a 0 bytes file but, we must not process percentage
//which is base on length
if (request.ContentLength > 0)
{
var currentP = (decimal)((count / request.ContentLength) * 100);
if (CurrentPercentage < 100) {
CurrentPercentage = (int)Math.Round(currentP, MidpointRounding.ToEven);
}
}
}
while (readBytes != 0);
}
responseStream.Close();
CurrentPercentage = 100;
}
catch (Exception ex) {
throw new Exception("Could not download file properly.", ex);
}

IsRequestCompleted = true;

}

///
/// List base directory (url) files
///
public String&#91;&#93; GetDirectoryFiles()
{
try
{
var request = Request(_Url);
request.Method = WebRequestMethods.Ftp.ListDirectory;
var response = request.GetResponse();
String expectedResult = String.Empty;
using (response)
{
using (StreamReader sr = new StreamReader(response.GetResponseStream()))
{
expectedResult = sr.ReadToEnd();
}
}
if (!String.IsNullOrEmpty(expectedResult))
{
String&#91;&#93; files = expectedResult.Split(_separators, StringSplitOptions.RemoveEmptyEntries);
return files;
}
}
catch(Exception ex) {
throw new Exception("Can not list directory", ex);
}
return null;
}

#endregion

#region Private Methods
///
/// Return a new FtpWebRequest with default parameters
///
/// Url to connect
/// return a new FtpWebRequest
private FtpWebRequest Request(String Url)
{
var request = (FtpWebRequest)WebRequest.Create(Url);
request.Credentials = new NetworkCredential(_Login, _Password);
request.KeepAlive = false;
request.UseBinary = true;
return request;
}

///
/// Get expected file url on ftp;
///
///
///
private String GetFileFtpUrl(String file)
{
if (file.StartsWith("ftp://"))
return file;

FileInfo fi = new FileInfo(file);
Uri baseUrl = new Uri(_Url);
Uri destUri;

if (Uri.TryCreate(baseUrl, fi.Name, out destUri)) {
return destUri.AbsoluteUri;
}
return String.Empty;
}

#endregion

#region Public Properties
public String Password
{
get { return _Password; }
set { _Password = value; }
}

public String Login
{
get { return _Login; }
set { _Login = value; }
}

public String Url
{
get { return _Url; }
set { _Url = value; }
}
///
/// gets / sets if current request is completed
///
public Boolean IsRequestCompleted
{
get { return _IsRequestCompleted; }
set
{
if (_IsRequestCompleted != value) {
_IsRequestCompleted = value;
RaisePropertyChanged("IsRequestCompleted");
}
}
}

///
/// gets / sets current file being downloaded or upload size
///
public int CurrentPercentage
{
get { return _currentPercentage; }
set
{
if (_currentPercentage != value)
{
_currentPercentage = value;
RaisePropertyChanged("CurrentPercentage");
}
}
}

#endregion

#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
protected void RaisePropertyChanged(string propertyName)
{
PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
if (propertyChanged != null)
{
propertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
#endregion
}
&#91;/sourcecode&#93;

<h2>Utilisation du Helper</h2>

Pour pouvoir envoyer un fichier, il faudrait initialiser la classe avec les informations de connexion :

FtpHelper helper = new FtpHelper("ftp.example.com", "login", "password");

Pour pouvoir transférer un fichier vers le FTP :

helper.Upload("monfichier.ext");

Pour télécharger un fichier vers son poste :

helper.Download("nomdufichier")

Ou

Helper.Download("nomdufichier", @"D:\DestDirectory\")

Pour connaître l’état d’avancement du transfert, il est possible de se “binder” sur la propriété CurrentPercentage

helper.CurrentPercentage

Pour déterminer si une requête est complètement exécutée (transfert fini), il est possible de se binder sur la propriété IsRequestCompleted :

IsRequestCompleted.

Pour finir

Bien entendu, cette classe est modifiable à votre convenance (et peut être davantage améliorée). Vous pourrez trouver un exemple (WPF) d’utilisation plus précise de cette classe en cliquant ici.

A bientôt.

Nombre de vue : 141

COMMENTAIRES 2 commentaires

  1. Benjamin Baumann dit :

    Ce code est il publié sur une plateforme collaborative? Sous quelle licence? J’ai fait quelques changements en interne (surcharge de fonction, quelques oublis de libération de flux) et j’aimerai bien les répercuter…

  2. David POULIN dit :

    Hello Ben (^__^),

    Ce code n’est encore publié à ce jour sur aucune plateforme collaborative et sous aucune licence. Tu peux avoir si tu le désires cette liberté de pouvoir le modifier et publier tes modifications à ta convenance que ce soit ici, ou alors, sur une plateforme de ton choix !

    A bientôt !

AJOUTER UN COMMENTAIRE