1

Given the method signature:

(awaitable) Task<Token> ITokenService.GetAPIToken();

In this method what is happening on the line with the await?

public async Task<User> GetUser(string userId)
{
    Token token = await TokenService.GetAPIToken();

    //..........
}

My understanding: GetAPIToken is called and the current method (GetUser) returns a Task<User> object (which will provide a User object later). The current method's execution continues only once the GetAPIToken method returns.

If I am wrong, what is the type/value of token while the code waits for the GetAPIToken() method to return?

I understand that the result of calling this method will be different given that it can be called either with or without the await keyword. Please assume, for the post, that it is being called with await.

Matt W
  • 11,753
  • 25
  • 118
  • 215
  • 1
    You are correct. The `GetUsed` method returns at that point, and it will be resumed when the `Task` returned from `GetAPIToken` completes. `token` is not initialized until that `await` completes. It doesn't matter, because you can't access its value until the `await` completes anyway. – canton7 Feb 11 '19 at 12:56
  • 2
    Well, you could [read](https://blog.stephencleary.com/2012/02/async-and-await.html) about it in number of sources. – Fabjan Feb 11 '19 at 13:05
  • 1
    Possible duplicate of [How and when to use ‘async’ and ‘await’](https://stackoverflow.com/questions/14455293/how-and-when-to-use-async-and-await) – Fabjan Feb 11 '19 at 13:12
  • I understand that this appears to be a duplicate, but IMHO I am asking about a specific piece of code. Unless those other posts are exactly the same as mine, they don't answer my question. Having said that, they are very close and help me out - though, again, I'm asking about /this/ code because those other posts did not take me all the way (I've seen them before.) – Matt W Feb 11 '19 at 14:05
  • Your question is not clear. If you await `GetUser` method then you get back `User` and if you don't await it then you get back `Task` which might be already completed and it might not. Then you ask about `token`, so now I'm not sure if you want to know what happens to `GetUser` or `GetAPIToken`... – FCin Feb 11 '19 at 14:13
  • I have added clarity. Thank you for the clarification on which type is returned. I'm really asking about the overall execution in the typical scenario. – Matt W Feb 11 '19 at 14:33
  • 1
    @Matt I have completed and corrected my answer; I hope it's clearer now. Eric also explains it perfectly. – J.P. Feb 12 '19 at 22:43

2 Answers2

7

My understanding: GetAPIToken is called and the current method (GetUser) returns a Task<User> object (which will provide a User object later). The current method's execution continues only once the GetAPIToken method returns.

That is very close. Let's crisp that up in two ways.

First, let's make a distinction between returns -- which means, returns control to the caller -- and completes, which means the task represented by the method is completed and either we have its value, or, in the case of abnormal completion, an exception.

In non-async methods we do not need to make a distinction because returning control to the caller only happens on completion. In async methods, we can return-to-caller-as-suspension (because of awaiting a non-completed task) or return-as-completion (when the represented task is signalled as being complete).

Second, it is helpful to express the workflow in terms of what happens if the task is complete when it is created; this can happen in the case of caching, say.

So let's now re-state your understanding with that in mind:

  • GetAPIToken is called and returns a task to the current user.
  • If the task is completed, then GetApiToken returned when it finished all its work. GetUser extracts the token from the completed task and continues without suspending.
  • If the task is not completed, and this is the first await in GetUser, then GetUser creates a Task<User>
  • GetUser assigns the remainder of GetUser as the continuation of the Task<Token>, and suspends by returning the Task<User>
  • When the Task<Token> completes it runs its continuation, which resumes GetUser where it left off.

what is the type/value of token while the code waits for the GetAPIToken() method to return?

Well, what would the value of token be in an equivalent non-async case? Consider:

Token x = Foo();

What's the value of x while we're waiting for Foo to complete? Making Foo async doesn't make a difference; the local is not assigned a value until after the call completes normally. If Foo goes into an infinite loop, or if Foo throws, then x is never assigned.

In practice of course, C# assigns all locals their default value when they are created, so that's the value that will be in the variable.

Eric Lippert
  • 647,829
  • 179
  • 1,238
  • 2,067
1

On the line with the await, indeed the execution of GetUser() is stopped (awaits) until GetAPIToken() returns. This is correct. Therefore token has no value (or is even declared in this case) until it gets it from GetAPIToken() returning.

What GetUser() returns depends on how it's called, with or without the await operator. If called with await, the caller of GetUser() will wait for it to finish as well. Also in this case the caller will eventually get a User returned by GetUser(), not a Task<User>.

In this scenario, you're not benefiting by running anything in parallel.

If on the other hand GetUser() is called without the await operator, two things happen differently: GetUser() returns to the caller earlier, as soon as it has hit your line actually; and it returns a Task<User> instead of a User directly -- after all none had yet been created.

From this Task the caller can later (after doing other things in parallel, that'd be the whole point) get the resulting User. This can be done in different ways -- the most idiomatic being to await it then; or else see the methods and properties of Task<>.

It is important to understand when things run in parallel. In that case (if GetUser() were called without await) it's a possibility that GetUser() returns and you continue doing stuff while, in parallel in the other thread, GetAPIToken() hasn't yet returned and so token is not initialized.

Check this nice MSDN article with graph: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/index#BKMK_WhatHappensUnderstandinganAsyncMethod

J.P.
  • 350
  • 2
  • 11