rappel/délégué?

Question

j'ai un doute ..

je voudrais créer une fonction et il ressemblera à ceci ...

public class A  //this is just a class file 
{ 
    function dowork() 
    { 
     //work 1 

     INPUT = here in this line it should call a delegate function or raise event etc... 

     //work 2 using INPUT 
    } 
} 

public class B 
{ 
    function myfn() 
    { 
     A objA = new A(); 
     objA.dowork(); 

    } 
} 

En nous soulèverons « classe A » événement ou si & il sera afficher une forme de fenêtres à l'utilisateur et l'utilisateur saisira une valeur & nous devons retourner cette valeur à la classe a -> méthode DoWork .... alors que nous devrions continuer à « travailler 2 »

cela devrait également prendre en charge multi threading ... quelqu'un a une idée de comment nous pouvons mettre en œuvre ce ??

merci :)

Answer 1

Vous pouvez utiliser ManulResetEvent à cette fin: Vous exécutez votre formulaire d'entrée et quand il fait cette forme définissez l'événement afin que vous puissiez l'attraper de méthode A.dowork. Alors que l'entrée en action vous exécutez la boucle infinie, vérifier l'état et le processus événement pour vous faire application responsable cette fois l'application de l'événement:

public class A  //this is just a class file 
{ 
    private ManualResetEvent _event; 

    public void dowork() 
    { 
    //work 1 

    _event = new ManualResetEvent(false); 
    //INPUT = here in this ... 
    Worker worker = new Worker(); 
    worker.DoInput(_event); 

    while(true) 
    { 
     if(_event.WaitOne()) 
     break; 
     Application.DoEvents(); 
    } 

    //work 2 using INPUT 
    } 
} 

class Worker 
{ 
    private ManualResetEvent _event; 

    public void DoInput(ManualResetEvent @event) 
    { 
    _event = @event; 

    // Show input form here. 
    // When it done, you call: _event.Set(); 
    } 
} 

Aussi, je vous suggère (si vous pouvez) utiliser la bibliothèque Async (il est disponible en configuration autonome). Là, vous pouvez le mettre en œuvre de manière beaucoup plus simple:

public class A  //this is just a class file 
{ 
    public async void dowork() 
    { 
    //work 1 

    //INPUT = here in this ... 
    Worker worker = new Worker(); 
    wait worker.DoInput(); 

    //work 2 using INPUT 
    } 
} 

class Worker 
{ 
    public async void DoInput() 
    { 
    InputForm form = new InputForm(); 
    wait form.ShowInput(); 
    } 
} 

public class B 
{ 
    async void myfn() 
    { 
    A objA = new A(); 
    wait objA.dowork(); 
    } 
} 

Comme vous voyez que vous attendez juste tandis que d'autres morceau de code exécuté sans se verrouillage de l'interface utilisateur et les événements. Je peux fournir une explication plus détaillée de la façon dont async/wait fonctionne ici si vous en avez besoin. Que voulez-vous dire lorsque vous dites Windows Form?