Делегируя задачу в и будучи уведомленным, когда это завершается (в C#)

Необходимо использовать AsyncCallBacks. Можно использовать AsyncCallBacks, чтобы указать делегата в методе и затем указать Методы обратного вызова, которые называют, после того как выполнение целевого метода завершается.

Вот небольшой Пример, выполненный, и посмотрите его для себя.

класс Программа {

    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();

    }
}

В.Net 2 был представлен BackgroundWorker, это делает рабочие асинхронные операции действительно легкими:

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();

В.Net 1 необходимо использовать потоки.

Хотя существует несколько возможностей здесь, я использовал бы делегата, асинхронно названное использование BeginInvoke метод.

Предупреждение: не забывайте всегда звонить EndInvoke на IAsyncResult избегать возможных утечек памяти, как описано в этой статье.

Выезд BackgroundWorker.

Используйте асинхронных делегатов:

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

Хорошо, я не уверен в том, как Вы хотите пойти об этом. От Вашего примера похоже, что WorkerMethod не создает свой собственный поток для выполнения под, но Вы хотите назвать тот метод на другом потоке.

В этом случае создайте короткий метод рабочего, который звонит, WorkerMethod затем называет SomeOtherMethod и очередь что метод на другом потоке. Затем, когда WorkerMethod завершается, SomeOtherMethod называют. Например:

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