Introduction

In the world of email communication, an SMTP Server plays a crucial role in sending and receiving emails. Whether you are setting up a personal email system or integrating email functionality into an application, understanding how an SMTP server works is essential.

What is an SMTP Server?

SMTP (Simple Mail Transfer Protocol) is a protocol used for sending emails over the internet. An SMTP Server is a specialized server that follows the SMTP protocol to transmit email messages from a sender to a recipient.

How Does an SMTP Server Work?

1. User Sends an Email: The email client connects to the SMTP server.
2. SMTP Authentication: The server verifies the sender’s credentials.
3. Message Transmission: The email is forwarded to the recipient’s mail server.
4. Recipient Mail Server: The recipient’s server processes and delivers the email.

Key Features of an SMTP Server

• Email Authentication: Prevents unauthorized users from sending emails.
• Spam Filtering: Helps reduce spam and phishing emails.
• Relay Services: Ensures emails reach the correct destination.
• Encryption Support: Uses SSL/TLS for secure email transmission.

Setting Up an SMTP Server

To set up an SMTP server, follow these steps:

Step 1: Choose an SMTP Provider

Some popular SMTP providers include:

• Google SMTP Server (Gmail SMTP Settings) (DoFollow Link)
• Microsoft Outlook SMTP
• SendGrid SMTP

Step 2: Configure SMTP Settings

Common SMTP settings include:

• SMTP Server Address: smtp.example.com
• SMTP Port: 25, 465 (SSL), or 587 (TLS)
• Authentication: Username and Password

Step 3: Set Up SMTP in a Web Application

For example, in an ASP.NET Core application:

var smtpClient = new SmtpClient("smtp.example.com")
{
    Port = 587,
    Credentials = new NetworkCredential("your-email@example.com", "your-password"),
    EnableSsl = true,
};

Common SMTP Errors and Troubleshooting

• SMTP 550 Error: Recipient not found.
• SMTP 554 Error: Message rejected due to spam filtering.
• SMTP Authentication Failed: Incorrect username or password.

Advantages of Using an SMTP Server

• Reliable Email Delivery
• Better Security and Encryption
• Prevention of Spam and Phishing

How to Send Emails in ASP.NET Core Using MailKit

Introduction

Email communication is essential for modern applications, whether for sending notifications, verification codes, or transactional emails. In this guide, we will explore how to send emails using MailKit in an ASP.NET Core application.

What is MailKit?

MailKit is a powerful and feature-rich email library for .NET applications. It supports:

• SMTP (Sending Emails)
• IMAP & POP3 (Receiving Emails)
• Authentication & Encryption

Compared to the deprecated SmtpClient, MailKit is more efficient and flexible.

Why Use MailKit for Email Sending?

✔ Secure authentication & encryption support. ✔ More features than the built-in SMTP client. ✔ Supports modern email sending protocols. ✔ Open-source & actively maintained.

Setting Up MailKit in ASP.NET Core

1. Install MailKit NuGet Package

To install MailKit, run the following command:

Install-Package MailKit

or using .NET CLI:

dotnet add package MailKit

2. Configure SMTP Settings in appsettings.json

Store your SMTP server credentials in appsettings.json:

{
  "EmailSettings": {
    "EmailHost": "smtp.example.com",   
    "EmailPort": 465,   
    "EmailUserName": "your-email@example.com",  
    "EmailPassword": "your-email-password"  
  }
}

3. Create an Email Service

Step 1: Define an Interface

Create IEmailService inside Services or Repository folder:

using System.Threading.Tasks;

namespace YourNamespace.Services
{
    public interface IEmailService
    {
        Task SendEmailAsync(string to, string subject, string body);
    }
}

Step 2: Implement the Email Service

Now, create EmailService.cs:

using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;
using MimeKit.Text;
using Microsoft.Extensions.Configuration;
using System.Threading.Tasks;

namespace YourNamespace.Services
{
    public class EmailService : IEmailService
    {
        private readonly IConfiguration _config;

        public EmailService(IConfiguration config)
        {
            _config = config;
        }

        public async Task SendEmailAsync(string to, string subject, string body)
        {
            var email = new MimeMessage();
            email.From.Add(MailboxAddress.Parse(_config["EmailSettings:EmailUserName"]));
            email.To.Add(MailboxAddress.Parse(to));
            email.Subject = subject;
            email.Body = new TextPart(TextFormat.Html) { Text = body };

            using var smtp = new SmtpClient();
            await smtp.ConnectAsync(
                _config["EmailSettings:EmailHost"],
                int.Parse(_config["EmailSettings:EmailPort"]),
                SecureSocketOptions.SslOnConnect
            );
            
            await smtp.AuthenticateAsync(
                _config["EmailSettings:EmailUserName"], 
                _config["EmailSettings:EmailPassword"]
            );
            
            await smtp.SendAsync(email);
            await smtp.DisconnectAsync(true);
        }
    }
}

4. Register Email Service in Dependency Injection

To use EmailService across the application, register it in Program.cs:

using YourNamespace.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<IEmailService, EmailService>();

var app = builder.Build();

app.Run();

5. Create an Email API Controller

Create EmailController.cs:

using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using YourNamespace.Services;

namespace YourNamespace.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmailController : ControllerBase
    {
        private readonly IEmailService _emailService;

        public EmailController(IEmailService emailService)
        {
            _emailService = emailService;
        }

        [HttpPost("send")] 
        public async Task<IActionResult> SendEmail([FromBody] EmailRequest request)
        {
            await _emailService.SendEmailAsync(request.To, request.Subject, request.Body);
            return Ok("Email Sent Successfully!");
        }
    }

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

Testing the Email API

Using Postman:

1. Open Postman.
2. Select POST method and enter http://localhost:5000/api/email/send.
3. Go to Body → raw → JSON and paste:

{
    "to": "recipient@example.com",
    "subject": "Hello!",
    "body": "This is a test email."
}

4. Click Send.
5. If configured correctly, you will receive an Email Sent Successfully! response.

Conclusion

In this blog, we covered: ✔ Installing and configuring MailKit in ASP.NET Core.
✔ Setting up SMTP settings in appsettings.json.
✔ Implementing an Email Service for sending emails.
✔ Creating a Web API Endpoint to send emails.
✔ Testing the email-sending functionality using Postman.

MailKit is a powerful and flexible email library, making it the best choice for modern .NET applications. 🚀

Additional Resources

• MailKit GitHub Repository (DoFollow)
• ASP.NET Core Official Documentation (DoFollow)

If you have any questions, feel free to ask in the comments!