Como chamar qualquer método de forma assíncrona em c #

Alguém poderia me mostrar um pequeno trecho de código que demonstra como chamar um método de forma assíncrona em c #?

Se você usar action.BeginInvoke (), terá que chamar EndInvoke em algum lugar - caso contrário, a estrutura terá que manter o resultado da chamada assíncrona no heap, resultando em um vazamento de memória.

Se você não quiser pular para C # 5 com as palavras-chave async / await, você pode apenas usar a biblioteca Task Parallels no .Net 4. É muito, muito mais agradável do que usar BeginInvoke / EndInvoke e oferece uma maneira limpa de disparar e esqueça para trabalhos assíncronos:

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

Se você tiver métodos para chamar esses parâmetros, poderá usar um lambda para simplificar a chamada sem ter que criar delegados:

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

Tenho certeza (mas não tenho certeza) de que a sintaxe assíncrona / esperar do C # 5 é apenas um açúcar sintático na biblioteca de tarefas.

Começando com .Net 4.5, você pode usar Task.Run para simplesmente iniciar uma ação:

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

Task.Run vs Task.Factory.StartNew

Esta é uma maneira de fazer isso:

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


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

Claro que você precisa substituir Actionpor outro tipo de delegado se o método tiver uma assinatura diferente

Consulte o artigo do MSDN Assynchronous Programming with Async and Await se você puder se dar ao luxo de brincar com coisas novas. Ele foi adicionado ao .NET 4.5.

Exemplo de snippet de código do link (que é deste projeto de código de amostra do 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 AccessTheWebAsyncnão houver nenhum trabalho que possa ser feito entre chamar GetStringAsync e aguardar sua conclusão, você pode simplificar seu código chamando e aguardando na seguinte instrução única.

string urlContents = await client.GetStringAsync();

Mais detalhes estão no 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));
        }
    }