web-dev-qa-db-fra.com

Comment afficher la barre de progression pour le téléchargement avec FtpWebRequest

Je télécharge des fichiers sur ftp en utilisant FtpWebRequest. J'ai besoin de montrer au statut que tout est fait.

Jusqu'ici mon code est:

public void Upload(string filename, string url)
{
    FileInfo fileInf = new FileInfo(filename);
    string uri = "ftp://" + url + "/" + fileInf.Name;
    FtpWebRequest reqFTP;
    //string uri = "ftp://" + Host + "/public_html/testing/blogtest/" + fileInf.Name;

    // Create FtpWebRequest object from the Uri provided
    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));

    // Provide the WebPermission Credintials
    reqFTP.Credentials = new NetworkCredential(Username, Password);

    // By default KeepAlive is true, where the control connection is not closed
    // after a command is executed.
    reqFTP.KeepAlive = false;
    //reqFTP.UsePassive = true;
    // Specify the command to be executed.
    reqFTP.Method = WebRequestMethods.Ftp.UploadFile;

    // Specify the data transfer type.
    reqFTP.UseBinary = true;

    // Notify the server about the size of the uploaded file
    reqFTP.ContentLength = fileInf.Length;

    // The buffer size is set to 2kb
    int buffLength = 2048;
    byte[] buff = new byte[buffLength];
    int contentLen;

    // Opens a file stream (System.IO.FileStream) to read the file to be uploaded
    FileStream fs = fileInf.OpenRead();

    // Stream to which the file to be upload is written
    Stream strm = reqFTP.GetRequestStream();

    // Read from the file stream 2kb at a time
    contentLen = fs.Read(buff, 0, buffLength);

    // Till Stream content ends
    while (contentLen != 0)
    {
        // Write Content from the file stream to the FTP Upload Stream
        strm.Write(buff, 0, contentLen);
        contentLen = fs.Read(buff, 0, buffLength);
    }

    // Close the file stream and the Request Stream
    strm.Close();
    fs.Close();
}
c#winformsftpprogress-barftpwebrequest
25
Afnan Bashir

Le plus simple consiste à utiliser BackgroundWorker et à placer votre code dans le gestionnaire d'événements DoWork. Et signaler les progrès avec BackgroundWorker.ReportProgress.

L'idée de base:

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    var ftpWebRequest = (FtpWebRequest)WebRequest.Create("ftp://example.com");
    ftpWebRequest.Method = WebRequestMethods.Ftp.UploadFile;
    using (var inputStream = File.OpenRead(fileName))
    using (var outputStream = ftpWebRequest.GetRequestStream())
    {
        var buffer = new byte[1024 * 1024];
        int totalReadBytesCount = 0;
        int readBytesCount;
        while ((readBytesCount = inputStream.Read(buffer, 0, buffer.Length)) > 0)
        {
            outputStream.Write(buffer, 0, readBytesCount);
            totalReadBytesCount += readBytesCount;
            var progress = totalReadBytesCount * 100.0 / inputStream.Length;
            backgroundWorker1.ReportProgress((int)progress);
        }
    }
}

private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressBar.Value = e.ProgressPercentage;
}

Assurez-vous que WorkerReportsProgress est activé

backgroundWorker2.WorkerReportsProgress = true;

Avec BackgroundWorker, vous pouvez également implémenter facilement une annulation de téléchargement. 

35
Alex Aza

Un exemple trivial de téléchargement FTP avec FtpWebRequest avec la barre de progression WinForms avec Task class :

private void button1_Click(object sender, EventArgs e)
{
    // Run Upload on background thread
    Task.Run(() => Upload());
}

private void Upload()
{
    FtpWebRequest request =
        (FtpWebRequest)WebRequest.Create("ftp://ftp.example.com/remote/path/file.Zip");
    request.Credentials = new NetworkCredential("username", "password");
    request.Method = WebRequestMethods.Ftp.UploadFile;

    using (Stream fileStream = File.OpenRead(@"C:\local\path\file.Zip"))
    using (Stream ftpStream = request.GetRequestStream())
    {
        progressBar1.Invoke(
            (MethodInvoker)delegate { progressBar1.Maximum = (int)fileStream.Length; });

        byte[] buffer = new byte[10240];
        int read;
        while ((read = fileStream.Read(buffer, 0, buffer.Length)) > 0)
        {
            ftpStream.Write(buffer, 0, read);
            progressBar1.Invoke(
                (MethodInvoker)delegate {
                    progressBar1.Value = (int)fileStream.Position; });
        }
    }
}

 enter image description here

Le code de téléchargement principal est basé sur:
Téléchargez et téléchargez un fichier binaire vers/depuis un serveur FTP en C # /. NET

2
Martin Prikryl

Une approche annulable utilisant l'interface IProgress du modèle async/wait, tirant parti de chevauchement d'E/S si disponible. Reportez-vous à KB156932 pour déterminer si votre scénario est admissible. Le jeton d'annulation est vérifié avant d'ouvrir les flux, mais est sinon déchargé vers les méthodes asynchrones des flux pendant le transfert du fichier.

J'ai très peu analysé les performances, mais je suppose que cela n’est pratique que lors de l’envoi de gros fichiers. Les performances d’utilisation d’E/S superposées peuvent se dégrader avec des fichiers plus petits et des tailles de mémoire tampon particulièrement réduites.

public async Task FtpAsync(string sourceFile, Uri destinationUri, string user, SecureString password, IProgress<decimal> progress, CancellationToken token)
{
  const int bufferSize = 128 * 1024;  // 128kb buffer
  progress.Report(0m);

  var request = (FtpWebRequest)WebRequest.Create(destinationUri);
  request.Method = WebRequestMethods.Ftp.UploadFile;
  request.Credentials = new NetworkCredential(user, password);

  token.ThrowIfCancellationRequested();

  using (var fileStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, true))
  {
    using (var ftpStream = await request.GetRequestStreamAsync())
    {
      var buffer = new byte[bufferSize];
      int read;

      while ((read = await fileStream.ReadAsync(buffer, 0, buffer.Length, token)) > 0)
      {
        await ftpStream.WriteAsync(buffer, 0, read, token);
        var percent = 100m * ((decimal)fileStream.Position / fileStream.Length);
        progress.Report(percent);
      }
    }
  }

  var response = (FtpWebResponse)await request.GetResponseAsync();
  var success = (int)response.StatusCode >= 200 && (int)response.StatusCode < 300;
  response.Close();
  if (!success)
    throw new Exception(response.StatusDescription);
}
0
RMart

Voir BackgroundWorker , il vous permet d'exécuter une tâche fastidieuse pendant que l'interface graphique est toujours réactive et fournit également une progression/annulation.

0
Guillaume