Wie kann eine asynchrone Methode einen Wert zurückgeben?

Ich weiß, wie man Async-Methoden erstellt, sage aber, dass ich eine Methode habe, die viel Arbeit leistet und dann einen booleschen Wert zurückgibt.

Wie gebe ich den booleschen Wert beim Rückruf zurück?

Klarstellung :

public bool Foo(){
    Thread.Sleep(100000); // Do work
    return true;
}

Ich möchte dies asynchron machen können.

Es gibt einige Möglichkeiten, dies zu tun. Am einfachsten ist es, wenn die asynchrone Methode auch die Folgeoperation ausführt. Ein anderer beliebter Ansatz ist die Weitergabe eines Rückrufs, d. H.

void RunFooAsync(..., Action<bool> callback) {
     // do some stuff
     bool result = ...

     if(callback != null) callback(result);
}

Ein anderer Ansatz wäre, ein Ereignis (mit dem Ergebnis in den Ereignisargumentdaten) auszulösen, wenn der asynchrone Vorgang abgeschlossen ist.

Wenn Sie die TPL verwenden, können Sie außerdem Folgendes verwenden ContinueWith:

Task<bool> outerTask = ...;
outerTask.ContinueWith(task =>
{
    bool result = task.Result;
    // do something with that
});

Ab C # 5.0 können Sie die Methode als angeben

public async Task<bool> doAsyncOperation()
{
    // do work
    return true;
}

bool result = await doAsyncOperation();

Der wahrscheinlich einfachste Weg, dies zu tun, besteht darin, einen Delegaten zu erstellen und dann BeginInvoke, gefolgt von einem Warten zu einem späteren Zeitpunkt, und einem EndInvoke.

public bool Foo(){
    Thread.Sleep(100000); // Do work
    return true;
}

public SomeMethod()
{
    var fooCaller = new Func<bool>(Foo);
    // Call the method asynchronously
    var asyncResult = fooCaller.BeginInvoke(null, null);

    // Potentially do other work while the asynchronous method is executing.

    // Finally, wait for result
    asyncResult.AsyncWaitHandle.WaitOne();
    bool fooResult = fooCaller.EndInvoke(asyncResult);

    Console.WriteLine("Foo returned {0}", fooResult);
}

Verwenden Sie einen BackgroundWorker. Sie erhalten nach Abschluss Rückrufe und können den Fortschritt verfolgen. Sie können den Ergebniswert für die Ereignisargumente auf den resultierenden Wert setzen.

    public void UseBackgroundWorker()
    {
        var worker = new BackgroundWorker();
        worker.DoWork += DoWork;
        worker.RunWorkerCompleted += WorkDone;
        worker.RunWorkerAsync("input");
    }

    public void DoWork(object sender, DoWorkEventArgs e)
    {
        e.Result = e.Argument.Equals("input");
        Thread.Sleep(1000);
    }

    public void WorkDone(object sender, RunWorkerCompletedEventArgs e)
    {
        var result = (bool) e.Result;
    }

Vielleicht können Sie versuchen, einen Delegaten zu beginnen, der auf Ihre Methode verweist:

    delegate string SynchOperation(string value);

    class Program
    {
        static void Main(string[] args)
        {
            BeginTheSynchronousOperation(CallbackOperation, "my value");
            Console.ReadLine();
        }

        static void BeginTheSynchronousOperation(AsyncCallback callback, string value)
        {
            SynchOperation op = new SynchOperation(SynchronousOperation);
            op.BeginInvoke(value, callback, op);
        }

        static string SynchronousOperation(string value)
        {
            Thread.Sleep(10000);
            return value;
        }

        static void CallbackOperation(IAsyncResult result)
        {
            // get your delegate
            var ar = result.AsyncState as SynchOperation;
            // end invoke and get value
            var returned = ar.EndInvoke(result);

            Console.WriteLine(returned);
        }
    }

Verwenden Sie dann den Wert in der Methode, die Sie als AsyncCallback gesendet haben, um fortzufahren.

Sie sollten das EndXXX Ihrer asynchronen Methode verwenden, um den Wert zurückzugeben. EndXXX sollte warten, bis mit dem WaitHandle des IAsyncResult ein Ergebnis vorliegt, und dann mit dem Wert zurückkehren.