Delegieren einer Aufgabe und benachrichtigt zu werden, wenn es (in C #) abgeschlossen

Question

Konzeptionell würde Ich mag folgendes zu erreichen, aber haben Mühe hatte, zu verstehen, wie es zu codieren richtig in C #:

SomeMethod { // Member of AClass{}
    DoSomething;
    Start WorkerMethod() from BClass in another thread;
    DoSomethingElse;
}

Wenn dann WorkerMethod () abgeschlossen ist, führen Sie diese:

void SomeOtherMethod()  // Also member of AClass{}
{ ... }

Kann jemand bitte ein Beispiel für das geben?

Answer 1

Die Background Klasse wurde hinzugefügt, um .NET 2.0 für genau diesen Zweck.

Auf den Punkt gebracht Sie tun:

BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate { myBClass.DoHardWork(); }
worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(SomeOtherMethod);
worker.RunWorkerAsync();

Sie können auch ausgefallene Sachen wie Löschung und Fortschritt hinzufügen berichten, wenn Sie wollen:)

Answer 2

In .Net 2 die Background eingeführt wurde, das macht async Operationen läuft einfach:

BackgroundWorker bw = new BackgroundWorker { WorkerReportsProgress = true };

bw.DoWork += (sender, e) => 
   {
       //what happens here must not touch the form
       //as it's in a different thread
   };

bw.ProgressChanged += ( sender, e ) =>
   {
       //update progress bars here
   };

bw.RunWorkerCompleted += (sender, e) => 
   {
       //now you're back in the UI thread you can update the form
       //remember to dispose of bw now
   };

worker.RunWorkerAsync();

In .Net 1 Sie haben Threads zu verwenden.

Answer 3

Sie haben AsyncCallBacks zu verwenden. Sie können AsyncCallBacks verwenden einen Delegierten auf ein Verfahren zu spezifizieren, und dann Callback-Methoden angeben, die aufgerufen werden, wenn die Ausführung des Ziel Verfahren abgeschlossen ist.

Hier ein kleines Beispiel ist, laufen und sehen Sie selbst.

class Program     {

    public delegate void AsyncMethodCaller();


    public static void WorkerMethod()
    {
        Console.WriteLine("I am the first method that is called.");
        Thread.Sleep(5000);
        Console.WriteLine("Exiting from WorkerMethod.");
    }

    public static void SomeOtherMethod(IAsyncResult result)
    {
        Console.WriteLine("I am called after the Worker Method completes.");
    }



    static void Main(string[] args)
    {
        AsyncMethodCaller asyncCaller = new AsyncMethodCaller(WorkerMethod);
        AsyncCallback callBack = new AsyncCallback(SomeOtherMethod);
        IAsyncResult result = asyncCaller.BeginInvoke(callBack, null);
        Console.WriteLine("Worker method has been called.");
        Console.WriteLine("Waiting for all invocations to complete.");
        Console.Read();

    }
}

Answer 4

Zwar gibt es mehrere Möglichkeiten hier, würde ich einen Delegaten verwenden, asynchron BeginInvoke Methode aufgerufen werden.

Warnung : vergessen Sie nicht immer EndInvoke auf dem IAsyncResult zu nennen eventuelle Speicherlecks zu vermeiden, wie in dieser Artikel .

Answer 5

Überprüfen Sie heraus Background.

Answer 6

Mit Async Delegierten:

// Method that does the real work
public int SomeMethod(int someInput)
{
Thread.Sleep(20);
Console.WriteLine(”Processed input : {0}”,someInput);
return someInput+1;
} 


// Method that will be called after work is complete
public void EndSomeOtherMethod(IAsyncResult result)
{
SomeMethodDelegate myDelegate = result.AsyncState as SomeMethodDelegate;
// obtain the result
int resultVal = myDelegate.EndInvoke(result);
Console.WriteLine(”Returned output : {0}”,resultVal);
}

// Define a delegate
delegate int SomeMethodDelegate(int someInput);
SomeMethodDelegate someMethodDelegate = SomeMethod;

// Call the method that does the real work
// Give the method name that must be called once the work is completed.
someMethodDelegate.BeginInvoke(10, // Input parameter to SomeMethod()
EndSomeOtherMethod, // Callback Method
someMethodDelegate); // AsyncState

Answer 7

Ok, ich bin nicht sicher, wie Sie darüber gehen wollen. Von Ihrem Beispiel sieht es aus wie WorkerMethod keinen eigenen Thread erstellt unter auszuführen, aber Sie wollen auf einem anderen Thread, dass die Methode aufzurufen.

In diesem Fall erzeugt eine kurzen Arbeiter Methode, die WorkerMethod ruft dann ruft SomeOtherMethod, und das Verfahren auf einem anderen Thread anstehen. Dann, wenn WorkerMethod abgeschlossen ist, wird SomeOtherMethod genannt. Zum Beispiel:

public class AClass
{
    public void SomeMethod()
    {
        DoSomething();

        ThreadPool.QueueUserWorkItem(delegate(object state)
        {
            BClass.WorkerMethod();
            SomeOtherMethod();
        });

        DoSomethingElse();
    }

    private void SomeOtherMethod()
    {
        // handle the fact that WorkerMethod has completed. 
        // Note that this is called on the Worker Thread, not
        // the main thread.
    }
}