Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

await (Riferimenti per C#)

L'operatore await si applica a un'attività in un metodo asincrono per sospendere l'esecuzione del metodo finchè l'attività eseguita tramite l'operatore await è completata. L'attività rappresenta il lavoro che deve essere svolto.

Il metodo asincrono in cui viene utilizzato await deve essere modificato dalla parola chiave async. Tale metodo, definito utilizzando il modificatore async e in genere contenente una o più espressioni await, viene definito un metodo async.

Nota Nota

Le parole chiave await e async introdotte in Visual Studio 2012. Per un'introduzione alla programmazione asincrona, vedere Programmazione asincrona con Async e Await (C# e Visual Basic).

L'attività a cui l'operatore await viene applicato è, in genere, il valore restituito da una chiamata a un metodo che implementa Il modello asincrono Basato su attività. Gli esempi includono valori di tipo Task o Task<TResult>.

Nel codice seguente tramite il metodo GetByteArrayAsync di HttpClient viene restituito un oggetto Task<byte[]>, getContentsTask. L'attività è una promessa di produrre la matrice di byte attuale quando l'attività è completa. L'operatore await viene applicato a getContentsTask per sospendere l'esecuzione in SumPageSizesAsync finché getContentsTask non è completo. Contemporaneamente, il controllo viene restituito al chiamante di SumPageSizesAsync. Al termine di getContentsTask, l'espressione await restituisce una matrice di byte.


private async Task SumPageSizesAsync()
{
    // To use the HttpClient type in desktop apps, you must include a using directive and add a 
    // reference for the System.Net.Http namespace.
    HttpClient client = new HttpClient();
    // . . .
    Task<byte[]> getContentsTask = client.GetByteArrayAsync(url);
    byte[] urlContents = await getContentsTask;

    // Equivalently, now that you see how it works, you can write the same thing in a single line.
    //byte[] urlContents = await client.GetByteArrayAsync(url);
    // . . .
}

Nota importanteImportante

Per l'esempio completo, vedere Procedura dettagliata: accesso al Web tramite Async e Await (C# e Visual Basic). È possibile scaricare l'esempio da Esempi di codice dello sviluppatore sul sito Web Microsoft. L'esempio è incluso nel progetto AsyncWalkthrough_HttpClient.

Come mostrato nell'esempio precedente, se await viene applicata al risultato di una chiamata al metodo che restituisce Task<TResult>, il tipo dell'espressione await è TResult. Se await viene applicata al risultato di una chiamata al metodo tramite cui viene restituito Task, il tipo dell'espressione await è void. Il seguente esempio illustra la differenza.

// Keyword await used with a method that returns a Task<TResult>.
TResult result = await AsyncMethodThatReturnsTaskTResult();

// Keyword await used with a method that returns a Task.
await AsyncMethodThatReturnsTask();

Un'espressione await non blocca il thread in cui è in esecuzione. Invece, indica al compilatore di firmare il resto del metodo async come una continuazione dell'attività in attesa ("attività in attesa"= attività che è stata preceduta dall'operatore await). Il controllo ritorna quindi al chiamante del metodo async. Quando l'attività termina, l'esecuzione del metodo async viene ripresa nel punto in cui il processo era stato interrotto.

Un'espressione await può verificarsi solo immediatamente nel corpo di un metodo, di un'espressione lambda, o un metodo anonimo contrassegnato da un modificatore async. Il termine await funge da parola chiave solo in tale contesto. Altrove, viene interpretato come identificatore. All'interno del metodo, dell'espressione lambda o del metodo anonimo, un'espressione await non può verificarsi nel corpo di una funzione sincrona, in un'espressione di query, nel blocco catch o finally di un'istruzione di gestione delle eccezioni, nel blocco di un'istruzione lock o in un contesto unsafe.

Tramite la maggior parte dei metodi asincroni viene restituito un oggetto Task o Task<TResult>. Le proprietà dell'attività restituita contengono informazioni sullo stato attuale e passato, informazioni che dicono se l'attività sia completa, se il metodo async ha provocato un'eccezione o è stato annullato e qual è il risultato finale. L'operatore await accede a quelle proprietà.

Se il metodo async su cui viene usato l'operatore await, provoca un'eccezione, l'operatore await rilancia l'eccezione.

Se un'attività async a cui viene applicato l'operatore await viene cancellata, l'operatore await rilancia una OperationCanceledException.

Una singola attività nello stato Faulted può essere il risultato della presenza di più eccezioni. Ad esempio, l'attività potrebbe essere il risultato di una chiamata al metodo Task.WhenAll. Quando si attende tale attività, l'operazione di attesa esegue il rethrow di una sola delle eccezioni. Comunque non è possibile prevedere quale eccezione,delle diverse (eventualmente) verificatesi, sarà rilanciata.

Per esempi di gestione degli errori in metodi asincroni, vedere try-catch (Riferimenti per C#).

Nell'esempio seguente di Windows Form viene illustrato l'utilizzo di await in un metodo async, WaitAsynchronouslyAsync. Notare la differenza di comportamento di quest'ultimo metodo dal comportamento del metodo WaitSynchronously. Senza un operatore await applicato a un'attività, WaitSynchronously viene eseguito in modo sincrono nonostante l'uso del modificatore async nella definizione e in una chiamata a Thread.Sleep nel corpo.


private async void button1_Click(object sender, EventArgs e)
{
    // Call the method that runs asynchronously.
    string result = await WaitAsynchronouslyAsync();

    // Call the method that runs synchronously.
    //string result = await WaitSynchronously ();

    // Display the result.
    textBox1.Text += result;
}

// The following method runs asynchronously. The UI thread is not
// blocked during the delay. You can move or resize the Form1 window 
// while Task.Delay is running.
public async Task<string> WaitAsynchronouslyAsync()
{
    await Task.Delay(10000);
    return "Finished";
}

// The following method runs synchronously, despite the use of async.
// You cannot move or resize the Form1 window while Thread.Sleep
// is running because the UI thread is blocked.
public async Task<string> WaitSynchronously()
{
    // Add a using directive for System.Threading.
    Thread.Sleep(10000);
    return "Finished";
}

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft