What is the async-await-free equivalent of a method using async-await?

Question

I am trying to understand what exactly, in C#, a method using async await is doing under the hood.

Consider the following two examples:

static async Task<byte[]> MyReadAsync1(Stream source)
{
    var result = new byte[1024];
    int readBytes = 0;

    while (readBytes != result.Length)
    {
        int singleRead = await source.ReadAsync(result, readBytes, result.Length - readBytes);
        if (singleRead == 0)
            break;
        readBytes += singleRead;
    }

    if (readBytes == result.Length)
        return result;
    return result.Take(readBytes).ToArray();
}

static Task<byte[]> MyReadAsync2(Stream source)
{
    return Task.Run(() =>
    {
        var result = new byte[1024];
        int readBytes = 0;

        while (readBytes != result.Length)
        {
            int singleRead;
            try
            {
                singleRead = source.ReadAsync(result, readBytes, result.Length - readBytes).Result;
            }
            catch (AggregateException e)
            {
                ExceptionDispatchInfo.Capture(e.InnerException).Throw();
            }

            if (singleRead == 0)
                break;
            readBytes += singleRead;
        }

        if (readBytes == result.Length)
            return result;
        return result.Take(readBytes).ToArray();
    });
}

My question is: Are these two methods equivalent?

If I execute them, it looks like they are. Neither of them is blocking the calling thread. They are doing the exact same thing as far as I can tell, even in case of any exceptions being thrown.

If they really are equivalent, does the compiler produce the same code? Would that mean that async await does nothing else but save me type some boilerplate code, starting a task and unwrapping AggregateExceptions?

If there is a difference, what exactly is it and would it be possible to achieve the exact same behavior without async await?

Note: I've seen the question What is the purpose of “return await” in C#? and I understand the answers given there. But that covers only the case of one single return statement, whereas my question is meant to be more general.

I'm not questioning the purpose of async await, I just want to understand it in detail.

Update

The possible duplicate does not answer my question. That question only covers a one single line of code, comparing .Result and await. In my question I have many lines of additional code that are "mixed" with asynchronous code and in MyReadAsync2 method I'm wrapping the entire execution in Task.Run. I cannot see how the other question addresses any of these additional questions.

Answer 1

Roughly speaking, if you wanted to write an "async free" version of the code, you'd be using ContinueWith in about the same location as each await, rather than using Result (which as discussed, will block a thread and may result in deadlocks).

Of course, this ignores the synchronization context machinery which e.g. can get your code running back on the UI thread if that was the context in which the original method was called. You'll also find (if you have more than a single await) that your nesting levels go crazy and that you can't easily use some constructs (e.g. try doing an await inside a loop, and then try to write the equivalent using ContinueWith^1,2).

There's a lot of machinery that async/await just gives you and you don't often have to peek behind the scenes. If you want to though, you can always try compiling some async based code and then running it through a decompiler that either doesn't support async or has an option to not try to reverse-engineer async methods.

---

¹Not that simple loops just calling await is a good typical example of async code in most cases.

²Note that in this example that each iteration of the loop only starts when the previous awaitable has completed - so you have to pass the loop context into whatever method you're passing to the ContinueWith call.