.NET 8控制台应用：如何向Channels消费者发送生产者停止信号？

针对你的场景，这里有几个直接可行的实现方式：

方案一：使用"终止标记"通知消费者停止 #

你可以在生产者完成所有邮件任务后，往Channel中发送一个特殊的终止信号，消费者识别到这个信号后停止处理，并触发应用关闭。

实现步骤： #

1. 定义包含终止标记的消息类型：

public class EmailTask
{
    public string To { get; set; }
    public string Content { get; set; }
    // 标记是否为终止信号
    public bool IsTerminationSignal { get; set; } = false;
}

2. 生产者逻辑：收集完邮件后发送终止信号

public class EmailProducer
{
    private readonly Channel<EmailTask> _channel;

    public EmailProducer(Channel<EmailTask> channel)
    {
        _channel = channel;
    }

    public async Task ProduceEmailsAsync()
    {
        // 1. 执行邮件数据收集逻辑
        var emails = GetEmailsFromDataSource();

        // 2. 将所有邮件任务写入Channel
        foreach (var email in emails)
        {
            await _channel.Writer.WriteAsync(new EmailTask
            {
                To = email.To,
                Content = email.Content
            });
        }

        // 3. 发送终止信号并关闭Writer
        await _channel.Writer.WriteAsync(new EmailTask { IsTerminationSignal = true });
        _channel.Writer.Complete();
    }

    // 模拟邮件数据收集方法
    private List<(string To, string Content)> GetEmailsFromDataSource()
    {
        return new List<(string, string)>();
    }
}

3. 消费者（托管服务）逻辑：识别信号并停止应用

public class EmailConsumerService : BackgroundService
{
    private readonly Channel<EmailTask> _channel;
    private readonly IHostApplicationLifetime _appLifetime;

    public EmailConsumerService(Channel<EmailTask> channel, IHostApplicationLifetime appLifetime)
    {
        _channel = channel;
        _appLifetime = appLifetime;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var task in _channel.Reader.ReadAllAsync(stoppingToken))
        {
            if (task.IsTerminationSignal)
            {
                // 收到终止信号，退出处理循环
                break;
            }

            // 执行邮件发送逻辑
            await SendEmailAsync(task);
        }

        // 触发应用停止
        _appLifetime.StopApplication();
    }

    private Task SendEmailAsync(EmailTask task)
    {
        // 你的邮件发送实现
        return Task.CompletedTask;
    }
}

方案二：通过任务完成跟踪直接停止应用 #

如果不需要终止信号，也可以让生产者在写完所有邮件后，等待消费者处理完所有任务，再主动触发应用停止。

实现步骤： #

1. 消费者用TaskCompletionSource跟踪处理完成状态：

public class EmailConsumerService : BackgroundService
{
    private readonly Channel<EmailTask> _channel;
    private readonly IHostApplicationLifetime _appLifetime;
    public TaskCompletionSource<bool> ProcessingCompleted { get; } = new();

    public EmailConsumerService(Channel<EmailTask> channel, IHostApplicationLifetime appLifetime)
    {
        _channel = channel;
        _appLifetime = appLifetime;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            await foreach (var task in _channel.Reader.ReadAllAsync(stoppingToken))
            {
                await SendEmailAsync(task);
            }
            ProcessingCompleted.TrySetResult(true);
        }
        catch (Exception ex)
        {
            ProcessingCompleted.TrySetException(ex);
        }
        finally
        {
            _appLifetime.StopApplication();
        }
    }

    // 邮件发送方法同上
}

2. 生产者写完邮件后等待消费者完成：

public class EmailProducer
{
    private readonly Channel<EmailTask> _channel;
    private readonly EmailConsumerService _consumer;

    public EmailProducer(Channel<EmailTask> channel, EmailConsumerService consumer)
    {
        _channel = channel;
        _consumer = consumer;
    }

    public async Task ProduceAndWaitAsync()
    {
        var emails = GetEmailsFromDataSource();
        foreach (var email in emails)
        {
            await _channel.Writer.WriteAsync(new EmailTask { To = email.To, Content = email.Content });
        }
        _channel.Writer.Complete();

        // 等待消费者处理完所有任务
        await _consumer.ProcessingCompleted.Task;
    }

    // 模拟邮件数据收集方法
    private List<(string To, string Content)> GetEmailsFromDataSource()
    {
        return new List<(string, string)>();
    }
}

3. 主机启动时执行生产者任务：

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddSingleton(Channel.CreateUnbounded<EmailTask>());
        services.AddHostedService<EmailConsumerService>();
        services.AddSingleton<EmailProducer>();
    })
    .Build();

var producer = host.Services.GetRequiredService<EmailProducer>();
await producer.ProduceAndWaitAsync();

await host.RunAsync();

方案三：改为一次性任务模式 #

既然应用每周仅运行一次，完全可以不用长期运行的托管服务，直接在Program.cs中按顺序执行任务：

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // 注册邮件发送相关服务
        services.AddSingleton<IEmailSender, EmailSender>();
    })
    .Build();

using (host)
{
    await host.StartAsync();

    // 1. 收集邮件数据
    var emails = GetEmailsFromDataSource();

    // 2. 并行执行邮件发送
    var emailSender = host.Services.GetRequiredService<IEmailSender>();
    var tasks = emails.Select(email => emailSender.SendAsync(email.To, email.Content));
    await Task.WhenAll(tasks);

    // 3. 停止并退出应用
    await host.StopAsync();
}

// 模拟邮件数据收集和发送接口
public interface IEmailSender { Task SendAsync(string to, string content); }
public class EmailSender : IEmailSender { public Task SendAsync(string to, string content) => Task.CompletedTask; }
private static List<(string To, string Content)> GetEmailsFromDataSource() => new();

这种方式更简洁，无需托管服务长期运行，完成任务后直接退出，完全匹配你的场景。

内容的提问来源于stack exchange，提问作者javery