Wenn ich möchte, dass alles innerhalb einer Funktion ausgeführt wird, erwarte ich jede Zeile?

Question

Ich weiß sicher, mein Gehirn ist nicht ganz klar auf Async/erwarten, also brauche ich etwas Klarheit. Ich sehe eine Menge Beispiele, in denen in einigen Zeilen auf wait gewartet wird und nicht auf anderen in einer async-markierten Funktion. Zum Beispiel habe ich nur selten, wenn ein Beispiel so gesehen (ich die print-Anweisung als Beispiel für etwas Einfaches/basic verwende.):

myFunction() async { 
    await functionA(); 
    await print("This really long thing that's going to print out."); 
    await functionB(); 
    await MyExtraClass.lookupSomethingQuickly(); 
    ... 
} 

So die Beispiele, die ich sehen, dass es in der Regel etwas wie folgt aus:

myFunction() async { 
    await functionA(); 
    print("This really long thing that's going to print out."); 
    await functionB(); 
    MyExtraClass.lookupSomethingQuickly(); 
    ... 
} 

Also ich frage mich, ob es nur eine Vermutung, dass einfache Dinge in Ordnung oder theoretisch beenden, wenn await vor jeder Zeile setzen wird, was soll ich in Fällen tun, wo ich absolut Linie 1 brauchen Linie zu folgen 2, um Zeile 3 usw. zu folgen ... Wie wäre es, wenn ich unbedingt den Druck beenden müsste, bevor die FunktionB() ausgeht?

Im Wesentlichen stelle ich fest, dass ich jedes Mal, wenn ich eine Funktion mit async/awaite schreibe, einen Urteilsspruch in jeder Zeile schreibe, und ich weiß nie, ob mein Code aufgrund von gutem Timing und Glück funktioniert oder ob es Fälle geben würde Wirf die Ausführung ab.

Answer 1

async/await ist asynchron Code einfacher zu schreiben, zu lesen und zu begründen. Der Synchronous-Code benötigt keine solche Unterstützung.
Für Asynchron-Programmierung in Dart auch https://www.dartlang.org/docs/tutorials/futures/

sehen Wenn Sie dieses Codebeispiel

nehmen

import 'dart:async' show Future; 
void main() { 
    doSomethingAsync().then((_) => print('afterwards')); 
    print('at last'); 
} 

Future doSomethingAsync() { 
    return new Future.delayed(const Duration(seconds: 1),() { 
    print('done something'); 
    }); 
} 

es in DartPad

Versuchen Sie, die

zuletzt

etwas getan druckt danach

Wenn Sie mit Asynchron-Ausführung nicht vertraut sind dies könnte überraschend sein

Dies liegt daran, den Code zu Future.delayed() bestand mit einer Verzögerung von 1 Sekunde ausgeführt wird. Die Future -Instanz, die von doSomethingAsync() zurückgegeben wird, ist "abgeschlossen", wenn der Code in Future.delayed() ausgeführt wurde.

In dieser Linie

doSomethingAsync().then((_) => print('afterwards')); 

wir nennen .then(...) auf die zurück Future durch doSomethingAsync() und einen Verschluss (Inline-Funktion) zu .then(...) passieren. ((_) => print('afterwards')).

Ein Merkmal Future ist, dass es den Code übergeben then(...) ruft, nachdem er abgeschlossen wurde (in unserem Fall, wenn nach 1 sec done something Verzögerung gedruckt wurde).

So geht die Ausführung so etwas wie

• Anruf doSomethingAsync() der Zeitplan einen Aufruf an print('done something) für die spätere Ausführung und einen Future
• Aufruf gibt print('at last'); die gerade at last
• nach 1 Sekunde Verzögerung druckt print('done something') genannt wird
• Die Future zurückgegeben von doSomethingAsync() ist abgeschlossen
• die Future Anrufe `(_) => drucken ('nachher')
• main() endet.

Wenn wir verwenden async/await der Code sieht aus wie

import 'dart:async' show Future; 
Future main() async { 
    await doSomethingAsync(); 
    print('afterwards'); 
    print('at last'); 
} 

Future doSomethingAsync() { 
    return new Future.delayed(const Duration(seconds: 1),() { 
    print('done something'); 
    }); 
} 

Probieren Sie es in DartPad

Wenn Lauf, der Ausgang ist

etwas getan
danach
zu guter Letzt

wir auch async/await in doSomethingAsync() verwenden könnte, aber jetzt konzentrieren wir uns nur auf main()

Nun ist die Ausführung sieht aus wie

• Anruf doSomething() und warten auf die zurück Future abzuschließen
• print('done something') wird ausgeführt und Future wird vervollständigt
• die Ausführung von Code nach await weiter
• print('afterwards');
• print('at last');

Dies ist wahrscheinlich das Verhalten erwartet.

Zu Ihrer ursprünglichen Frage. await ist nur erforderlich, wenn ein Anruf eine Future zurückgibt und der folgende Code nur ausgeführt werden soll, wenn die Future abgeschlossen ist. Wenn der Anruf keine Future zurückgibt, gibt es nichts zu warten.

await print('xxx') ist immer noch gültigen Code. Dies ist zur Unterstützung von Funktionen, die manchmal einige asynchrone Arbeit und geben Sie eine Future zurück, aber manchmal haben die asynchrone Arbeit nicht zu tun und den Code sofort ausführen und nur danach zurückkehren. In diesem Fall gibt es nichts zu warten.

someTimesAsync() { 
    if(new DateTime.now().weekday == 1) { 
    return new Future.delayed(const Duration(seconds: 1),() { 
     print('done something'); 
    }); 
    } else { 
    print('done something'); 
    } 
} 

await someTimesAsync(); 

Arbeiten in beiden Fällen. Wenn es nicht wäre, wäre das umständlich.

Für weitere Informationen über async/await siehe auch https://www.dartlang.org/articles/await-async/