Jak wywołać dowolną metodę asynchronicznie w języku C #

Czy ktoś mógłby mi pokazać mały fragment kodu, który pokazuje, jak wywołać metodę asynchronicznie w języku C #?

Jeśli używasz action.BeginInvoke (), musisz gdzieś wywołać EndInvoke - w przeciwnym razie framework musi przechowywać wynik wywołania asynchronicznego na stercie, powodując wyciek pamięci.

Jeśli nie chcesz przeskakiwać do C # 5 ze słowami kluczowymi async / await, możesz po prostu użyć biblioteki Task Parallels w .Net 4. Jest o wiele, dużo przyjemniejsza niż użycie BeginInvoke / EndInvoke i zapewnia czysty sposób odpalania. i-zapomnij dla zadań asynchronicznych:

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

Jeśli masz metody do wywołania, które pobierają parametry, możesz użyć lambdy, aby uprościć wywołanie bez konieczności tworzenia delegatów:

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

Jestem prawie pewien (ale wprawdzie nie jest to pozytywne), że składnia C # 5 async / await jest po prostu cukrem składniowym wokół biblioteki zadań.

Począwszy od .Net 4.5 możesz użyć Task.Run, aby po prostu rozpocząć akcję:

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

Task.Run vs Task.Factory.StartNew

Oto sposób, aby to zrobić:

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


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

Oczywiście musisz zastąpić Actiondelegata innym typem, jeśli metoda ma inny podpis

Przeczytaj artykuł MSDN Asynchronous Programming with Async and Await, jeśli możesz sobie pozwolić na zabawę z nowymi rzeczami. Został dodany do .NET 4.5.

Przykładowy fragment kodu z linku (który sam pochodzi z tego przykładowego projektu kodu 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;
}

Cytowanie:

Jeśli AccessTheWebAsyncnie ma żadnej pracy, którą może wykonać między wywołaniem GetStringAsync i oczekiwaniem na jego zakończenie, możesz uprościć kod, wywołując i oczekując w poniższej pojedynczej instrukcji.

string urlContents = await client.GetStringAsync();

Więcej szczegółów w linku .

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