在 Emit 代码中如何await一个异步方法

0. 前言

首先立马解释一波为啥会有这样一篇伪标题的Demo随笔呢?
不是本人有知识误区，或者要误人子弟
由于你们都知道emit写出来的都是同步方法，不可能await，至少如今这么多年来没有提供对应的功能
这是以前某天在微信群看见讨论怎么emit一个异步方法并包装异步结构，简单几句文字也未能清晰的表达
因此趁着元旦节放假有点时间，
简单列举三种我知道方式去达到这样的效果
三种方法都是绕过emit直接书写emit代码，而是将对应逻辑转到其余方法中，最后emit调用方法达到效果

Demo 说明

原始方法是个延迟2秒以后返回55的方法：

public static async Task<int> GetV()
        {
            await Task.Delay(2000);
            return 55;
        }

如今咱们须要把 55 的结果加 6 ，让最终的结果变为 61

咱们的测试方法是这样，会输出一些简单的时间，帮助咱们了解执行顺序和异步状况

private static async Task Test(MethodInfo method, MethodInfo awaitMehtod)
        {
            var caller = CreateCaller(method, awaitMehtod);
            Console.WriteLine($"Start {awaitMehtod.Name} at: {DateTime.Now}.");
            var task = caller();
            Console.WriteLine($"Call done at: {DateTime.Now}.");
            var number = await task;
            Console.WriteLine($"Hello {number} at: {DateTime.Now}.");
            Console.WriteLine($"End at: {DateTime.Now}.");
            Console.WriteLine();
        }

1. ContinueWith

public static Func<Task<int>> CreateCaller(MethodInfo method, MethodInfo awaitMehtod)
        {
            var m = new DynamicMethod(Guid.NewGuid().ToString("N"), typeof(Task<int>), Type.EmptyTypes);
            var il = m.GetILGenerator();
            il.Emit(OpCodes.Call, method);
            il.Emit(OpCodes.Call, typeof(Program).GetMethod(nameof(Program.AddSixUseContinueWith))); // 这里是差别点
            il.Emit(OpCodes.Ret);

            return m.CreateDelegate(typeof(Func<Task<int>>)) as Func<Task<int>>;
        }

        public static Task<int> AddSixUseContinueWith(Task<int> task)
        {
            return task.ContinueWith(i =>
            {
                Console.WriteLine($"AddSixUseContinueWith is: {DateTime.Now}.");
                return i.Result + 6;
            });
        }

测试结果：

Start AddSixUseContinueWith at: 2021/1/2 13:34:55.
Call done at: 2021/1/2 13:34:55.
AddSixUseContinueWith is: 2021/1/2 13:34:57.
Hello 61 at: 2021/1/2 13:34:57.
End at: 2021/1/2 13:34:57.

优势

仍是真正的异步

缺点

成本比较大，毕竟这样没有了状态机等等优化，（成本在 ns 级别哦，不是你们想的 ms哦）

2. GetAwaiter().GetResult()

public static Func<Task<int>> CreateCaller(MethodInfo method, MethodInfo awaitMehtod)
        {
            var m = new DynamicMethod(Guid.NewGuid().ToString("N"), typeof(Task<int>), Type.EmptyTypes);
            var il = m.GetILGenerator();
            il.Emit(OpCodes.Call, method);
            il.Emit(OpCodes.Call, typeof(Program).GetMethod(nameof(Program.AddSixUseAwaiter))); // 这里是差别点
            il.Emit(OpCodes.Ret);

            return m.CreateDelegate(typeof(Func<Task<int>>)) as Func<Task<int>>;
        }

        public static Task<int> AddSixUseAwaiter(Task<int> task)
        {
            var r = task.ConfigureAwait(false).GetAwaiter().GetResult() + 6;
            Console.WriteLine($"AddSixUseAwaiter is: {DateTime.Now}.");
            return Task.FromResult(r);
        }

测试结果：

Start AddSixUseAwaiter at: 2021/1/2 13:34:57.
AddSixUseAwaiter is: 2021/1/2 13:34:59.
Call done at: 2021/1/2 13:34:59.
Hello 61 at: 2021/1/2 13:34:59.
End at: 2021/1/2 13:34:59.

优势

执行时间上消耗很小

缺点

固然这样 异步都变成了同步，因此可能会在某些状况下咱们操做不当的代码从而致使失去异步方法的优点

3. async/await

public static Func<Task<int>> CreateCaller(MethodInfo method, MethodInfo awaitMehtod)
        {
            var m = new DynamicMethod(Guid.NewGuid().ToString("N"), typeof(Task<int>), Type.EmptyTypes);
            var il = m.GetILGenerator();
            il.Emit(OpCodes.Call, method);
            il.Emit(OpCodes.Call, typeof(Program).GetMethod(nameof(Program.AddSixUseAsyncAwait))); // 这里是差别点
            il.Emit(OpCodes.Ret);

            return m.CreateDelegate(typeof(Func<Task<int>>)) as Func<Task<int>>;
        }

        public static async Task<int> AddSixUseAsyncAwait(Task<int> task)
        {
            var r = await task;
            Console.WriteLine($"AddSixUseAsyncAwait is: {DateTime.Now}.");
            return r + 6;
        }

测试结果：

Start AddSixUseAsyncAwait at: 2021/1/2 13:34:59.
Call done at: 2021/1/2 13:34:59.
AddSixUseAsyncAwait is: 2021/1/2 13:35:01.
Hello 61 at: 2021/1/2 13:35:01.
End at: 2021/1/2 13:35:01.

优势

async / await 自己的优点都没有损失

缺点

本来想在 emit 中 对result的处理逻辑 必须迁移到 async / await 方法中，emit代码必须好好设计

完整Demo放在

https://github.com/fs7744/grocery/blob/main/csharp/emit_await/EmitAwaitDemo/Program.cs

分享不易，若是能给予一点动力，不胜感激：关注一下本人的开源项目： Norns.Urd