async & await - Umfrage nach Alternativen [geschlossen]

Jetzt, da wir wissen, was auf c # 5 zukommt , haben wir offenbar noch eine Möglichkeit, die Auswahl der beiden neuen Schlüsselwörter für " Asynchrony " zu beeinflussen, die gestern von Anders Heijsberg auf der PDC10 angekündigt wurden .

async void ArchiveDocuments(List<Url> urls) {
    Task archive = null;
    for(int i = 0; i < urls.Count; ++i) {
        var document = await FetchAsync(urls[i]);
        if (archive != null)
            await archive;
        archive = ArchiveAsync(document);
    }
}

Eric Lippert hat eine Erklärung für die Auswahl der aktuellen zwei Schlüsselwörter und die Art und Weise, wie sie in Usability-Studien missverstanden wurden. Die Kommentare haben mehrere andere Aussagen.

Bitte - ein Vorschlag pro Antwort, Duplikate werden geknackt.

Da mir die Bedeutung / Notwendigkeit von nicht klar ist async, kann ich nicht wirklich darüber streiten, aber mein bester Vorschlag für das Ersetzen awaitist:

yield while (schau! keine neuen Keywords)

Hinweis mit Gedanken über das ein bisschen mehr, frage ich mich , ob die Wiederverwendung von whileauf diese Weise eine gute Idee ist - die natürliche Tendenz danach eine boolean zu erwarten wäre.

(Denkt, gute Keywords zu finden ist wie gute Domainnamen zu finden :)

Wie wäre es, wenn Sie kein Keyword hätten?

Ich möchte, dass der Compiler erkennt, dass ich in den meisten Fällen, wenn ich eine asynchrone Methode aufrufe, das Ergebnis davon haben möchte.

Document doc = DownloadDocumentAsync();

Das ist es. Der Grund, warum die Leute Schwierigkeiten haben, sich ein Schlüsselwort für diese Sache auszudenken, ist, dass es so ist, als hätte man ein Schlüsselwort für "Mach das, was du machen würdest, wenn die Dinge vollkommen normal wären". Dies sollte die Standardeinstellung sein und kein Schlüsselwort erfordern.

Aktualisieren

Ich schlug ursprünglich vor, dass der Compiler mit der Typinferenz klug werden sollte, um herauszufinden, was zu tun ist. Wenn Sie dies weiter überlegen, würde ich die vorhandene Implementierung im CTP beibehalten, aber ein paar triviale Ergänzungen vornehmen, um die Fälle zu reduzieren, in denen Sie das awaitSchlüsselwort explizit verwenden müssten .

Wir erfinden ein Attribut: [AutoAwait]. Dies kann nur auf Methoden angewendet werden. Eine Möglichkeit, dies auf Ihre Methode anzuwenden, besteht darin, es zu markieren async. Sie können es aber auch von Hand machen, zB:

[AutoAwait]
public Task<Document> DownloadDocumentAsync()

In einer beliebigen asyncMethode geht der Compiler dann davon aus DownloadDocumentAsync, dass Sie auf einen Aufruf von warten möchten , sodass Sie ihn nicht angeben müssen. Jeder Aufruf dieser Methode wartet automatisch darauf.

Document doc = DownloadDocumentAsync();

Wenn Sie nun "clever" werden und die erhalten möchten Task<Document>, verwenden Sie einen Operator start, der nur vor einem Methodenaufruf angezeigt werden kann:

Task<Document> task = start DownloadDocumentAsync();

Ordentlich, denke ich. Jetzt bedeutet ein einfacher Methodenaufruf, was es normalerweise bedeutet: Warten Sie, bis die Methode abgeschlossen ist. Und startweist auf etwas anderes hin: Warten Sie nicht.

Bei Code, der außerhalb einer asyncMethode angezeigt wird, können Sie eine Methode nur aufrufen, [AutoAwait]indem Sie ihm ein Präfix voranstellen start. Dadurch müssen Sie Code schreiben, der dieselbe Bedeutung hat, unabhängig davon, ob er in einer asyncMethode enthalten ist oder nicht.

Dann werde ich gierig! :)

Erstens möchte ich mich asyncauf Schnittstellenmethoden beziehen:

interface IThing
{
    async int GetCount();
} 

Dies bedeutet im Grunde, dass die implementierende Methode zurückkehren muss Task<int>oder etwas Kompatibles await, und dass Aufrufer der Methode [AutoAwait]Verhalten erhalten.

Auch wenn ich die obige Methode implementiere, möchte ich schreiben können:

async int GetCount()

Task<int>Als Rückgabetyp muss ich also nicht erwähnen .

Außerdem möchte ich mich asyncauf Delegiertypen anwenden (die schließlich wie Schnittstellen mit einer Methode sind). So:

public async delegate TResult AsyncFunc<TResult>();

Ein asyncDelegierter hat - Sie haben es erraten - [AutoAwait]Verhalten. Von einer asyncMethode aus können Sie sie aufrufen und sie wird automatisch awaitbearbeitet (es sei denn, Sie wählen nur startdiese). Und wenn Sie sagen:

AsyncFunc<Document> getDoc = DownloadDocumentAsync;

Das funktioniert einfach Es ist kein Methodenaufruf. Es wurde noch keine Aufgabe gestartet - eine async delegateist keine Aufgabe. Es ist eine Fabrik für Aufgaben. Sie können sagen:

Document doc = getDoc();

Damit wird eine Aufgabe gestartet und es wird gewartet, bis sie abgeschlossen ist und Sie das Ergebnis erhalten. Oder du kannst sagen:

Task<Document> t = start getDoc();

Wenn Sie also eine asyncMethode delegieren möchten , müssen Sie wissen, wie man einen async delegateTyp verwendet. Also anstatt Funcdu musst sagen AsyncFunc, und so weiter. Eines Tages könnte dies durch eine verbesserte Typinferenz behoben werden.

Eine andere Frage ist, was passieren soll, wenn Sie sagen, dass Sie mit einer normalen (nicht asynchronen) Methode beginnen. Offensichtlich wäre ein Kompilierungsfehler die sichere Option. Es gibt aber auch andere Möglichkeiten.

hearken unto AsyncFetch(…)

(Wenn du es nicht verstehst, lies Erics Blog-Eintrag . Zumindest ist es besser als for sooth Romeo wherefore art thou AsyncFetch(…))

Ich denke, asyncist in Ordnung, aber vielleicht liegt das daran, dass ich es mit asynchronen ASP.NET-Seiten verbinde - dieselbe Idee.

Für das awaitKeyword bevorzuge ich continue afteroder resume after.

Ich nicht wie yieldoder eine seiner Varianten, da die Semantik so ist , dass das Verfahren kann nie Ausführung tatsächlich ergibt; es kommt auf den zustand der aufgabe an.

Ich habe auch Kommentare zu Erics Blog hinzugefügt. Ich sehe keine Probleme bei der Verwendung desselben Keywords async

var data = async DownloadFileAsync(url);

Ich drücke nur aus, dass ich die Datei asynchron herunterladen möchte. Hier gibt es ein bisschen Redundanz, "async" erscheint zweimal, weil es auch im Methodennamen steht. Der Compiler könnte besonders clever sein und die Konvention erkennen, dass mit "Async" endende Methoden infakte asynchrone Methoden sind, und diese für uns in den kompilierten Code einfügen. Stattdessen möchten Sie vielleicht einfach anrufen

var data = async DownloadFile(url);

im Gegensatz zu den synchronen zu nennen

var data = DownloadFile(url);

Heck, sollten wir auch in der Lage sein, sie auf die gleiche Weise zu definieren, da das Schlüsselwort async in unserer Deklaration enthalten ist, warum müssen wir jedem Methodennamen manuell "Async" hinzufügen - der Compiler kann dies für uns tun.

async = task - Ändert eine Funktion, um eine Aufgabe zurückzugeben. Warum also nicht das Schlüsselwort "task" verwenden?

wait = finish - Wir müssen nicht unbedingt warten, aber die Aufgabe muss "beendet" sein, bevor das Ergebnis verwendet wird.

Ich mag yield until. yield while, bereits vorgeschlagen, ist großartig und führt keine neuen Keywords ein, aber ich denke, "bis" erfasst das Verhalten ein wenig besser.

Ich denke, das yield <something>ist eine großartige Idee, denn Yield fängt bereits die Idee ein, den Rest der Methode so gut fortzusetzen. Vielleicht kann sich jemand ein besseres Wort als "bis" vorstellen.

Ich möchte nur meine Stimme für den Vorschlag von Aaron G registrieren comefrom- die erste angemessene Verwendung, die ich von der COMEFROM- Erklärung von INTERCAL gesehen habe . Die Idee ist, dass es das Gegenteil von GOTO ist ( von der GOTO-Anweisung wegzuspringen ), indem es einen Platz in Ihrem Code schafft , zur COMEFROM-Anweisung zu springen.

Task<T>Wie wäre es, startwenn Sie, da es sich um s handelt, als Schlüsselwort vor der Anweisung Folgendes verwenden:

start var document = FetchAsync(urls[i]);

Es ist erwähnenswert, dass F # das asyncSchlüsselwort auch in seinen asynchronen Workflows verwendet, was ziemlich genau der neuen asynchronen Funktionalität in C # 5 entspricht. Deshalb würde ich das auch so lassen

Für das awaitSchlüsselwort in F # verwenden sie einfach let!anstelle von let. C # hat nicht die gleiche Zuweisungssyntax, daher benötigen sie etwas auf der rechten Seite des =Zeichens. Wie Benjol sagte, funktioniert es genauso wie yieldes fast eine Variante davon sein sollte.

yield async FetchAsync(..)

Dies passt perfekt zu dem asyncModifikator, den Sie für die aufgerufene Methode benötigen. Und auch die Semantik der aktuell , yield returndas heißt, Sie zurückkommen und Ausbeuten Ausführung an das Aufzählen Code während in diesem Fall sind Sie Ihre Ausführung der asynchronen Methode ergeben.

Stellen Sie sich vor, wenn es in Zukunft andere Verwendungszwecke für geben sollte yield, könnten wir ein " yield xwhere x" als neue glänzende Funktion hinzufügen, anstatt all diese verschiedenen Schlüsselwörter zu haben, um zumeist das Gleiche zu tun und die Ausführung zu ermöglichen.

Ehrlich gesagt verstehe ich das Argument, dass die Hinrichtung nicht möglich ist, nicht ganz. Ist der Sinn des Aufrufs einer anderen Methode nicht bereits, diese Methode auszuführen? Egal ob asynchron oder nicht? Ich vermisse etwas hier?

Und gut für Sie, wenn die asyncRückgabe synchron erfolgt, das Schlüsselwort jedoch vorhanden ist, um anzuzeigen, dass die Methode wahrscheinlich asynchron ausgeführt wird und Sie die Ausführung für eine andere Methode ausgeben. Ihre Methode sollte dies berücksichtigen, unabhängig davon, ob die Methode tatsächlich asynchrone Aufrufe ausführt oder nicht.

IMO Ich denke, dass die verschiedenen Fälle, in denen keine Ergebnisse erzielt werden, ein Implementierungsdetail sind. Ich würde lieber für Konsistenz in der Sprache bürgen (dh wiederverwenden yield).

Wie wäre es mit complete"Ich möchte, dass die Aufgabe erledigt wird"?

Task<byte[]> downloadTask = DownloadFileAsync(url);
byte[] data = complete downloadTask;

task(für Methodendeklaration) und async(im Methodenkörper)