Cách gọi bất kỳ phương thức không đồng bộ nào trong c #

Ai đó có thể vui lòng cho tôi xem một đoạn mã nhỏ giải thích cách gọi một phương thức không đồng bộ trong c # không?

Nếu bạn sử dụng action.BeginInvoke (), bạn phải gọi EndInvoke ở đâu đó - nếu không thì khung công tác phải giữ kết quả của lệnh gọi không đồng bộ trên heap, dẫn đến rò rỉ bộ nhớ.

Nếu bạn không muốn chuyển đến C # 5 với các từ khóa async / await, bạn có thể sử dụng thư viện Task Parallels trong .Net 4. Nó đẹp hơn nhiều so với việc sử dụng BeginInvoke / EndInvoke và cung cấp một cách dễ dàng để kích hoạt- và-quên đối với các công việc không đồng bộ:

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

Nếu bạn có các phương thức để gọi có tham số, bạn có thể sử dụng lambda để đơn giản hóa việc gọi mà không cần phải tạo đại diện:

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

Tôi khá chắc chắn (nhưng phải thừa nhận là không tích cực) rằng cú pháp C # 5 async / await chỉ là một đường cú pháp xung quanh thư viện Tác vụ.

Bắt đầu với .Net 4.5, bạn có thể sử dụng Task.Run để bắt đầu một hành động đơn giản:

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

Task.Run so với Task.Factory.StartNew

Đây là một cách để làm điều đó:

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


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

Tất nhiên, bạn cần thay thế Actionbằng một loại đại biểu khác nếu phương thức có chữ ký khác

Hãy xem bài viết MSDN Lập trình không đồng bộ với Async và Await nếu bạn có đủ khả năng để chơi với những thứ mới. Nó đã được thêm vào .NET 4.5.

Đoạn mã mẫu từ liên kết (chính là từ dự án mã mẫu MSDN này ):

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

Trích dẫn:

Nếu AccessTheWebAsynckhông có bất kỳ công việc nào mà nó có thể thực hiện giữa việc gọi GetStringAsync và chờ hoàn thành, bạn có thể đơn giản hóa mã của mình bằng cách gọi và chờ trong câu lệnh đơn sau.

string urlContents = await client.GetStringAsync();

Thông tin chi tiết có trong liên kết .

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