Wie schreibe ich eine "erwartete" Methode?

Ich schaue mir endlich die asynchronen und wartenden Schlüsselwörter an, die ich irgendwie "bekomme", aber alle Beispiele, die ich gesehen habe, rufen asynchrone Methoden im .Net-Framework auf, z. B. dieses , das aufruft HttpClient.GetStringAsync().

Was mir nicht so klar ist, ist, was in einer solchen Methode vor sich geht und wie ich meine eigene "erwartete" Methode schreiben würde. Ist es so einfach, den Code, den ich asynchron in einer Task ausführen möchte, zu verpacken und zurückzugeben?

Es ist so einfach wie

Task.Run(() => ExpensiveTask());

Um es zu einer erwarteten Methode zu machen:

public Task ExpensiveTaskAsync()
{
    return Task.Run(() => ExpensiveTask());
}

Das Wichtigste dabei ist, eine Aufgabe zurückzugeben. Die Methode muss nicht einmal als asynchron markiert werden. (Lesen Sie einfach etwas weiter, damit es ins Bild kommt.)

Dies kann nun als bezeichnet werden

async public void DoStuff()
{
    PrepareExpensiveTask();
    await ExpensiveTaskAsync();
    UseResultsOfExpensiveTask();
}

Beachten Sie, dass hier die Methodensignatur lautet async, da die Methode die Kontrolle bis zur Rückkehr an den Aufrufer ExpensiveTaskAsync()zurückgeben kann. Auch teuer in diesem Fall bedeutet zeitaufwändig, wie eine Webanforderung oder ähnliches. Um umfangreiche Berechnungen an einen anderen Thread zu senden, ist es normalerweise besser, die "alten" Ansätze zu verwenden, dh System.ComponentModel.BackgroundWorkerfür GUI-Anwendungen oder System.Threading.Thread.

Wie würde ich meine eigene "erwartete" Methode schreiben? Ist es so einfach, den Code, den ich asynchron ausführen möchte, in einen zu verpacken Taskund diesen zurückzugeben?

Dies ist eine Option, aber höchstwahrscheinlich nicht das, was Sie tun möchten, da Sie dadurch nicht viele der Vorteile von asynchronem Code erhalten. Weitere Informationen finden Sie unter Stephen Toubs Soll ich asynchrone Wrapper für synchrone Methoden verfügbar machen?

Im Allgemeinen sind Methoden nicht zu erwarten, Typen sind es. Wenn Sie in der Lage sein wollen , wie etwas zu schreiben await MyMethod(), dann MyMethod()muss zurückkehren Task, Task<T>oder eine benutzerdefinierte awaitLage Art. Die Verwendung eines benutzerdefinierten Typs ist ein seltenes und fortgeschrittenes Szenario. Mit Taskhaben Sie mehrere Möglichkeiten:

• Schreiben Sie Ihre Methode mit asyncund await. Dies ist nützlich für Komponieren Aktionen asynchron, aber es kann nicht für den inner meisten verwendet werden awaitkönnen Anrufe.
• Erstellen Sie die Taskmit einer der Methoden auf Task, wie Task.Run()oder Task.FromAsync().
• Verwenden Sie TaskCompletionSource. Dies ist der allgemeinste Ansatz. Er kann verwendet werden, um awaitaus allem, was in Zukunft passieren wird, fähige Methoden zu erstellen .

... wie ich meine eigene "erwartbare" Methode schreiben würde.

Die Rückgabe von a Taskist nicht der einzige Weg. Sie haben die Möglichkeit, einen benutzerdefinierten Kellner zu erstellen (indem Sie GetAwaiterund implementieren INotifyCompletion). Hier finden Sie eine gute Lektüre: "Warten Sie auf alles" . Beispiele für .NET-APIs, die benutzerdefinierte Wartende zurückgeben: Task.Yield(), Dispatcher.InvokeAsync.

Ich habe hier und hier einige Posts mit benutzerdefinierten Wartern , z.

// don't use this in production
public static class SwitchContext
{
    public static Awaiter Yield() { return new Awaiter(); }

    public struct Awaiter : System.Runtime.CompilerServices.INotifyCompletion
    {
        public Awaiter GetAwaiter() { return this; }

        public bool IsCompleted { get { return false; } }

        public void OnCompleted(Action continuation)
        {
            ThreadPool.QueueUserWorkItem((state) => ((Action)state)(), continuation);
        }

        public void GetResult() { }
    }
}

// ...

await SwitchContext.Yield();

Ja, technisch gesehen müssen Sie nur eine Taskoder Task<Result>von einer asyncMethode zurückgeben, um eine erwartete Methode zu implementieren.

Dies unterstützt das aufgabenbasierte asynchrone Muster .

Es gibt jedoch verschiedene Möglichkeiten, das TAP zu implementieren. Weitere Informationen finden Sie unter Implementieren des aufgabenbasierten asynchronen Musters .

(Aber all diese Implementierungen kehren immer noch zurück Taskoder Task<Result>natürlich.)

Konvertieren Sie einfach Ihre Methode in Task. Wie bei @Romiox verwende ich normalerweise diese Erweiterung:

public static partial class Ext
{
    #region Public Methods
    public static Task ToTask(Action action)
    {
        return Task.Run(action);
    }
    public static Task<T> ToTask<T>(Func<T> function)
    {
        return Task.Run(function);
    }
    public static async Task ToTaskAsync(Action action)
    {
        return await Task.Run(action);
    }
    public static async Task<T> ToTaskAsync<T>(Func<T> function)
    {
        return await Task.Run(function);
    }
    #endregion Public Methods
}

Lassen Sie uns jetzt sagen, dass Sie haben

void foo1()...

void foo2(int i1)...

int foo3()...

int foo4(int i1)...

...

Dann können Sie Ihre [asynchrone Methode] wie @Romiox deklarieren

async Task foo1Async()
{
    return await Ext.ToTask(() => foo1());
}
async Task foo2Async(int i1)
{
    return await Ext.ToTask(() => foo2(i1));
}
async Task<int> foo3Async()
{
    return await Ext.ToTask(() => foo3());
}
async Task<int> foo4Async(int i1)
{
    return await Ext.ToTask(() => foo4(i1));
}

ODER

async Task foo1Async()
{
    return await Ext.ToTaskAsync(() => foo1());
}
async Task foo2Async(int i1)
{
    return await Ext.ToTaskAsync(() => foo2(i1));
}
async Task<int> foo3Async()
{
    return await Ext.ToTaskAsync(() => foo3());
}
async Task<int> foo4Async(int i1)
{
    return await Ext.ToTaskAsync(() => foo4(i1));
}

...

Jetzt können Sie async verwenden und auf eine der fooAsync-Methoden warten, z. B. foo4Async

async Task<int> TestAsync () {
    ///Initial Code
    int m = 3;
    ///Call the task
    var X = foo4Async(m);
    ///Between
    ///Do something while waiting comes here
    ///..
    var Result = await X;
    ///Final
    ///Some Code here
    return Result;
}

Wenn Sie a nicht verwenden möchten Task, können Sie ein vollständig angepasstes, zu erwartendes Objekt schreiben. Ein solches Objekt implementiert eine Methode, GetAwaiter ()die ein implementiertes Objekt zurückgibt INotifyCompletion, das das Objekt selbst sein kann.

Mehr: INotifyCompletion

Der Kellner implementiert:

• IsCompleted ist den Staat zu bekommen
• GetResult () um das Ergebnis zu erhalten
• OnCompleted (Action continuation) um den Fortsetzungsdelegierten festzulegen.

Das erwartete Objekt enthält eine Methode für die tatsächliche Nutzlast (z. B. unten ist die Methode Run).

class Program {
    // Need to change the declaration of Main() in order to use 'await'
    static async Task Main () {
        // Create a custom awaitable object
        MyAwaitable awaitable = new MyAwaitable ();

        // Run awaitable payload, ignore returned Task
        _ = awaitable.Run ();

        // Do some other tasks while awaitable is running
        Console.WriteLine ("Waiting for completion...");

        // Wait for completion
        await awaitable;

        Console.WriteLine ("The long operation is now complete. " + awaitable.GetResult());
    }
}

public class MyAwaitable : INotifyCompletion {
    // Fields
    private Action continuation = null;
    private string result = string.Empty;

    // Make this class awaitable
    public MyAwaitable GetAwaiter () { return this; }

    // Implementation of INotifyCompletion for the self-awaiter
    public bool IsCompleted { get; set; }
    public string GetResult () { return result; }
    public void OnCompleted (Action continuation) {
        // Store continuation delegate
        this.continuation = continuation;
        Console.WriteLine ("Continuation set");
    }

    // Payload to run
    public async Task Run () {
        Console.WriteLine ("Computing result...");

        // Wait 2 seconds
        await Task.Delay (2000);
        result = "The result is 10";

        // Set completed
        IsCompleted = true;

        Console.WriteLine ("Result available");

        // Continue with the continuation provided
        continuation?.Invoke ();
    }
}