Copie du fichier avec la barre de progression

j'aime cette solution, parce que

Le moteur de copie est dans le cadre

public delegate void IntDelegate(int Int);

public static event IntDelegate FileCopyProgress;
public static void CopyFileWithProgress(string source, string destination)
{
    var webClient = new WebClient();
    webClient.DownloadProgressChanged += DownloadProgress;
    webClient.DownloadFileAsync(new Uri(source), destination);
}

private static void DownloadProgress(object sender, DownloadProgressChangedEventArgs e)
{
    if(FileCopyProgress != null)
        FileCopyProgress(e.ProgressPercentage);
}

les Chemins d'accès UNC

cela devrait fonctionner avec les chemins UNC aussi longtemps que les permissions sont configurées. Si ce n'est pas le cas, vous obtiendrez cette erreur, auquel cas, je vote pour la route d'utilisateur de requête authentifiée.

System.UnauthorizedAccessException: accès au chemin '\testws01\c$\foo " est refusé.

ASP.NET n'est pas autorisé à accéder à la ressource demandée. Envisager de accorder des droits d'accès à la ressource ASP.NET demande identité. ASP.NET a une identité de processus de base (généralement {MACHINE}\ASPNET sur IIS 5 ou réseau sur IIS 6 et IIS 7, et l'identité du pool d'applications configuré sur IIS 7.5) qui est utilisé si l'application est à ne pas usurper l'identité. Si la demande est usurpation de l'identité à l'aide de <identity impersonate="true"/>, l'identité sera l'utilisateur anonyme (typiquement IUSR_MACHINENAME) ou l'authentifié demande utilisateur.

faire votre propre logique de copie de fichier en utilisant 2 streams comme présenté par Gal est une option viable, mais son pas recommandé uniquement parce qu'il ya une opération windows profondément intégré qui est optimisé dans la fiabilité, la sécurité et la performance appelé CopyFileEx.

cela dit, dans l'article suivant: http://msdn.microsoft.com/en-us/magazine/cc163851.aspx ils font exactement ce que vous voulez, mais bien sûr, vous devez utiliser CopyFileEx

bon la chance

** EDIT ** (fixe ma réponse, mal witten)

vous pouvez copier des parties du flux de fichiers de chaque fichier, et mettre à jour après chaque "morceau" que vous mettez à jour. Ainsi, il sera plus continu - vous pouvez aussi facilement calculer la taille relative du "morceau" actuel que vous copiez par rapport à la taille totale du flux afin de montrer le pourcentage correct fait.

Voici une solution optimisée qui utilise les extensions .NET et un double-buffer Pour une meilleure performance. Une nouvelle surcharge de CopyTo est ajoutée à FileInfo avec une Action qui indique la progression seulement quand elle a changé.

cet exemple de mise en œuvre dans WPF avec une barre de progression nommée progressBar1 qui effectue l'opération de copie en arrière-plan.

private FileInfo _source = new FileInfo(@"C:\file.bin");
private FileInfo _destination = new FileInfo(@"C:\file2.bin");

private void CopyFile()
{
  if(_destination.Exists)
    _destination.Delete();

  Task.Run(()=>{
    _source.CopyTo(_destination, x=>Dispatcher.Invoke(()=>progressBar1.Value = x));
  }).GetAwaiter().OnCompleted(() => MessageBox.Show("File Copied!"));
}

voici un exemple pour une application Console

class Program
{
  static void Main(string[] args)
  {
    var _source = new FileInfo(@"C:\Temp\bigfile.rar");
    var _destination = new FileInfo(@"C:\Temp\bigfile2.rar");

    if (_destination.Exists) _destination.Delete();

    _source.CopyTo(_destination, x => Console.WriteLine($"{x}% Complete"));
    Console.WriteLine("File Copied.");
  }
}

pour utiliser, créer un nouveau fichier, tel que FileInfoExtensions.cs et ajoutez ce code:

public static class FileInfoExtensions
{
  public static void CopyTo(this FileInfo file, FileInfo destination, Action<int> progressCallback)
  {
    const int bufferSize = 1024 * 1024;  //1MB
    byte[] buffer = new byte[bufferSize], buffer2 = new byte[bufferSize];
    bool swap = false;
    int progress = 0, reportedProgress = 0, read = 0;
    long len = file.Length;
    float flen = len;
    Task writer = null;

    using (var source = file.OpenRead())
    using (var dest = destination.OpenWrite())
    {
      dest.SetLength(source.Length);
      for (long size = 0; size < len; size += read)
      {
        if ((progress = ((int)((size / flen) * 100))) != reportedProgress)
          progressCallback(reportedProgress = progress);
        read = source.Read(swap ? buffer : buffer2, 0, bufferSize);
        writer?.Wait();  // if < .NET4 // if (writer != null) writer.Wait(); 
        writer = dest.WriteAsync(swap ? buffer : buffer2, 0, read);
        swap = !swap;
      }
      writer?.Wait();  //Fixed - Thanks @sam-hocevar
    }
  }
}

le double buffer fonctionne en utilisant un thread pour lire et un thread pour écrire, donc la vitesse maximale est dictée seulement par le plus lent des deux. Deux tampons sont utilisés (un double tampon), ce qui garantit que les threads de lecture et d'écriture n'utilisent jamais le même tampon en même temps.

exemple: le code lit dans le buffer 1, puis quand la lecture est terminée, une opération d'écriture commence à écrire le contenu du buffer 1. Sans attendre terminer l'écriture, le buffer est remplacé par le buffer 2 et les données sont lues dans le buffer 2 pendant que le buffer 1 est encore en cours d'écriture. Une fois la lecture terminée dans le buffer 2, Il attend que l'écriture soit terminée sur le buffer 1, commence à écrire le buffer 2, et le processus se répète. Essentiellement, 1 fil est toujours en train de lire, et on est toujours en train d'écrire.

WriteAsync overlapped I / O, qui utilise I/O ports de fin d', qui dépendent du matériel pour effectuer des opérations asynchrones plutôt que des threads, ce qui rend cela très efficace. TLDR: j'ai menti sur le fait qu'il y avait deux fils, mais le concept est le même.

Vous pouvez utiliser le répartiteur pour mettre à jour votre barre de progression .

UpdateProgressBarDelegate updatePbDelegate = new UpdateProgressBarDelegate(ProgressBar1.SetValue);

Dispatcher.Invoke(updatePbDelegate, System.Windows.Threading.DispatcherPriority.Background, new object[] { ProgressBar.ValueProperty, value });