系列介绍

【五分钟的dotnet】是一个利用您的碎片化时间来学习和丰富.net知识的博文系列。它所包含了.net体系中可能会涉及到的方方面面，比如C#的小细节，AspnetCore，微服务中的.net知识等等。
5min+不是超过5分钟的意思，”+”是知识的增加。so，它是让您花费5分钟以下的时间来提升您的知识储备量。

正文

如果您现在正在使用.NetCore的话，相信您对await 和 async这两个关键字再熟悉不过了。它们是为异步编程提供的语法糖，便于我们在代码中更便捷的进行异步操作。

await 和 async其实是对Task对象都一层包装操作。而当我们查看Task对象的时候，会发现他有一个叫做 Yield() 的方法。它的签名是这样：

public static YieldAwaitable Yield();

对于Yield这个单词，可能一下就会让我们联想到C# 里面的关键字 yield return 和yield break。那么这个Task.Yield()究竟是什么作用呢？它会和我们C#里面都关键字一样吗？

而且您会在某些框架或者代码中看到：一旦使用它的话前面都会加上await关键字。这样就写成了 await Task.Yield() 。那么这种写法到底有什么意义呢？我们又该怎么在实际项目中应用呢？

好吧，接下来我们就来对它进行解密。 不过！不过！不过！ 在说这些代码之前，我们先来模拟吃个火锅。

是的，您没有听错，现在我们不讲代码，来讲吃饭。（*没想到居然是这样的博主，我**都脱了，你给我说来吃火锅？*）。

一顿火锅聚餐的思考

说到吃火锅的话，我就拿我们成都比较火爆的蜀大侠来举例吧。

说实话，每天去蜀大侠排队的人说真的多。（这不是打广告哈。对了，麻烦蜀大侠打个钱哈）。

曾经的大学室友毕业之后很多年没有见过了，这次大家说挑个时间找机会聚一下。很早之前就定了在今天去春熙路吃个火锅。但是今天毕竟是周五嘛，大家都还要上班，所以准备下班后集合。室友加上我一共六个人，准备凑一个大桌饱餐一顿。

六点下班之后，我就很快的来到了蜀大侠火锅店的门口，毕竟我上班的地方离春熙路很近。这个时候里面还是有位置的。于是我掏出手机在群里问了一下大家，还有多久能够到。

此时坑B的剧情来了，小李说他要等一会走，可能要打扫下办公室，毕竟明天周末嘛。小王就惨了，他说他要晚一个半小时，因为他刚才发现了一个bug。

等了一会，来蜀大侠吃饭的人就开始多了起来。此时的我该怎么办呢？

“我是在进店里坐着占一个大桌等一个半小时等到小王来吗？”

如果您是蜀大侠店的老板你会允许我这么做吗？ 我估计你会把我打死，因为这个时候正是黄金时期，我在那儿占着坑位不拉*，白白浪费你挣钱的机会。

好吧，我作为一个好公民，我还是找前台排了一个号。（我们这儿过号了延3桌还算很人性）。

最后，等了一个半小时之后，小王来了。这时火锅店已经爆满了，排了很多人。我们靠排的号最后延三桌吃到了火锅。

传说中都await Task.Yield()

好了，火锅的故事讲完了。现在我们来吹回我们文章的主体：Task.Yield()。

国际惯例，先来看看Msdn给出的解释：

创建异步产生当前上下文的等待任务。

这NM，什么鬼。好吧，它也知道我们看不懂，然后下面给了注解：

可以在异步方法中使用 await Task.Yield(); 来强制异步完成方法。

原来await Task.Yield()这种写法就是从这儿出来都呀，就相当于该方法是专门配合await使用的吗？

现在来回忆一下我们刚才所讲的火锅的故事。（故事真的不是白讲的哈，虽然蜀大侠真香。蜀大侠，请再次打钱）

如果把我们的系统资源看做是火锅店里面的位置，此时我们构建了一个非常消耗时间的任务需要做，这个任务您就可以看做是我们寝室的聚餐，因为小王加班，所以导致我们需要消耗太多时间。而火锅店门口那些等待的人就是系统中其他的任务。

我们怎么去保证任务分配最优呢？ 是我先来蜀大侠门口所以就让我先进店一直座在位置上吗？ 显然这不是最优，因为我不急着使用资源，我座在那儿也不会点菜，还要等小王嘛。 所以您会优先把位置让给后面真正要吃饭的人去座。

我们的处理器也是有处理能力的极限的（具体看核心数和线程数），就好比火锅店的桌位也是有极限的，反正场子只能摆下那么多桌子。所以，我们有没有办法像上面排号一样，虽然轮到我了，我只排号，让真正需要使用资源的人去使用。

来吧，用我们的代码来演示这个场景：

public class AwaitYieldDemo
{
    public void MockHotPotRestaurant()
    {
        Task[] tasks = new Task[20];
        //构建一批吃火锅的人
        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = new Task(PersonEatHot, i);
        }
        //人们陆续来吃火锅
        for (int j = 0; j < tasks.Length / 2; j++)
        {
            tasks[j].Start();
        }
        //我来吃火锅了
        GotoShuDaXiaEatHotPot();
        //人们陆续来吃火锅
        for (int j = 10; j < tasks.Length; j++)
        {
            tasks[j].Start();
        }
    }
    private void PersonEatHot(object personNo)
    {
        Console.WriteLine($"I am No.{personNo} person.I enter restaurant");
        Thread.Sleep(1000);   //eating
        Console.WriteLine($"I am No.{ personNo } person.I eat completed.");
    }
    private async Task GotoShuDaXiaEatHotPot()
    {
        Console.WriteLine($"I get a waiting card.");
        await Task.Yield();  //到店了 先排个号
        WaitMyPartnerJoin(5);  //等待我的5个小伙伴集合
        await EatingHotPot();   //开始吃火锅
    }
    private async Task EatingHotPot()
    {
        await Task.Run(() =>
        {
            Console.WriteLine("eating hot pot with my friends");
            Thread.Sleep(1000);
            Console.WriteLine("Completed : eating hot pot with my friends");
        });
    }
    private void WaitMyPartnerJoin(int partnerNum)
    {
        Console.WriteLine("Waiting my partner join.");
        for (int i = 0; i < partnerNum; i++)
        {
            for (int j = 0; j < 1000000; j++)
            {
            }
            Console.WriteLine($"no.{i} friend join.");
        }
        Console.WriteLine("everyone is here.");
    }
}

如果您有兴趣可以直接拷贝代码来执行。分别测试开启和关闭GotoShuDaXiaEatHotPot 中的 await Task.Yield(); 语句，然后看看有什么区别。

您会看到如果不使用 await Task.Yield(); 的话，我们的代码被线程执行到的时候，就会直接执行接下来的任务。 如果开启的话，它会去执行其他任务。

那么，它和我们传统的关键字yield return有什么联系吗？ 对于传统的yield return关键字，它会返回一个IEnumerable对象，该对象可以被我们使用foreach语法糖来进行迭代。(关于IEnumerable您可以参考你怎么穿着品如的衣服？IEnumerable AND IEnumerator)。

而对于使用了yield return的foreach，它每次迭代都会返回主循环体，进行下次取数时再进入迭代器内运算，从而进行按需所取的操作。

而我们的await Task.Yield()和yield return相似都地方就是，当遇到该内容都时候，就会返回到原有的执行体内。

所以现在来看MSDN对Yield方法的解释：“创建异步产生当前上下文的等待任务。可以在异步方法中使用 await Task.Yield(); 来强制异步完成方法” 。任务被产生了之后，很快就返回到原有的上下文中，而此时原来的上下文就有机会执行其他的任务了。

什么场景使用

所以我们知道了它的益处之后，我们会在什么情况下使用呢：如果我们当前任务执行一个很耗时的操作，而且它的优先级对我们来说又不是很高的时候，我们则可以考虑在方法开始的时候加上await Task.Yield()。让系统去调度其他更需要做的任务，稍后再来完成方法体内的耗时操作。

那么如果我只使用Task.Yield()，而不使用await关键字呢？ 哈哈，这是个秘密，嘘。（您可以在上面的demo代码中尝试）。

最后，小声说一句：创作不易，点个推荐吧