.NET 中 Channel 类的简单使用

.NET Core 3.0 引入了 `System.Threading.Channels` 命名空间，它提供了一套异步数据结构，用于生产者和消费者之间的数据传递。`Channel<T>` 类是其中的核心组件，类似于内存中的消息队列，支持高性能的并发数据流操作。本文将介绍 `Channel<T>` 类的基本用法，并提供示例代码，帮助开发者理解并应用这一强大的特性。

引言
`Channel<T>` 类作为.NET Core中的新特性，为生产者和消费者模型提供了一种高效的实现方式。它允许我们在不同的线程或异步任务之间传递数据，而无需使用传统的线程同步机制。

`Channel<T>` 类提供了两种类型的通道：
无界通道（`Channel.CreateUnbounded<T>()`）：可以无限容纳数据，有界通道（`Channel.CreateBounded<T>(capacity)`）：容量有限，写入操作在通道满时会阻塞。

以下是使用 `Channel<T>` 类创建生产者-消费者模型的示例代码：

1：使用无界通道

```csharp
using System;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;


class Program
{
    static async Task Main(string[] args)
    {
        var channel = Channel.CreateUnbounded<int>();
        var producer = Task.Run(async () =>
        {
            for (int i = 0; i < 10; i++)
            {
                await channel.Writer.WriteAsync(i);
                Console.WriteLine($"Producer: {i}");
                await Task.Delay(1000);
            }
            channel.Writer.Complete();
        });
        var consumer = Task.Run(async () =>
        {
            while (await channel.Reader.WaitToReadAsync())
            {
                while (channel.Reader.TryRead(out int item))
                {
                    Console.WriteLine($"Consumer: {item}");
                }
            }
        });
        await Task.WhenAll(producer, consumer);
    }
}
```

2：使用有界通道

```csharp
// 与无界通道示例类似，但创建通道时使用 Channel.CreateBounded<int>(capacity)
// 并在写入操作后添加了 Console.WriteLine 来输出生产者生成的数据。
```

3：多个生产者和消费者共享一个通道

```csharp
class Program
{
    static async Task Main(string[] args)
    {
        var channel = Channel.CreateUnbounded<int>();
        var producers = new[] { Produce(channel.Writer, 1), Produce(channel.Writer, 2) };
        var consumers = new[] { Consume(channel.Reader, 1), Consume(channel.Reader, 2) };
        await Task.WhenAll(producers.Concat(consumers));
    }


    static async Task Produce(ChannelWriter<int> writer, int id)
    {
        for (int i = 0; i < 10; i++)
        {
            await writer.WriteAsync(i);
            Console.WriteLine($"Producer {id}: {i}");
            await Task.Delay(1000);
        }
        writer.Complete();
    }


    static async Task Consume(ChannelReader<int> reader, int id)
    {
        while (await reader.WaitToReadAsync())
        {
            if (reader.TryRead(out int item))
            {
                Console.WriteLine($"Consumer {id}: {item}");
                await Task.Delay(2000);
            }
        }
    }
}
```

`Channel<T>` 类为.NET Core 3.0 及更高版本提供了一种高效的生产者-消费者模式实现方案。它是一个进程内的内存队列，性能高，适用于高并发场景。但使用时需要注意内存管理和数据的实时性。

推荐阅读
- .NET MAUI 开发在线课程表
- .NET 轻量级、高效任务调度器：ScheduleTask.NET
- Aspire 与 RabbitMQ 的最佳实践

进群学习交流加 : mm1552923

如果喜欢我的文章，那么

“在看”和转发是对我最大的支持！