Come chiamare qualsiasi metodo in modo asincrono in c #

Qualcuno potrebbe mostrarmi un piccolo frammento di codice che dimostra come chiamare un metodo in modo asincrono in c #?

Se usi action.BeginInvoke (), devi chiamare EndInvoke da qualche parte, altrimenti il ​​framework deve contenere il risultato della chiamata asincrona sull'heap, con conseguente perdita di memoria.

Se non vuoi passare a C # 5 con le parole chiave async / await, puoi semplicemente usare la libreria Task Parallels in .Net 4. È molto, molto più bello che usare BeginInvoke / EndInvoke e offre un modo pulito per sparare- e dimentica per i lavori asincroni:

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

Se disponi di metodi per chiamare che accettano parametri, puoi usare un lambda per semplificare la chiamata senza dover creare delegati:

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

Sono abbastanza sicuro (ma certamente non positivo) che la sintassi asincrona / attesa di C # 5 sia solo zucchero sintattico attorno alla libreria Task.

A partire da .Net 4.5 puoi utilizzare Task.Run per avviare semplicemente un'azione:

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

Task.Run vs Task.Factory.StartNew

Ecco un modo per farlo:

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


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

Ovviamente è necessario sostituire Actioncon un altro tipo di delegato se il metodo ha una firma diversa

Consulta l'articolo MSDN sulla programmazione asincrona con Async e Await se puoi permetterti di giocare con nuove cose. È stato aggiunto a .NET 4.5.

Esempio di frammento di codice dal collegamento (che è esso stesso da questo progetto di codice di esempio 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;
}

citando:

Se AccessTheWebAsyncnon ha alcun lavoro che può fare tra la chiamata di GetStringAsync e l'attesa del suo completamento, puoi semplificare il tuo codice chiamando e attendendo nella seguente istruzione singola.

string urlContents = await client.GetStringAsync();

Maggiori dettagli sono nel link .

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