ایمیل ساده ارسال API با .NET

namespace EmailSenderAPI.Models
{
    public class EmailDto
    {
        [Required]
        public string To { get; set; } = string.Empty;

        [Required]
        public string ContactName { get; set; } = string.Empty;

        [Required]
        public string Body { get; set; } = string.Empty;
    }
}

using EmailSenderAPI.Models;

namespace EmailSenderAPI.Services.EmailService
{
    public interface IEmailService
    {
        void SendEmail(EmailDto request);
    }
}

using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;
using MimeKit.Text;
using EmailSenderAPI.Models;
using Microsoft.Extensions.Logging;

namespace EmailSenderAPI.Services.EmailService
{
    public class EmailService(IConfiguration config, ILogger<EmailService> logger) : IEmailService
    {
        private readonly IConfiguration _config = config ?? throw new ArgumentNullException(nameof(config));
        private readonly ILogger<EmailService> _logger = logger ?? throw new ArgumentNullException(nameof(logger));

        // Sends both emails: one to the business and one to the customer
        public void SendEmail(EmailDto request)
        {
            ArgumentNullException.ThrowIfNull(request);

            try
            {
                // Send confirmation email to the user
                var confirmationEmail = CreateConfirmationEmail(request);
                SendEmailMessage(confirmationEmail);

                // Send original message to the business
                var businessEmail = CreateBusinessEmail(request);
                SendEmailMessage(businessEmail);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error sending email to {Recipient}", request.To);
                throw;
            }
        }

        // Email to the customer confirming receipt
        private MimeMessage CreateConfirmationEmail(EmailDto request)
        {
            var email = new MimeMessage();

            email.From.Add(MailboxAddress.Parse(_config["EmailUsername"]));
            email.To.Add(MailboxAddress.Parse(request.To));
            email.Subject = "Thank you for your message";

            email.Body = new TextPart(TextFormat.Html)
            {
                Text = "
Thank you for your email. We will get in touch with you shortly.
"
            };

            return email;
        }

        // Email to the business with the user's message
        private MimeMessage CreateBusinessEmail(EmailDto request)
        {
            var email = new MimeMessage();

            email.From.Add(MailboxAddress.Parse(_config["EmailUsername"]));
            email.To.Add(MailboxAddress.Parse(_config["EmailUsername"]));
            email.Subject = $"New message from {request.ContactName}";

            email.Body = new TextPart(TextFormat.Html)
            {
                Text = $@"
                    
New contact form submission
                    
From: {request.ContactName} ({request.To})
                    
Message:
                    {request.Body}"
            };

            return email;
        }

        // Connects and sends the email
        private void SendEmailMessage(MimeMessage email)
        {
            using var smtp = new SmtpClient();

            var host = _config["EmailHost"];
            var port = _config.GetValue<int>("Port");
            var username = _config["EmailUsername"];
            var password = _config["EmailPassword"];

            if (string.IsNullOrWhiteSpace(host))
                throw new InvalidOperationException("EmailHost configuration is missing");
            if (port <= 0)
                throw new InvalidOperationException("Invalid Port configuration");
            if (string.IsNullOrWhiteSpace(username))
                throw new InvalidOperationException("EmailUsername configuration is missing");
            if (string.IsNullOrWhiteSpace(password))
                throw new InvalidOperationException("EmailPassword configuration is missing");

            smtp.Connect(host, port, SecureSocketOptions.StartTls);
            smtp.Authenticate(username, password);

            try
            {
                smtp.Send(email);
            }
            finally
            {
                smtp.Disconnect(true);
            }
        }
    }
}

using System.Net;
using EmailSenderAPI.Models;
using EmailSenderAPI.Services.EmailService;
using Microsoft.AspNetCore.Mvc;

namespace EmailSenderAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmailController(IEmailService emailService) : ControllerBase
    {
        // Service for sending emails
        private readonly IEmailService _emailService = emailService;

        // POST api/email
        [HttpPost]
        public IActionResult SendEmail(EmailDto request)
        {
            // Call the service to send the email
            _emailService.SendEmail(request);

            // Return success response
            return Ok(new { message = "Email sent successfully" });
        }
    }
}

using EmailSenderAPI.Services.EmailService;
using Microsoft.OpenApi.Models;

var builder = WebApplication.CreateBuilder(args);

// ------ Service Configuration ------
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo
    {
        Title = "EmailSenderAPI",
        Version = "v1",
        Description = "Email sending API"
    });
});

// Register custom services
builder.Services.AddScoped<IEmailService, EmailService>();
builder.Services.AddHttpClient();

var app = builder.Build();

// ------ Middleware Pipeline ------
if (app.Environment.IsDevelopment())
{
    // Enable Swagger only in Development
    app.UseSwagger();
    app.UseSwaggerUI(); // Default endpoint: /swagger
}

app.UseHttpsRedirection();
app.MapControllers();
app.Run();

{
  "EmailHost": "smtp.example.com",
  "EmailUsername": "your@email.com",
  "EmailPassword": "yourEmailPassword",
  "Port": 587,
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}