如何在C#中异步调用任意方法

Question

请问有人能给我展示一小段代码，演示如何在C＃中异步调用方法吗？

- Thomas

Answer 1

如果您使用action.BeginInvoke()，则必须在某处调用EndInvoke - 否则框架必须将异步调用的结果保存在堆上，从而导致内存泄漏。

如果您不想使用C# 5中的async/await关键字，那么可以在.Net 4中使用任务并行库。它比使用BeginInvoke/EndInvoke要好得多，并提供了一种干净的方式来启动和忘记异步作业：

using System.Threading.Tasks;
...
void Foo(){}
...
new Task(Foo).Start();

如果您有需要传递参数的方法，您可以使用lambda来简化调用，而无需创建委托：

void Foo2(int x, string y)
{
    return;
}
...
new Task(() => { Foo2(42, "life, the universe, and everything");}).Start();

我相信（但承认不确定）C# 5的async/await语法只是对Task库的语法糖。

- Drew Shafer

---

如果还不清楚，关于async/await的最终假设是正确的，但它将极大地改变你的代码外观。 - Gusdor

我正在尝试使用创建事件和委托的方法，这样做正确吗？如果是这样，我该如何结束任务。谢谢。 - Joster

Answer 2

从 .Net 4.5 开始，您可以使用 Task.Run 来简单地启动一个操作：

void Foo(string args){}
...
Task.Run(() => Foo("bar"));

Task.Run与Task.Factory.StartNew的区别

- ms007

Answer 3

这里是一种实现方式：

// The method to call
void Foo()
{
}


Action action = Foo;
action.BeginInvoke(ar => action.EndInvoke(ar), null);

当然，如果方法具有不同的签名，就需要使用另一种类型的委托来替换Action。

- Thomas Levesque

---

当我们调用foo函数时，如何传递你没有展示的参数？ - Thomas

你可以放一个对象来代替 null。让 Foo 接受一个类型为 object 的输入参数。然后你需要在 Foo 中将该对象转换为适当的类型。 - Denise Skidmore

Answer 4

如果你有时间尝试新的东西，可以查看MSDN文章使用Async和Await进行异步编程。它被添加到.NET 4.5中。

来自链接的示例代码段（本身来自这个MSDN示例代码项目）：

// Three things to note in the signature: 
//  - The method has an async modifier.  
//  - The return type is Task or Task<T>. (See "Return Types" section.)
//    Here, it is Task<int> because the return statement returns an integer. 
//  - The method name ends in "Async."
async Task<int> AccessTheWebAsync()
{ 
    // You need to add a reference to System.Net.Http to declare client.
    HttpClient client = new HttpClient();

    // GetStringAsync returns a Task<string>. That means that when you await the 
    // task you'll get a string (urlContents).
    Task<string> getStringTask = client.GetStringAsync("http://msdn.microsoft.com");

    // You can do work here that doesn't rely on the string from GetStringAsync.
    DoIndependentWork();

    // The await operator suspends AccessTheWebAsync. 
    //  - AccessTheWebAsync can't continue until getStringTask is complete. 
    //  - Meanwhile, control returns to the caller of AccessTheWebAsync. 
    //  - Control resumes here when getStringTask is complete.  
    //  - The await operator then retrieves the string result from getStringTask. 
    string urlContents = await getStringTask;

    // The return statement specifies an integer result. 
    // Any methods that are awaiting AccessTheWebAsync retrieve the length value. 
    return urlContents.Length;
}

引用：

如果在调用GetStringAsync和等待其完成之间，AccessTheWebAsync没有任何工作可做，您可以通过以下单个语句调用并等待来简化代码。

string urlContents = await client.GetStringAsync();

更多细节请参见链接。

- Michael Blake

---

我该如何使用这种技术并设置超时时间？ - Su Llewellyn

Answer 5

public partial class MainForm : Form
{
    Image img;
    private void button1_Click(object sender, EventArgs e)
    {
        LoadImageAsynchronously("http://media1.santabanta.com/full5/Indian%20%20Celebrities(F)/Jacqueline%20Fernandez/jacqueline-fernandez-18a.jpg");
    }

    private void LoadImageAsynchronously(string url)
    {
        /*
        This is a classic example of how make a synchronous code snippet work asynchronously.
        A class implements a method synchronously like the WebClient's DownloadData(…) function for example
            (1) First wrap the method call in an Anonymous delegate.
            (2) Use BeginInvoke(…) and send the wrapped anonymous delegate object as the last parameter along with a callback function name as the first parameter.
            (3) In the callback method retrieve the ar's AsyncState as a Type (typecast) of the anonymous delegate. Along with this object comes EndInvoke(…) as free Gift
            (4) Use EndInvoke(…) to retrieve the synchronous call’s return value in our case it will be the WebClient's DownloadData(…)’s return value.
        */
        try
        {
            Func<Image> load_image_Async = delegate()
            {
                WebClient wc = new WebClient();
                Bitmap bmpLocal = new Bitmap(new MemoryStream(wc.DownloadData(url)));
                wc.Dispose();
                return bmpLocal;
            };

            Action<IAsyncResult> load_Image_call_back = delegate(IAsyncResult ar)
            {
                Func<Image> ss = (Func<Image>)ar.AsyncState;
                Bitmap myBmp = (Bitmap)ss.EndInvoke(ar);

                if (img != null) img.Dispose();
                if (myBmp != null)
                    img = myBmp;
                Invalidate();
                //timer.Enabled = true;
            };
            //load_image_Async.BeginInvoke(callback_load_Image, load_image_Async);             
            load_image_Async.BeginInvoke(new AsyncCallback(load_Image_call_back), load_image_Async);             
        }
        catch (Exception ex)
        {

        }
    }
    protected override void OnPaint(PaintEventArgs e)
    {
        if (img != null)
        {
            Graphics grfx = e.Graphics;
            grfx.DrawImage(img,new Point(0,0));
        }
    }

- Dr.Sai