async attende il ritorno Task

Qualcuno può spiegare cosa significa questo in un metodo sincrono? Se provo a cambiare il metodo per asyncpoi VS mi lamento.

Questo funziona:

public Task MethodName()
{
     return Task.FromResult<object>(null);
}

Questo non funziona:

public async Task MethodName()
{
     return Task.FromResult<object>(null);
}

Quindi sostanzialmente vorrei sapere cosa significa esattamente questo: Task.FromResult<object>(null);

asynci metodi sono diversi dai metodi normali. Qualunque cosa tu ritorni dai asyncmetodi è racchiusa in a Task.

Se non si restituisce alcun valore (vuoto) verrà inserito Task, Se si restituisce intverrà inserito Task<int>e così via.

Se il tuo metodo asincrono deve essere restituito int, contrassegnerai il tipo restituito del metodo come Task<int>e restituirai semplicemente intnon il Task<int>. Compilatore converte il intper Task<int>per voi.

private async Task<int> MethodName()
{
    await SomethingAsync();
    return 42;//Note we return int not Task<int> and that compiles
}

Allo stesso modo, quando Task<object>ritorni dovrebbe essere il tipo di ritorno del tuo metodoTask<Task<object>>

public async Task<Task<object>> MethodName()
{
     return Task.FromResult<object>(null);//This will compile
}

Poiché il tuo metodo sta tornando Task, non dovrebbe restituire alcun valore. Altrimenti non verrà compilato.

public async Task MethodName()
{
     return;//This should work but return is redundant and also method is useless.
}

Tieni presente che il metodo asincrono senza awaitun'istruzione non lo è async.

Devi usare la parola chiave wait quando usi asincrono e il tuo tipo di ritorno di funzione dovrebbe essere generico Ecco un esempio con valore di ritorno:

public async Task<object> MethodName()
{
    return await Task.FromResult<object>(null);
}

Ecco un esempio senza valore di ritorno:

public async Task MethodName()
{
    await Task.CompletedTask;
}

Leggi questo:

TPL: http://msdn.microsoft.com/en-us/library/dd460717(v=vs.110).aspx e attività: http://msdn.microsoft.com/en-us/library/system.threading .tasks (v = vs.110) .aspx

Asincrono: http://msdn.microsoft.com/en-us/library/hh156513.aspx In attesa: http://msdn.microsoft.com/en-us/library/hh156528.aspx

L'aggiunta della parola chiave asincrona è solo zucchero sintattico per semplificare la creazione di una macchina a stati. In sostanza, il compilatore prende il tuo codice;

public async Task MethodName()
{
     return null;
}

E lo trasforma in;

public Task MethodName()
{
     return Task.FromResult<object>(null);
}

Se il tuo codice ha delle awaitparole chiave, il compilatore deve prendere il tuo metodo e trasformarlo in una classe per rappresentare la macchina a stati richiesta per eseguirlo. Ad ogni awaitparola chiave, lo stato delle variabili e lo stack verranno conservati nei campi della classe, la classe si aggiungerà come hook di completamento all'attività in attesa, quindi ritornerà.

Al termine dell'attività, l'attività verrà eseguita di nuovo. Quindi un po 'di codice extra viene aggiunto all'inizio del metodo per ripristinare lo stato delle variabili e passare al pannello successivo del codice.

Vedi cosa genera asincrono e attendi? per un esempio cruento.

Questo processo ha molto in comune con il modo in cui il compilatore gestisce i metodi iteratore con dichiarazioni di rendimento.

Questa è un'attività che restituisce un'attività di tipo String (funzione anonima C # o in altre parole una delega viene utilizzata 'Func')

    public static async Task<string> MyTask()
    {
        //C# anonymous AsyncTask
        return await Task.FromResult<string>(((Func<string>)(() =>
        {
            // your code here
            return  "string result here";

        }))());
    }

Per ottenere risposte adeguate dai metodi asincroni, è necessario attendere mentre si chiamano quei metodi di attività. Ciò attenderà la conversione al tipo di valore restituito anziché al tipo di attività.

Ad esempio var content = await StringAsyncTask (

dove Attività pubblica asincrona < String > StringAsyncTask ())