Products

Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller

Developer

Article Blog Forum Interview Beginner News Startup Quiz

Users

Career

Apply Job Internship

Pricing

Login Sign Up Get a Quote

How to create bulk sender service in C#?

ICSM Computer 805 05 May 2025

How to create bulk sender service in C#?

Ask by ICSM Computer

Updated 01 Jun 2025

1 Answers

ICSM Computer 01 Jun 2025

To create a bulk email sender service in C#, you need to ensure it’s efficient, scalable, and resilient—especially when sending thousands of emails. Here’s a high-level architecture and practical implementation approach.

Key Components of a Bulk Email Sender Service

Email Queue – Holds messages to be sent (in-memory or persistent).
Background Worker/Hosted Service – Dequeues and sends emails.
SMTP Client – Sends emails via an SMTP server.
Throttling & Retry Logic – Controls sending rate and handles failures.
Logging – For audit and troubleshooting.
(Optional) Database + Status Tracking – To persist and track email status.

Basic Implementation (Console App / Windows Service Style)

1. Email Model

public class EmailMessage
{
    public string To { get; set; }
    public string Subject { get; set; }
    public string Body { get; set; }
}

2. Email Sender Service

public class EmailSenderService
{
    private readonly SmtpClient _smtpClient;

    public EmailSenderService()
    {
        _smtpClient = new SmtpClient("smtp.example.com", 587)
        {
            Credentials = new NetworkCredential("your@email.com", "password"),
            EnableSsl = true
        };
    }

    public async Task SendEmailAsync(EmailMessage message)
    {
        var mail = new MailMessage("your@email.com", message.To, message.Subject, message.Body)
        {
            IsBodyHtml = true
        };

        try
        {
            await _smtpClient.SendMailAsync(mail);
        }
        catch (SmtpException ex)
        {
            // Log and handle retry
            Console.WriteLine($"Failed to send to {message.To}: {ex.Message}");
            throw;
        }
    }
}

3. Producer: Enqueue Emails

public class EmailQueue
{
    private readonly ConcurrentQueue<EmailMessage> _queue = new();
    public void Enqueue(EmailMessage email) => _queue.Enqueue(email);
    public bool TryDequeue(out EmailMessage email) => _queue.TryDequeue(out email);
}

4. Consumer: Background Worker

public class BulkEmailWorker
{
    private readonly EmailQueue _queue;
    private readonly EmailSenderService _sender;

    public BulkEmailWorker(EmailQueue queue, EmailSenderService sender)
    {
        _queue = queue;
        _sender = sender;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            if (_queue.TryDequeue(out var email))
            {
                try
                {
                    await _sender.SendEmailAsync(email);
                }
                catch
                {
                    // Retry logic or logging
                }

                // Optional throttling
                await Task.Delay(100); // 10 emails per second
            }
            else
            {
                await Task.Delay(500); // No email found, wait a bit
            }
        }
    }
}

5. Putting It Together (Console Example)

var queue = new EmailQueue();
var sender = new EmailSenderService();
var worker = new BulkEmailWorker(queue, sender);

// Enqueue sample emails
for (int i = 0; i < 1000; i++)
{
    queue.Enqueue(new EmailMessage
    {
        To = $"user{i}@example.com",
        Subject = "Test Bulk Email",
        Body = $"Hello user{i}, this is a test email."
    });
}

var cts = new CancellationTokenSource();
await worker.StartAsync(cts.Token);

Advanced Features (for production)

Feature	Benefit
Database-backed Queue	Resume on restart, large-scale durability
Email Template Engine	Personalize content (e.g., RazorLight or Scriban)
Throttling / Rate Limits	Avoid SMTP bans (e.g., limit to 100 per minute)
Retry Policy (Polly)	Retry failed emails with backoff
Parallelism	Send multiple emails in parallel (within SMTP limits)
Monitoring UI / Logs	Track successes/failures

Notes on SMTP Providers

Gmail SMTP has sending limits (e.g., ~500/day).
Use bulk-friendly providers for production:
1. SendGrid
2. Amazon SES
3. Mailgun
4. SMTP2GO

They often have SDKs or REST APIs more suitable for bulk sending than raw SMTP.

advertising

Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.