await foreach怎么在C# 8.0中使用

今天就跟大家聊聊有关await foreach怎么在C# 8.0中使用，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。

static int SumFromOneToCount(int count)
    {
      ConsoleExt.WriteLine("SumFromOneToCount called!");

      var sum = 0;
      for (var i = 0; i <= count; i++)
      {
        sum = sum + i;
      }
      return sum;
    }

调用方法.

static void Main(string[] args)
    {
      const int count = 5;
      ConsoleExt.WriteLine($"Starting the application with count: {count}!");
      ConsoleExt.WriteLine("Classic sum starting.");
      ConsoleExt.WriteLine($"Classic sum result: {SumFromOneToCount(count)}");
      ConsoleExt.WriteLine("Classic sum completed.");
      ConsoleExt.WriteLine("################################################");
    }

输出结果.

可以看到,整个过程就一个线程Id为1的线程自上而下执行,这是最基础的做法.

Yield Return

接下来,我们使用yield运算符使得这个方法编程延迟加载,如下所示.

static IEnumerable<int> SumFromOneToCountYield(int count)
    {
      ConsoleExt.WriteLine("SumFromOneToCountYield called!");

      var sum = 0;
      for (var i = 0; i <= count; i++)
      {
        sum = sum + i;

        yield return sum;
      }
    }

主函数

static void Main(string[] args)
    {
      const int count = 5;
      ConsoleExt.WriteLine("Sum with yield starting.");
      foreach (var i in SumFromOneToCountYield(count))
      {
        ConsoleExt.WriteLine($"Yield sum: {i}");
      }
      ConsoleExt.WriteLine("Sum with yield completed.");

      ConsoleExt.WriteLine("################################################");
      ConsoleExt.WriteLine(Environment.NewLine);
    }

运行结果如下.

正如你在输出窗口中看到的那样，结果被分成几个部分返回，而不是作为一个值返回。以上显示的累积结果被称为惰性枚举。但是，仍然存在一个问题，即 sum 方法阻塞了代码的执行。如果你查看线程ID，可以看到所有东西都在主线程1中运行,这显然不完美,继续改造.

Async Return

我们试着将async用于SumFromOneToCount方法(没有yield关键字).

static async Task<int> SumFromOneToCountAsync(int count)
    {
      ConsoleExt.WriteLine("SumFromOneToCountAsync called!");

      var result = await Task.Run(() =>
      {
        var sum = 0;

        for (var i = 0; i <= count; i++)
        {
          sum = sum + i;
        }
        return sum;
      });

      return result;
    }

主函数.

static async Task Main(string[] args)
    {
      const int count = 5;
      ConsoleExt.WriteLine("async example starting.");
      // Sum runs asynchronously! Not enough. We need sum to be async with lazy behavior.
      var result = await SumFromOneToCountAsync(count);
      ConsoleExt.WriteLine("async Result: " + result);
      ConsoleExt.WriteLine("async completed.");

      ConsoleExt.WriteLine("################################################");
      ConsoleExt.WriteLine(Environment.NewLine);
    }

运行结果.

我们可以看到计算过程是在另一个线程中运行，但结果仍然是作为一个值返回！任然不完美.

如果我们想把惰性枚举（yield return）与异步方法结合起来,即返回Task<IEnumerable,这怎么实现呢?

Task<IEnumerable>

我们根据假设把代码改造一遍,使用Task<IEnumerable<T>>来进行计算.

可以看到,直接出现错误.

IAsyncEnumerable

其实,在C# 8.0中Task<IEnumerable>这种组合称为IAsyncEnumerable。这个新功能为我们提供了一种很好的技术来解决拉异步延迟加载的问题，例如从网站下载数据或从文件或数据库中读取记录,与 IEnumerable 和 IEnumerator 类似，Async Streams 提供了两个新接口 IAsyncEnumerable 和 IAsyncEnumerator，定义如下：

public interface IAsyncEnumerable<out T>
  {
    IAsyncEnumerator<T> GetAsyncEnumerator();
  }

  public interface IAsyncEnumerator<out T> : IAsyncDisposable
  {
    Task<bool> MoveNextAsync();
    T Current { get; }
  }

  // Async Streams Feature 可以被异步销毁 
  public interface IAsyncDisposable
  {
   Task DiskposeAsync();
  }

AsyncStream

下面,我们就来见识一下AsyncStrema的威力,我们使用IAsyncEnumerable来对函数进行改造,如下.

static async Task ConsumeAsyncSumSeqeunc(IAsyncEnumerable<int> sequence)
    {
      ConsoleExt.WriteLineAsync("ConsumeAsyncSumSeqeunc Called");

      await foreach (var value in sequence)
      {
        ConsoleExt.WriteLineAsync($"Consuming the value: {value}");

        // simulate some delay!
        await Task.Delay(TimeSpan.FromSeconds(1));
      };
    }

    private static async IAsyncEnumerable<int> ProduceAsyncSumSeqeunc(int count)
    {
      ConsoleExt.WriteLineAsync("ProduceAsyncSumSeqeunc Called");
      var sum = 0;

      for (var i = 0; i <= count; i++)
      {
        sum = sum + i;

        // simulate some delay!
        await Task.Delay(TimeSpan.FromSeconds(0.5));

        yield return sum;
      }
    }

主函数.

 static async Task Main(string[] args)
    {
      const int count = 5;
      ConsoleExt.WriteLine("Starting Async Streams Demo!");

      // Start a new task. Used to produce async sequence of data!
      IAsyncEnumerable<int> pullBasedAsyncSequence = ProduceAsyncSumSeqeunc(count);

      // Start another task; Used to consume the async data sequence!
      var consumingTask = Task.Run(() => ConsumeAsyncSumSeqeunc(pullBasedAsyncSequence));

      await Task.Delay(TimeSpan.FromSeconds(3));

      ConsoleExt.WriteLineAsync("X#X#X#X#X#X#X#X#X#X# Doing some other work X#X#X#X#X#X#X#X#X#X#");

      // Just for demo! Wait until the task is finished!
      await consumingTask;

      ConsoleExt.WriteLineAsync("Async Streams Demo Done!");
    }

如果一切顺利,那么就能看到这样的运行结果了.

最后,看到这就是我们想要的结果,在枚举的基础上,进行了异步迭代.

可以看到,整个计算过程并没有造成主线程的阻塞,其中,值得重点关注的是红色方框区域的线程5!线程5!线程5!线程5在请求下一个结果后,并没有等待结果返回,而是去了Main()函数中做了别的事情,等待请求的结果返回后,线程5又接着执行foreach中任务.

Client/Server的异步拉取

如果还没有理解Async Streams的好处,那么我借助客户端 / 服务器端架构是演示这一功能优势的绝佳方法。

同步调用

客户端向服务器端发送请求，客户端必须等待（客户端被阻塞），直到服务器端做出响应.

示例中Yield Return就是以这种方式执行的,所以整个过程只有一个线程即线程1在处理.

异步调用

客户端发出数据块请求，然后继续执行其他操作。一旦数据块到达，客户端就处理接收到的数据块并询问下一个数据块，依此类推，直到达到最后一个数据块为止。这正是 Async Streams 想法的来源。

最后一个示例就是以这种方式执行的,线程5询问下一个数据后并没有等待结果返回,而是去做了Main()函数中的别的事情,数据到达后,线程5又继续处理foreach中的任务.

Tips

如果你使用的是.net core 2.2及以下版本,会遇到这样的报错.

需要安装.net core 3.0 preview的SDK(截至至博客撰写日期4月9日,.net core SDK最新版本为3.0.100-preview3-010431),安装好SDK后,如果你是VS 2019正式版,可能无法选择3.0的与预览版,听过只有VS 2019 Preview才支持.Net core 3.0的预览版.

看完上述内容，你们对await foreach怎么在C# 8.0中使用有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注亿速云行业资讯频道，感谢大家的支持。