How to call any method asynchronously in c#

Here's a way to do it:

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




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

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

看看 MSDN 的文章 使用异步和等待的异步编程，如果你能负担得起玩新的东西。它被添加到。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;
}

引用:

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

string urlContents = await client.GetStringAsync();

更多细节在 链接中。

如果你用行动。BeginInvoke () ，您在其他地方使用 必须调用 EndInvoke——框架必须在堆上保存异步调用的结果，从而导致内存泄漏。

如果不想使用异步/等待关键字跳转到 C # 5，可以在。净值4。它比使用 BeginInvoke/EndInvoke 要好得多，并且为异步作业提供了一种简洁的启动和忘记(fire-and-forget)方式:

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

如果您有调用 take 参数的方法，您可以使用 lambda 来简化调用，而不必创建委托:

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

I'm pretty sure (but admittedly not positive) that the C# 5 async/await syntax is just syntactic sugar around the Task library.

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

从.Net 4.5开始，你可以使用 Task:

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

任务。运行对任务。工厂。开始新建