Bagaimana memanggil metode apapun secara asynchronous di c #

Bisakah seseorang menunjukkan kepada saya potongan kecil kode yang menunjukkan cara memanggil metode secara asinkron di c #?

Jika Anda menggunakan action.BeginInvoke (), Anda harus memanggil EndInvoke di suatu tempat - jika tidak, framework harus menahan hasil panggilan asinkron di heap, yang mengakibatkan kebocoran memori.

Jika Anda tidak ingin melompat ke C # 5 dengan kata kunci async / await, Anda dapat menggunakan pustaka Task Parallels di .Net 4. Ini jauh, jauh lebih bagus daripada menggunakan BeginInvoke / EndInvoke, dan memberikan cara yang bersih untuk mengaktifkan- dan-lupakan untuk pekerjaan asinkron:

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

Jika Anda memiliki metode untuk memanggil parameter take itu, Anda dapat menggunakan lambda untuk menyederhanakan panggilan tanpa harus membuat delegasi:

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

Saya cukup yakin (tetapi diakui tidak positif) bahwa sintaks C # 5 async / await hanyalah gula sintaksis di sekitar pustaka Tugas.

Dimulai dengan .Net 4.5 Anda dapat menggunakan Task.Run untuk memulai tindakan:

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

Task.Run vs Task.Factory.StartNew

Berikut cara melakukannya:

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


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

Tentu saja Anda perlu mengganti Actiondengan tipe delegasi lain jika metode tersebut memiliki tanda tangan yang berbeda

Lihat artikel MSDN Pemrograman Asinkron dengan Async dan Tunggu jika Anda mampu bermain dengan hal-hal baru. Itu ditambahkan ke .NET 4.5.

Contoh potongan kode dari tautan (yang berasal dari proyek kode contoh MSDN ini ):

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

Mengutip:

Jika AccessTheWebAsynctidak memiliki pekerjaan apa pun yang dapat dilakukan antara memanggil GetStringAsync dan menunggu penyelesaiannya, Anda dapat menyederhanakan kode Anda dengan memanggil dan menunggu dalam pernyataan tunggal berikut.

string urlContents = await client.GetStringAsync();

Lebih detail ada di tautan .

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