Obtention des rapports d'avancement d'une classe de travailleurs en couches?

Question

J'ai une classe de travailleurs en couches dont j'essaie d'obtenir des rapports d'avancement. Ce que je ressemble à ceci:

public class Form1 
{ 
    private void Start_Click() 
    { 
     Controller controller = new Controller(); 

     controller.RunProcess(); 
    } 
} 

public class Controller 
{ 
    public void RunProcess() 
    { 
     Thread newThread = new Thread(new ThreadStart(DoEverything)); 
     newThread.Start(); 
    } 

    private void DoEverything() 
    { 
     // Commencing operation... 
     Class1 class1 = new Class1(); 

     class1.DoStuff(); 

     Class2 class2 = new Class2(); 

     class2.DoMoreStuff(); 
    } 

} 

public class Class1 
{ 
    public void DoStuff() 
    { 
     // Doing stuff 
     Thread.Sleep(1000); 

     // Want to report progress here 
    } 
} 

public class Class2 
{ 
    public void DoMoreStuff() 
    { 
     // Doing more stuff 
     Thread.Sleep(2000); 

     // Want to report progress here as well 
    } 
} 

Je l'ai utilisé la classe BackgroundWorker, mais je pense que je besoin de quelque chose un peu plus de forme libre pour quelque chose comme ça. Je pense que je pourrais utiliser une solution de délégué/événement, mais je ne suis pas sûr de savoir comment l'appliquer ici. Disons que j'ai quelques étiquettes ou quelque chose sur Form1 que je veux pouvoir mettre à jour avec les progrès de class1 et de class2, quelle est la meilleure façon de le faire?

Answer 1

L'utilisation d'événements est la solution la plus simple. Lorsque vous vous abonnez à l'événement à partir du thread principal, le gestionnaire doit vérifier le Control.IsInvokeRequired pour savoir s'il doit se rappeler à Invoke(...) pour que le message soit transmis au bon thread.

Answer 2

John a raison. Vous voulez utiliser des événements et pour cela, vous devrez utiliser un délégué ou des délégués. Cela pourrait vous donner quelques idées.

http://www.yoda.arachsys.com/csharp/threads/winforms.shtml

Answer 3

Si vous ne voulez pas bloquer les threads de traitement pendant la notification, vous pouvez utiliser Control.BeginInvoke() pour le feu & oublier le comportement.

Pour réduire le nombre d'appels et mettre à jour la progression sur un intervalle normal, vous souhaiterez peut-être encapsuler les états des différentes opérations dans les classes.
De cette façon, vous pouvez simplement écrire des états, par ex. champs volatiles - probablement une autre classe d'état agrégé - et utilisez une minuterie sur le thread graphique pour relire l'état et rafraîchir les étiquettes en conséquence.