So rufen Sie eine Methode in c # asynchron auf

Könnte mir bitte jemand einen kleinen Codeausschnitt zeigen, der zeigt, wie eine Methode in c # asynchron aufgerufen wird?

Wenn Sie action.BeginInvoke () verwenden, müssen Sie EndInvoke irgendwo aufrufen - andernfalls muss das Framework das Ergebnis des asynchronen Aufrufs auf dem Heap speichern, was zu einem Speicherverlust führt.

Wenn Sie nicht mit den Schlüsselwörtern async / await zu C # 5 springen möchten, können Sie einfach die Task Parallels-Bibliothek in .Net 4 verwenden. Sie ist viel, viel schöner als BeginInvoke / EndInvoke und bietet eine saubere Möglichkeit zum Feuern. und-vergessen für asynchrone Jobs:

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

Wenn Sie Methoden zum Aufrufen haben, die Parameter annehmen, können Sie ein Lambda verwenden, um den Aufruf zu vereinfachen, ohne Delegaten erstellen zu müssen:

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

Ich bin mir ziemlich sicher (aber zugegebenermaßen nicht positiv), dass die asynchrone / wartende C # 5-Syntax nur syntaktischer Zucker in der Task-Bibliothek ist.

Ab .Net 4.5 können Sie mit Task.Run einfach eine Aktion starten:

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

Task.Run vs Task.Factory.StartNew

Hier ist eine Möglichkeit, dies zu tun:

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


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

Natürlich müssen Sie Actiondurch einen anderen Delegatentyp ersetzen, wenn die Methode eine andere Signatur hat

Lesen Sie den MSDN-Artikel Asynchrone Programmierung mit Async und Await, wenn Sie es sich leisten können, mit neuen Dingen zu spielen. Es wurde zu .NET 4.5 hinzugefügt.

Beispielcode-Snippet aus dem Link (der selbst aus diesem MSDN-Beispielcode-Projekt stammt ):

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

Zitat:

Wenn AccessTheWebAsynczwischen dem Aufrufen von GetStringAsync und dem Warten auf dessen Abschluss keine Arbeit möglich ist, können Sie Ihren Code vereinfachen, indem Sie die folgende einzelne Anweisung aufrufen und abwarten.

string urlContents = await client.GetStringAsync();

Weitere Details finden Sie im 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));
        }
    }