📬 MailSettings.cs Documentation


File Path
IrbyImaging.BusinessLogic/SendEmailUtility/MailSettings.cs


📖 Table of Contents

  1. Overview & Purpose
  2. Key Functional Areas
  3. Dependencies & Technologies
  4. Data Model: MailSettings
  5. UML Class Diagram
  6. Configuration & Integration
  7. Sample Code Blocks & Usage Examples
  8. Error Handling & Return Types
  9. Third‑Party Integrations
  10. Conclusion

1. Overview & Purpose

MailSettings.cs defines a Plain-Old CLR Object (POCO) that encapsulates the SMTP/e-mail configuration needed by the SendEmailUtility within the IrbyImaging.BusinessLogic assembly.

🎯 Use Case:

  • Centralize SMTP credentials (host, port, credentials)
  • Bind these settings from appsettings.json (or any configuration provider)
  • Inject into your email-sending service for consistent, strongly-typed access

2. Key Functional Areas

  • Properties

    • Mail
    • DisplayName
    • Password
    • Host
    • Port
  • Configuration Binding

    • Leverages .NET’s Options Pattern (IOptions<MailSettings>) for easy DI
  • Security Considerations

    • Store passwords in Azure Key Vault, User Secrets, or environment variables

3. Dependencies & Technologies

Dependency Purpose
System Base .NET runtime types
System.Collections.Generic (Imported but not directly used)
System.Text (Imported but not directly used)
Microsoft.Extensions.Configuration & Microsoft.Extensions.Options Binding configuration sections to POCOs

ℹ️ Some using directives (Collections.Generic, Text) are present for future expansion but not leveraged by this simple data class.


4. Data Model: MailSettings

namespace IrbyImaging.BusinessLogic.SendEmailUtility
{
    /// <summary>
    /// Encapsulates SMTP e-mail settings.
    /// </summary>
    public class MailSettings
    {
        /// <summary>
        /// The “from” e-mail address.
        /// </summary>
        public string Mail { get; set; }

        /// <summary>
        /// Friendly name displayed alongside the e-mail.
        /// </summary>
        public string DisplayName { get; set; }

        /// <summary>
        /// SMTP account password or app-specific password.
        /// </summary>
        public string Password { get; set; }

        /// <summary>
        /// SMTP server host (e.g., smtp.gmail.com).
        /// </summary>
        public string Host { get; set; }

        /// <summary>
        /// SMTP server port (e.g., 587 for TLS).
        /// </summary>
        public int Port { get; set; }
    }
}

5. UML Class Diagram

classDiagram
    class MailSettings {
        +string Mail
        +string DisplayName
        +string Password
        +string Host
        +int Port
    }

6. Configuration & Integration

appsettings.json

{
  // ... other settings ...
  "MailSettings": {
    "Mail": "[email protected]",
    "DisplayName": "Irby Imaging Service",
    "Password": "your-secure-password",
    "Host": "smtp.mailprovider.com",
    "Port": 587
  }
}

.NET Core Startup Registration

// In Startup.cs or Program.cs (for .NET 6+ minimal APIs)
using IrbyImaging.BusinessLogic.SendEmailUtility;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

// 1. Bind configuration section
services.Configure<MailSettings>(
    Configuration.GetSection(nameof(MailSettings))
);

// 2. Register your email sending service for DI
services.AddTransient<IEmailService, SmtpEmailService>();

7. Sample Code Blocks & Usage Examples

Consuming MailSettings in a Service

using Microsoft.Extensions.Options;
using System.Net;
using System.Net.Mail;

public class SmtpEmailService : IEmailService
{
    private readonly MailSettings _settings;

    public SmtpEmailService(IOptions<MailSettings> options)
    {
        _settings = options.Value;
    }

    public async Task SendEmailAsync(string to, string subject, string htmlBody)
    {
        using var client = new SmtpClient(_settings.Host, _settings.Port)
        {
            Credentials = new NetworkCredential(_settings.Mail, _settings.Password),
            EnableSsl = true
        };

        var mailMessage = new MailMessage
        {
            From = new MailAddress(_settings.Mail, _settings.DisplayName),
            Subject = subject,
            Body = htmlBody,
            IsBodyHtml = true
        };
        mailMessage.To.Add(to);

        await client.SendMailAsync(mailMessage);
    }
}

Example Usage

public class NotificationController : ControllerBase
{
    private readonly IEmailService _emailService;

    public NotificationController(IEmailService emailService)
        => _emailService = emailService;

    [HttpPost("send")]
    public async Task<IActionResult> SendNotification([FromBody] EmailRequest req)
    {
        await _emailService.SendEmailAsync(req.To, req.Subject, req.Content);
        return Ok(new { Message = "Email sent successfully! 📧" });
    }
}

8. Error Handling & Return Types

  • SmtpException
    • Thrown if the SMTP server is unreachable or authentication fails
  • ArgumentException
    • Can be thrown if required settings (e.g., Host or Mail) are missing
  • Async Patterns
    • All I/O operations follow the async/await pattern
  • Return Types
    • Task or Task<T> for asynchronous operations

9. Third‑Party Integrations

  • SMTP Providers
    • Gmail, Outlook, SendGrid, Mailgun, etc.
  • Secrets Management
    • Azure Key Vault
    • AWS Secrets Manager
    • User Secrets for local development

10. Conclusion

🔑 MailSettings.cs is a lightweight configuration model that plays a pivotal role in the SendEmailUtility. By abstracting SMTP details into a strongly-typed class, it:

  • Ensures type-safe access to your mail settings
  • Supports configuration binding and dependency injection
  • Facilitates secure storage of sensitive data via external providers

With this in place, you can build robust email‑sending services with clarity and maintainability. Happy coding and happy emailing! 🎉