Использование многопоточности для отправки нескольких писем

Я пытаюсь отправить любое количество писем в кратчайшие сроки с помощью .NET 5.0?

Я играл с чем-то вроде следующего, но я не уверен, оптимально это или даже правильно, поскольку есть ряд элементов, которые я не понимаю.

public async Task SendEmailAsync(string subject, string htmlMessage,
    IEnumerable<string> recipients, string? attachment)
{
    using SemaphoreSlim semaphore = new(10, 10);
    await Task.WhenAll(recipients.Select(async recipient =>
    {
        await semaphore.WaitAsync();

        try
        {
            return SendEmailAsync(subject, htmlMessage, recipient, attachment);
        }
        finally
        {
            semaphore.Release();
        }
    }));
}

Может ли кто-нибудь уточнить, правильно ли это, или сообщить мне, знают ли они лучший подход?

Нет, этот код не уважает семафор. Он просто отправляет все электронные письма без ограничения степени параллелизма семафором. Так как return SendEmailAsync возвращается сразу после Task объект получен, а метод не завершен, семафор немедленно освобождается. Таким образом, семафор воспроизводит только запросы на создание, что, как я полагаю, будет быстрым.

Исправление await в try пункт.

public async Task SendEmailAsync(string subject, string htmlMessage,
    IEnumerable<string> recipients, string? attachment)
{
    using SemaphoreSlim semaphore = new(10);
    await Task.WhenAll(recipients.Select(recipient =>
        SendEmailAsync(subject, htmlMessage, recipient, attachment, semaphore)));
}

private async Task SendEmailAsync(string subject, string htmlMessage,
    string recipient, string? attachment, SemaphoreSlim semaphore)
{
    await semaphore.WaitAsync();
    try
    {
        await SendEmailAsync(subject, htmlMessage, recipient, attachment);
    }
    finally
    {
        semaphore.Release();
    }
}

Остальная часть кода мне подходит. Вероятно, я могу только предложить использовать ООП для инкапсуляции данных для массовой рассылки по электронной почте в какой-то класс. Это упростило бы улучшение кода пушнины.

Ваш подход может привести к огромному количеству активных задач в любой момент времени, каждая из которых представляет собой нагрузку на ресурсы ввода-вывода машины. Вам нужен способ ограничить количество задач.

Ваш подход также довольно плохо злоупотребляет вызовом Select (). По крайней мере, это делает код очень трудным для чтения.

Вот демонстрация с использованием фиксированного количества задач для имитации отправки электронного письма 1000 получателям. Обратите внимание, что доступ к общей Queue <> не нужно синхронизировать в этом примере, но это может потребоваться в зависимости от вызова API, используемого на практике, поэтому я добавил синхронизацию. Достаточно простой блокировки {}.

private static readonly Random random = new Random();
private static readonly Queue<string> recipients = new Queue<string>();

protected override async Task Run()
{
    for  (int i = 1; i <= 1000; ++i)
    {
        recipients.Enqueue($"recipient_{i:00000}@emaildomain.com");
    }

    List<Task> tasks = new List<Task>();

    for (int i = 1; i <= 50; ++i)
    {
        tasks.Add(SendEmails($"Task {i:00000}"));
    }

    await Task.WhenAll(tasks);
}

private static async Task SendEmails(string taskName)
{
    for (; ;)
    {
        string recipient;

        lock (recipients)
        {
            if (recipients.Count == 0)
            {
                break;
            }

            recipient = recipients.Dequeue();
        }

        Debug.WriteLine($"{taskName}: Sending to {recipient}...");
        await SendEmailAsync(recipient);
        Debug.WriteLine($"{taskName}: Sending to {recipient} complete");
    }

    Debug.WriteLine($"{taskName}: No more recipients; quitting");
}

private static async Task SendEmailAsync(string recipient)
{
    // Simulate sending an email with random network latency.
    await Task.Delay(random.Next(100, 2000));
}