C# await inside method arguments

Question

Is there any difference between this code:

MyFunction(await GetObject1(), await GetObject2());

and this:

var obj1 = await GetObject1();
var obj2 = await GetObject2();
MyFunction(obj1 , obj2);

As far as I know, arguments in C# are evaluated from left to right. But maybe in C# there are some optimizations that will start the calculation of both arguments and will wait for the first and then for the second?

The two samples may or may not emit identical code after compilation, but I wouldn't expect there to be any *meaningful* difference between them. Code readability/maintainability likely supercedes any such difference, if there even is one. — David, Sep 08 '22 at 15:49
According to [SharpLab](https://sharplab.io/#v2:C4LghgzgtgPgAgJgIwFgBQcAMACOSCsA3OunAMy4LYDC2A3utk7hXABy4As2AskgBQBKeo2ZieATzj5gASwD2AO35wAnNgDiAU2AB5AEYArLQGNgAwQBpc67XqOngCIYOJoxAXxLvm5XBzhuHmdhBh8xJgA3MAAnbHkjJGwAXhtNHQNjMws3COZouITDKlS1dPsspyFcvN4pGQVlIqTrIoRXUSYvNE6WLjrpOSV+WUVgbFlrPBwIUO6xPzgANgAeUeAAPnLMxwsUreWAOgAxGPkoACUtCABXABtgfiQO8L7llemtux2zEP3cJYnM6Xa73R4AIjA4Je6A8QA=), both options yield exactly the same JITted assembler code. — Heinzi, Sep 08 '22 at 15:53
Writing code like this is a bad idea. It's hard to read, debug and maintain — Panagiotis Kanavos, Sep 08 '22 at 15:56
@PanagiotisKanavos: Which variation are you saying is better, which worse? — Ben Voigt, Sep 08 '22 at 16:50
There's only one to talk about: `MyFunction(await GetObject1(), await GetObject2())`. The other is the normal way — Panagiotis Kanavos, Sep 09 '22 at 08:12
The `MyFunction(await GetObject1(), await GetObject2());` is the worse one. If something fails, and you only know that the exception occurred on line 132, you'll have a hard time guessing the source of the exception. There are 5 possible failure points in a single line of code. — Theodor Zoulias, Sep 09 '22 at 08:45

Guilherme · Accepted Answer · 2022-09-08T16:55:30.823

3

There is no difference.

When you use two await in sequence, they will be executed in sequence. This may be optimal or not, depending on the situation.

If you want to give "freedom" to the C# runtime to execute the async functions in any order or in parallel (this depends on the underlying implementation of each function), you can do:

var taskObj1 = GetObject1();
var taskObj2 = GetObject2();

await Task.WhenAll(taskObj1, taskObj2);

MyFunction(taskObj1.Result, taskObj2.Result);

That way, you are awaiting once for the two async functions, and can be optimal in some circumstances.

EDIT

Thanks @Ben for the comment. I added it together with the other tests.

Benchmark:

 var oneSecond = TimeSpan.FromSeconds(1);

 Stopwatch sw = new Stopwatch(); 
 
 sw.Start();
 await Task.Delay(oneSecond);
 await Task.Delay(oneSecond);
 sw.Stop();
 
 Console.WriteLine($"Using two awaits: {sw.ElapsedMilliseconds}");
 
 sw.Reset();
 
 sw.Start();
 await Task.WhenAll(Task.Delay(oneSecond), Task.Delay(oneSecond));
 sw.Stop();
 
 Console.WriteLine($"Using await Task.WhenAll: {sw.ElapsedMilliseconds}");
 
 sw.Reset();
 
 sw.Start();
 var task1 = Task.Delay(oneSecond);
 var task2 = Task.Delay(oneSecond);
 await task1;
 await task2;
 sw.Stop();
 
 Console.WriteLine($"Creating the tasks, then awaiting: {sw.ElapsedMilliseconds}");

Result:

edited Sep 08 '22 at 16:55

answered Sep 08 '22 at 15:52

Guilherme

5,143
5
39
60

You are correct, but bear in mind that if 'GetObject' uses EF, then you will get an exception stating that you can't run multiple queries at once with the same DbContext. – Neil Sep 08 '22 at 15:59
@Neil yes. This is one good example of a "not optimal" Task.WhenAll – Guilherme Sep 08 '22 at 15:59
1

The `Task.WhenAll` isn't important here. Same parallel execution from `MyFunction(await taskObj1, await taskObj2);` The important thing is whether starting the second task happens before or after awaiting the first. – Ben Voigt Sep 08 '22 at 16:05
1

@BenVoigt Thanks for the comment, but I don't believe it is correct. I created a simple benchmark to compare the two `await`s with `Task.WhenAll`. Please see my edit. As you can see, awaiting in sequence does not grant paralelism. – Guilherme Sep 08 '22 at 16:42
Your benchmark is not testing the right thing, you failed to observe **The important thing is whether starting the second task happens before or after awaiting the first**. I'll edit the code, you can then re-test. – Ben Voigt Sep 08 '22 at 16:45
Edit made. Time for you to remeasure. – Ben Voigt Sep 08 '22 at 16:46
I see your point. In this case, this works like Task.WhenAll – Guilherme Sep 08 '22 at 16:47
1

Let's add that to the answer. – Guilherme Sep 08 '22 at 16:48
Instead of using `Result` you can just await the tasks again. That way if the `WhenAll` is removed the code would still work. – juharr Sep 08 '22 at 17:15
I think that the EDIT section with the benchmark reduces the value of the answer. The answer can be improved, and be worthy of an upvote, by deleting this section. As for the `await Task.WhenAll` being an optional luxury, it is thoroughly discussed in this question: [Awaiting multiple Tasks with different results](https://stackoverflow.com/questions/17197699/awaiting-multiple-tasks-with-different-results). Spoiler alert, it's not. – Theodor Zoulias Sep 09 '22 at 08:34

CokoBWare · Answer 2 · 2022-10-19T15:16:59.947

The short answer:

The difference is minimal. Code readability is probably your biggest gain, depending on your needs. There are tradeoffs with both approaches.

The long answer:

I dumped both variants into Sharplab.io to see what code compilation would look like.

Variant 1:

using System;
using System.Threading.Tasks;

public class C {
    public async void M() {
        MyFunction(await GetObject1(), await GetObject2());
    }

    public async Task<Object> GetObject1(){
        return new object();
    }

    public async Task<Object> GetObject2(){
        return new object();
    }

    public void MyFunction(Object object1, Object object2) {
    
    }
}

compiles to...

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
public class C
{
    [StructLayout(LayoutKind.Auto)]
    [CompilerGenerated]
    private struct <M>d__0 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncVoidMethodBuilder <>t__builder;

        public C <>4__this;

        private object <>7__wrap1;

        private TaskAwaiter<object> <>u__1;

        private void MoveNext()
        {
            int num = <>1__state;
            C c = <>4__this;
            try
            {
                TaskAwaiter<object> awaiter;
                if (num != 0)
                {
                    if (num == 1)
                    {
                        awaiter = <>u__1;
                        <>u__1 = default(TaskAwaiter<object>);
                        num = (<>1__state = -1);
                        goto IL_00ca;
                    }
                    awaiter = c.GetObject1().GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        num = (<>1__state = 0);
                        <>u__1 = awaiter;
                        <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                        return;
                    }
                }
                else
                {
                    awaiter = <>u__1;
                    <>u__1 = default(TaskAwaiter<object>);
                    num = (<>1__state = -1);
                }
                <>7__wrap1 = awaiter.GetResult();
                awaiter = c.GetObject2().GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    num = (<>1__state = 1);
                    <>u__1 = awaiter;
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                    return;
                }
                goto IL_00ca;
                IL_00ca:
                object result = awaiter.GetResult();
                c.MyFunction(<>7__wrap1, result);
                <>7__wrap1 = null;
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult();
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            <>t__builder.SetStateMachine(stateMachine);
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [StructLayout(LayoutKind.Auto)]
    [CompilerGenerated]
    private struct <GetObject1>d__1 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder<object> <>t__builder;

        private void MoveNext()
        {
            object result;
            try
            {
                result = new object();
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult(result);
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            <>t__builder.SetStateMachine(stateMachine);
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [StructLayout(LayoutKind.Auto)]
    [CompilerGenerated]
    private struct <GetObject2>d__2 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder<object> <>t__builder;

        private void MoveNext()
        {
            object result;
            try
            {
                result = new object();
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult(result);
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            <>t__builder.SetStateMachine(stateMachine);
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [AsyncStateMachine(typeof(<M>d__0))]
    public void M()
    {
        <M>d__0 stateMachine = default(<M>d__0);
        stateMachine.<>t__builder = AsyncVoidMethodBuilder.Create();
        stateMachine.<>4__this = this;
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
    }

    [AsyncStateMachine(typeof(<GetObject1>d__1))]
    public Task<object> GetObject1()
    {
        <GetObject1>d__1 stateMachine = default(<GetObject1>d__1);
        stateMachine.<>t__builder = AsyncTaskMethodBuilder<object>.Create();
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }

    [AsyncStateMachine(typeof(<GetObject2>d__2))]
    public Task<object> GetObject2()
    {
        <GetObject2>d__2 stateMachine = default(<GetObject2>d__2);
        stateMachine.<>t__builder = AsyncTaskMethodBuilder<object>.Create();
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }

    public void MyFunction(object object1, object object2)
    {
    }
}

Variant 2:

using System;
using System.Threading.Tasks;

public class C {
    public async void M() {
        var obj1 = await GetObject1();
        var obj2 = await GetObject2();
        MyFunction(obj1, obj2);
    }

    public async Task<Object> GetObject1(){
        return new object();
    }

    public async Task<Object> GetObject2(){
        return new object();
    }

    public void MyFunction(Object object1, Object object2) {
    
    }
}

compiles to...

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
public class C
{
    [StructLayout(LayoutKind.Auto)]
    [CompilerGenerated]
    private struct <M>d__0 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncVoidMethodBuilder <>t__builder;

        public C <>4__this;

        private object <>7__wrap1;

        private TaskAwaiter<object> <>u__1;

        private void MoveNext()
        {
            int num = <>1__state;
            C c = <>4__this;
            try
            {
                TaskAwaiter<object> awaiter;
                if (num != 0)
                {
                    if (num == 1)
                    {
                        awaiter = <>u__1;
                        <>u__1 = default(TaskAwaiter<object>);
                        num = (<>1__state = -1);
                        goto IL_00ca;
                    }
                    awaiter = c.GetObject1().GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        num = (<>1__state = 0);
                        <>u__1 = awaiter;
                        <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                        return;
                    }
                }
                else
                {
                    awaiter = <>u__1;
                    <>u__1 = default(TaskAwaiter<object>);
                    num = (<>1__state = -1);
                }
                <>7__wrap1 = awaiter.GetResult();
                awaiter = c.GetObject2().GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    num = (<>1__state = 1);
                    <>u__1 = awaiter;
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                    return;
                }
                goto IL_00ca;
                IL_00ca:
                object result = awaiter.GetResult();
                c.MyFunction(<>7__wrap1, result);
                <>7__wrap1 = null;
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult();
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            <>t__builder.SetStateMachine(stateMachine);
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [StructLayout(LayoutKind.Auto)]
    [CompilerGenerated]
    private struct <GetObject1>d__1 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder<object> <>t__builder;

        private void MoveNext()
        {
            object result;
            try
            {
                result = new object();
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult(result);
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            <>t__builder.SetStateMachine(stateMachine);
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [StructLayout(LayoutKind.Auto)]
    [CompilerGenerated]
    private struct <GetObject2>d__2 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder<object> <>t__builder;

        private void MoveNext()
        {
            object result;
            try
            {
                result = new object();
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult(result);
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            <>t__builder.SetStateMachine(stateMachine);
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [AsyncStateMachine(typeof(<M>d__0))]
    public void M()
    {
        <M>d__0 stateMachine = default(<M>d__0);
        stateMachine.<>t__builder = AsyncVoidMethodBuilder.Create();
        stateMachine.<>4__this = this;
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
    }

    [AsyncStateMachine(typeof(<GetObject1>d__1))]
    public Task<object> GetObject1()
    {
        <GetObject1>d__1 stateMachine = default(<GetObject1>d__1);
        stateMachine.<>t__builder = AsyncTaskMethodBuilder<object>.Create();
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }

    [AsyncStateMachine(typeof(<GetObject2>d__2))]
    public Task<object> GetObject2()
    {
        <GetObject2>d__2 stateMachine = default(<GetObject2>d__2);
        stateMachine.<>t__builder = AsyncTaskMethodBuilder<object>.Create();
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }

    public void MyFunction(object object1, object object2)
    {
    }
}

When diffing the results with Codebeautify.org/file-diff, I get about 8 lines of results that are very small changes. We get about 6 lines of changes between Variant 1 and Variant 2 that are basically variable name and label identifiers, and Variant 1 produces one more line of code than Variant 2 which nulls an object references within an exception block. Variant 1 has one object cast more than Variant 2 in the compiled result, but has one less null assignment.

Maybe over billions of iterations, you might see a small difference, but honestly, I think you're fine with either method.

Code readability, depending on context, is probably the biggest gain from this exercise.

C# await inside method arguments

2 Answers2