Task and Lazy syntactic sugar

[hanxinimm]

static class Program
    {

        public class IClusterClient
        {
            public Task Connect() { return Task.CompletedTask; }

            public Task<TGrainInterface> GetGrain<TGrainInterface>(string primaryKey){ return Task.FromResult<TGrainInterface>(default(TGrainInterface)); }
        }

        internal static async Task<TGrainInterface> GetGrainAsync<TGrainInterface>(this Lazy<Task<IClusterClient>> lazyClusterClient, string Name)
        {
            //Before
            var ClusterClient = await lazyClusterClient.Value;
            return await ClusterClient.GetGrain<TGrainInterface>("key");
            //After 
            await lazyClusterClient.Value.GetGrain<TGrainInterface>("key");
            //Best
            await lazyClusterClient.GetGrain<TGrainInterface>("key");
        }

        internal static Lazy<Task<IClusterClient>> Initialize(string serviceName, IClusterClient clusterClient = null)
        {

            return new Lazy<Task<IClusterClient>>(async () =>
            {
                await clusterClient.Connect();
                return clusterClient;
            });
        }


        public static Lazy<Task<IClusterClient>> WorkCommand { get; set; }


        static void Main(string[] args)
        {
            Run(args).Wait();
        }

        private static async Task Run(string[] args)
        {
            //Before
            var INTERFACE = await WorkCommand.GetGrainAsync<Demo>(string.Empty);
            var INTERFACE2 = await INTERFACE.Sample1();
            await INTERFACE2.Sample2();
            //After
            await WorkCommand.GetGrainAsync<Demo>(string.Empty).Sample1().Sample2();
        }

    }

    public interface Demo
    {
        Task<Demo2> Sample1();
    }

    public interface Demo2
    {
        Task Sample2();
    }

[svick]

I think that making each await explicit is one of the design goals of async-await in C#, to make it clear what's going on.

What you're proposing would make the code more confusing, and it would also make it ambiguous: Task<T> and other awaitable types can (and do) have their own members. With your proposal, when you write code like await g.Sample1().Sample2();, Sample2 could be a method on Demo2 or it could be a method on Task<Demo2>. I don't think such ambiguity is a good thing to have.

---

Though there is one thing you could do to make your code simpler: make Lazy<Task<T>> awaitable. With that, you will be able to write e.g. return await (await lazyClusterClient).GetGrain<TGrainInterface>("key");.

To do that, you can use the following extension method:

public static TaskAwaiter<T> GetAwaiter<T>(this Lazy<Task<T>> lazyTask) => 
    lazyTask.Value.GetAwaiter();

[gulshan]

Another thing, you can change this-

async Task<T> MethodAsync() => await AnotherMethodAsync(param1, param2);

to

Task<T> MethodAsync() => AnotherMethodAsync(param1, param2);

Whenever I see return await or => await, it comes to my mind.

[bondsbw]

Similar to #827 (in particular chaining await using |>).

[Joe4evr]

@gulshan Just don't ever do that if it's inside a try or using block.

[yaakov-h]

@gulshan Doing that removes stack frames from exceptions, making it harder to debug. In the example below, Bar gets erased from the second exception, so you can't be sure what arguments BlowUp was called with.

Just something to keep in mind - it's not neccesarily bad, but there is a tradeoff between performance and diagnostics.

using System;
using System.Linq;
using System.Threading.Tasks;

namespace stacktrace
{
    public class Program
    {
        public static void Main(string[] args)
        {
            try { RunAsync(true).Wait(); } catch (Exception ex) { Console.WriteLine(ex); }
            try { RunAsync(false).Wait(); } catch (Exception ex) { Console.WriteLine(ex); }
        }

        static async Task RunAsync(bool shouldAwait)
        {
            if (shouldAwait)
            {
                await Foo();
            }
            else
            {
                await Bar();
            }
        }

        static async Task Foo() => await BlowUp(true);

        static Task Bar() => BlowUp(false);

        static async Task BlowUp(bool value)
        {
            await Task.Yield();
            throw new InvalidOperationException("aaaaaaah");
        }
    }
}

[jnm2]

I considered saying exactly what @yaakov-h has put very well. IIRC, Stephen Cleary recommends not trying to elide the async and await in most cases even where possible.