List<MyObject> does not contain a definition for GetAwaiter

Question

I have a method that returns a List<> of an object. This method takes a while to run.

private List<MyObject> GetBigList()
{
    ... slow stuff
}

This method is called from 4 or 5 sources. So, I thought I would try and use async and await to keep things moving while this list builds. I added this method:

public async Task<List<MyObject>> GetBigListAsync()
{
    var resultsTask = GetBigList();
    var resuls = await resultsTask;
    return resuls;
}

But, on this line:

var resuls = await resultsTask;

I get this error:

List<MyObject> does not contain a definition for GetAwaiter, and no extension method 'GetAwaiter' accepting a first argument of type List<MyObject> could be found.

What am I missing?

Your example code does not show any use of a Task in the GetBigList method nor is it marked as async, and that means the result from that method cannot be awaited. — Travis J
Remember, await does not make a synchronous operation into an asynchronous operation. Await signs up the remainder of the current method as the continuation of an already existing asynchronous operation. Await is about managing asynchrony, not creating it. If you want a synchronous operation to be asynchronous, you're going to have to figure out a way to make that happen. — Eric Lippert
I think This Link My Help You List.add() async task await correct syntax — Mostafa Anssary

Harald Coppoolse Harald Coppoolse · Accepted Answer · 2016-11-28T08:16:44

It seems you're a newbee to async-await. What really helped me to understand what async-await does is the restaurant analogy given by Eric Lippert in this interview. Search somewhere in the middle for async await.

Here he describes that if a cook has to wait for something, instead of doing nothing he starts looking around to see if he can do something else in the meantime.

Async-await is similar. Instead of awaiting for a file to be read, a database query to return, a web page to be downloaded, your thread will go up the callstack to see if any of the callers are not awaiting and performs those statements until he sees an await. Once he sees the await the thread goes up the call stack again to see if one of the callers is not awaiting etc. After a while when the file is read, or the query is finished etc, the statements after the await are performed.

Normally while reading your big list your thread would be very busy instead of idly waiting. It's not certain that ordering another thread to do the stuff would improve the time needed to read your list. Consider measuring both methods.

One reason to use async-await, even if it would lengthen the time needed to read the big list, would be to keep the caller (user interface?) responsive.

To make your function async, you should do the following:

Declare the function async;
Instead of TResult return Task<TResult> and instead of void return Task;
If your function calls other async functions, consider remembering the returned task instead of await, do other useful stuff you need to do and await the task when you need the result;
If you really want to let another thread do the busy stuff. call

Task.Run( () => GetBigList())

and await when you need the results.

private async Task<List<MyObject>> GetBigListAsync()
{
    var myTask = Task.Run( () => GetBigList());
    // your thread is free to do other useful stuff right nw
    DoOtherUsefulStuff();
    // after a while you need the result, await for myTask:
    List<MyObject> result = await myTask;

    // you can now use the results of loading:
    ProcessResult(result);
    return result;
}

Once again: if you have nothing useful to do while the other thread is loading the List (like keeping UI responsive), don't do this, or at least measure if you are faster.

Other articles that helped me understanding async-await were - Async await, by the ever so helpful Stephen Cleary, - and a bit more advanced: Async-Wait best practices.

List<MyObject> does not contain a definition for GetAwaiter

3 Answers