Delegeer 'n taak in en word in kennis gestel wanneer dit voltooi is (in C#)

Question

Konseptueel wil ek graag die volgende bereik, maar het probleme gehad om te verstaan ​​hoe om dit behoorlik in C# te kodeer:

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

Dan, wanneer WorkerMethod() voltooi is, voer dit uit:

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

Kan iemand asseblief 'n voorbeeld daarvan gee?

Answer 1

Die Agtergrondwerker klas is vir hierdie presiese doel by .NET 2.0 gevoeg.

In 'n neutedop doen jy:

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

Jy kan ook fancy goed soos kansellasie en vorderingsverslaggewing byvoeg as jy wil :)

Answer 2

In .Net 2 is die BackgroundWorker bekendgestel, dit maak dit baie maklik om asynchrone bewerkings uit te voer:

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 moet jy drade gebruik.

Answer 3

Jy moet AsyncCallBacks gebruik.U kan AsyncCallBacks gebruik om 'n afgevaardigde na 'n metode te spesifiseer, en dan CallBack-metodes spesifiseer wat opgeroep word sodra die uitvoering van die teikenmetode voltooi is.

Hier is 'n klein voorbeeld, hardloop en sien dit self.

klasprogram {

    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

Alhoewel daar verskeie moontlikhede hier is, sal ek 'n afgevaardigde gebruik, asinchroon genoem gebruik BeginInvoke metode.

Waarskuwing :moenie vergeet om altyd te bel nie EndInvoke op die IAsyncResult om uiteindelike geheuelekkasies te vermy, soos beskryf in Hierdie artikel.

Answer 5

Kyk na BackgroundWorker.

Answer 6

Gebruik Async Delegates:

// 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

Goed, ek is onseker oor hoe jy te werk wil gaan.Uit jou voorbeeld lyk dit of WorkerMethod nie sy eie draad skep om onder uit te voer nie, maar jy wil daardie metode op 'n ander draad noem.

In daardie geval, skep 'n kort werker-metode wat WorkerMethod roep, roep dan SomeOtherMethod, en plaas daardie metode op 'n ander draad.Dan wanneer WorkerMethod voltooi is, word SomeOtherMethod genoem.Byvoorbeeld:

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.
    }
}