Round #305

Implement async producer-consumer pattern using Channel<T>

**Async Producer-Consumer Pattern using Channel<T>** The producer-consumer pattern is a classic design pattern that allows for asynchronous communication between two or more threads. In this implementation, we will use the `Channel<T>` class in C# to create an async producer-consumer pattern. ### Overview * The producer will write items to the channel. * The consumer will read items from the channel. ### Implementation ```csharp using System; using System.Threading; using System.Threading.Channels; using System.Threading.Tasks; public class ProducerConsumerExample { public async Task RunAsync() { // Create a channel with a bounded capacity of 10 items var channel = Channel.CreateBounded<int>(new BoundedChannelOptions(10) { FullMode = BoundedChannelFullMode.Wait }); // Start the producer _ = ProduceAsync(channel.Writer, 10); // Start the consumer await ConsumeAsync(channel.Reader); } private async Task ProduceAsync(ChannelWriter<int> writer, int count) { for (int i = 0; i < count; i++) { Console.WriteLine($"Producing {i}"); await writer.WriteAsync(i); await Task.Delay(100); // Simulate production delay } writer.Complete(); } private async Task ConsumeAsync(ChannelReader<int> reader) { while (await reader.WaitToReadAsync()) { while (reader.TryRead(out int item)) { Console.WriteLine($"Consumed {item}"); } } } } class Program { static async Task Main(string[] args) { var example = new ProducerConsumerExample(); await example.RunAsync(); } } ``` ### Explanation * We create a `Channel<int>` with a bounded capacity of 10 items. This means that the producer will block if the channel is full. * The `ProduceAsync` method writes items to the channel. It simulates a production delay using `Task.Delay`. * The `ConsumeAsync` method reads items from the channel. It uses `WaitToReadAsync` to wait for items to be available in the channel. * In the `Main` method, we create an instance of `ProducerConsumerExample` and run it asynchronously. ### Advice * Use `Channel<T>` for async producer-consumer patterns. * Choose the correct `BoundedChannelFullMode` based on your requirements. In this example, we use `BoundedChannelFullMode.Wait` to block the producer if the channel is full. * Use `WaitToReadAsync` to wait for items to be available in the channel. * Use `TryRead` to read items from the channel without blocking.

```csharp using System; using System.Threading; using System.Threading.Tasks; using System.Threading.Channels; public class ProducerConsumerExample { public async Task RunExampleAsync() { // Create a bounded channel with a capacity of 10 items var channel = Channel.CreateBounded<int>(new BoundedChannelOptions(10) { FullMode = BoundedChannelFullMode.Wait }); // Start the producer _ = ProduceAsync(channel.Writer, 10); // Start the consumer await ConsumeAsync(channel.Reader); } private async Task ProduceAsync(ChannelWriter<int> writer, int count) { try { for (int i = 0; i < count; i++) { await writer.WriteAsync(i); Console.WriteLine($"Produced: {i}"); await Task.Delay(100); } writer.Complete(); } catch (Exception ex) { Console.WriteLine($"Producer error: {ex.Message}"); writer.TryComplete(ex); } } private async Task ConsumeAsync(ChannelReader<int> reader) { try { while (await reader.WaitToReadAsync()) { while (reader.TryRead(out int item)) { Console.WriteLine($"Consumed: {item}"); } } } catch (Exception ex) { Console.WriteLine($"Consumer error: {ex.Message}"); } } } class Program { static async Task Main(string[] args) { var example = new ProducerConsumerExample(); await example.RunExampleAsync(); } } ``` This implementation uses `Channel<T>` to create a bounded channel, which allows for asynchronous producer-consumer communication. The `ProduceAsync` method writes items to the channel, while the `ConsumeAsync` method reads items from the channel. The `Channel.CreateBounded` method is used to create a bounded channel with a capacity of 10 items. The `BoundedChannelFullMode.Wait` option is used to specify that the producer should wait when the channel is full. The `ProduceAsync` method uses a `for` loop to produce 10 items and writes each item to the channel using `writer.WriteAsync`. The `ConsumeAsync` method uses a `while` loop to read items from the channel using `reader.TryRead`. The `TryRead` method is used to read items from the channel without blocking. If the channel is empty, the method returns `false`. The `WaitToReadAsync` method is used to wait for items to be available in the channel. Error handling is implemented using `try-catch` blocks to catch any exceptions that may occur during production or consumption. If an exception occurs, the error message is printed to the console, and the channel is completed or marked as failed using `writer.TryComplete` or `writer.Complete`.