Async Barre De Progression Mise À Jour

Je suis en train d'utiliser un async await de mettre à jour une barre de progression sur mon WinForm basé sur une opération de copie, mais la barre de progression ne mettra à jour que lorsque le Copy fonction a fini, et puis lève une exception qu'il ne peut pas mettre à jour car il n'est pas sur le même thread?

La fonction de Copie n'a pas besoin d'interagir avec l'INTERFACE utilisateur, mais les Progrès de la fonction.

L'INTERFACE utilisateur n'est pas bloqué, donc il semble que la async partie fonctionne comme prévu, c'est juste de l'interaction avec le thread d'INTERFACE utilisateur qui ne l'est pas.

long fileProgress = 0;
long totalProgress = 0;
bool complete = false;

CopyFileEx.CopyFileCallbackAction callback(FileInfo source, FileInfo destination, object state, long totalFileSize, long totalBytesTransferred)
{
      fileProgress = totalBytesTransferred;
      totalProgress = totalFileSize;
      return CopyFileEx.CopyFileCallbackAction.Continue;
}

async Task Progress()
{
      await Task.Run(() =>
      {
           while (!complete)
           {
                if (fileProgress != 0 && totalProgress != 0)
                {
                     fileProgressBar.Value = (int)(fileProgress / totalProgress) * 100;
                }
           }
      });
}

private async void startButton_Click(object sender, EventArgs e)
{
      Copy();
      await Progress();
      MessageBox.Show("Done");
}

void Copy()
{
      Task.Run(() =>
      {
           CopyFileEx.FileRoutines.CopyFile(new FileInfo(@"C:\_USB\Fear.rar"), new FileInfo(@"H:\Fear.rar"), CopyFileEx.CopyFileOptions.All, callback, null);
           complete = true;
      });
}

OriginalL'auteur Bali C | 2016-03-31

async-await c#

async /await c'est de ne pas bloquer un thread un thread - lorsque vous traitez avec des I/O. de Mettre un blocage appel d'e/S à l'intérieur de Task.Run() (comme vous l'avez fait dans Copy()) n'est pas d'éviter le blocage - il suffit de créer une Tâche à un autre thread sera plus tard pick up, juste pour le trouver lui-même est bloqué quand il frappe le blocage CopyFileEx.FileRoutines.CopyFile() méthode.
Vous obtenez cette erreur, parce que vous n'êtes pas à l'aide de async /await correctement (quel que soit le ci-dessus). Pensez à le thread qui est en essayant de modifier l'INTERFACE utilisateur de l'objet fileProgressBar: le hasard de pool de threads thread qui ramasse la Tâche que vous créez sur Task.Run() obtient exécuter fileProgressBar.Value = ..., qui sera bien évidemment de le jeter.

C'est une façon d'éviter cette situation:

async Task Progress()
{
      await Task.Run(() =>
      {
           //A random threadpool thread executes the following:
           while (!complete)
           {
                if (fileProgress != 0 && totalProgress != 0)
                { 
                    //Here you signal the UI thread to execute the action:
                    fileProgressBar.Invoke(new Action(() => 
                    { 
                        //This is done by the UI thread:
                        fileProgressBar.Value = (int)(fileProgress / totalProgress) * 100 
                    }));
                }
           }
      });
}

private async void startButton_Click(object sender, EventArgs e)
{
      await Copy();
      await Progress();
      MessageBox.Show("Done");  //here we're on the UI thread.
}

async Task Copy()
{
    //You need find an async API for file copy, and System.IO has a lot to offer.
    //Also, there is no reason to create a Task for MyAsyncFileCopyMethod - the UI
    //will not wait (blocked) for the operation to complete if you use await:
    await MyAsyncFileCopyMethod();
    complete = true;
}

Merci, cela a bien fonctionné.
Soulignant que fileProgressBar.Invoke(() => {...}); ne compile pas, vous devez utiliser un type délégué tels que: fileProgressBar.Invoke(new Action(() => {...}));

OriginalL'auteur shay__

Vous devez utiliser IProgress<T> ici :

private async void startButton_Click(object sender, EventArgs e)
{
      var progress = new Progress<int>(percent =>
      {
         fileProgressBar.Value = percent;
      });

      await Copy(progress);

      MessageBox.Show("Done");
}

void Copy(IProgress<int> progress)
{
      Task.Run(() =>
      {
           CopyFileEx.FileRoutines.CopyFile(new FileInfo(@"C:\_USB\Fear.rar"), new FileInfo(@"H:\Fear.rar"), CopyFileEx.CopyFileOptions.All, callback, null,progress);
           complete = true;
      });
}

et votre méthode de rappel peut rendre compte du progrès de IProgress<T> comme:

CopyFileEx.CopyFileCallbackAction callback(FileInfo source, FileInfo destination, object state, long totalFileSize, long totalBytesTransferred,IProgress<int> progress)
{
      fileProgress = totalBytesTransferred;
      totalProgress = totalFileSize;
      progress.Report(Convert.ToInt32(fileProgress/totalProgress));
      return CopyFileEx.CopyFileCallbackAction.Continue;
}

Vous pouvez regarder ce très bon article de Stephen Cleary

OriginalL'auteur Ehsan Sajjad

4

Lors de l'utilisation de async/await-je utiliser le IProgress et de Progrès mises en œuvre, qui abstraire certains de la fonction de rappel de détails.

Im assez sûr de ce que vous avez il n'y a pas de travail parce qu'elle est exécutée dans un thread d'arrière-plan via la Tâche.Run() de l'appel, de sorte qu'il ne peut pas vraiment accès à des commandes de l'INTERFACE qui sont dans le thread de l'INTERFACE utilisateur contexte.

Découvrez cet article sur les rapports de progrès avec async/await, je pense que ça va aider.

http://blog.stephencleary.com/2012/02/reporting-progress-from-async-tasks.html

Dans votre implémentation actuelle si vous en avez toujours rêvé de travailler avec le rappel, je pense que je viens de mettre à jour la barre de progression directement dans votre méthode de rappel au lieu de vérification de l'état de l'avancement des variables dans une boucle, ce qui va bloquer votre INTERFACE utilisateur lorsque vous la sortez de la thread d'arrière-plan pour accéder à la barre de progression.

OriginalL'auteur davidallyoung

Vous devez vous connecter pour publier un commentaire.