如何使一个异步方法返回一个值？

Question

我知道如何使异步方法，但说我有一个方法，做了很多工作，然后返回一个布尔值？

如何返回回调的布尔值？

澄清：

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

我希望能够让这个异步的。

Answer 1

有这样做的几种方法......最简单的就是有异步方法也做了后续操作。另一种流行的方法是在一个回调来传递，即

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

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

另一种方法是提高一个事件（其结果在事件ARGS数据）时，异步操作完成。

此外，如果您使用的是第三方物流，可以使用ContinueWith：

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

Answer 2

使用BackgroundWorker。它可以让你完成回调，并让你跟踪进度。您可以将事件参数的结果值设置为结果值。

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

Answer 3

你应该用你的异步方法的EndXXX返回值。 EndXXX应该等到使用IAsyncResult的WaitHandle有结果并返回值。

Answer 4

从C# 5.0，你可以指定方法

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

bool result = await doAsyncOperation(); 

Answer 5

也许这样做是为了创建一个委托，然后BeginInvoke，然后在未来的某个时间等待的最简单方法，以及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); 
} 

Answer 6

或许你可以尝试的BeginInvoke委托指向你的方法，像这样：

 


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

然后使用您发送的AsyncCallback的继续该方法的价值..