.NET  

Building Enterprise-Grade .NET Core Web API: A Clean Architecture Guide

Organizing Your Project: Clean Architecture

Proper layering allows easier maintenance and scaling.

  • MyApp.API: Controllers, Middleware.
  • MyApp.Application: Business Logic, DTOs, Interfaces.
  • MyApp.Domain: Core Entities and Business Rules.
  • MyApp.Infrastructure: External Integrations (SMTP, SignalR, Third-party APIs).
  • MyApp.Persistence: Database Context, Repositories.

Each layer has a clear responsibility, making your code loosely coupled and testable.

SOLID Principles: The Backbone of Maintainable Code

Writing maintainable code means adhering to SOLID principles.

Principle What It Means Example
S - Single Responsibility One class, one responsibility Separate EmailService from ProductService
O - Open/Closed Open for extension, closed for modification Add new payment gateways without editing existing code
L - Liskov Substitution Subtypes can replace base types Derived services behave consistently with base interfaces
I - Interface Segregation Use multiple, specific interfaces instead of one large interface IEmailSender, INotificationSender rather than one big service
D - Dependency Inversion Depend on abstractions, not concrete classes Inject ILogger, IRepository via DI

Middleware Essentials

Middleware handles cross-cutting concerns.

app.UseExceptionHandler();
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.UseHealthChecks("/health");
app.UseCors();

Key middlewares

  • Global error handling
  • JWT Authentication & Authorization
  • Health checks for uptime monitoring
  • CORS for cross-origin requests

JWT Authentication & Role-Based Access

Secure your APIs by configuring JWT authentication.

services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        // configure
    });

Protect endpoints.

[Authorize(Roles = "Admin")]
public IActionResult CreateProduct(ProductDto product)
{
    // ...
}

SMTP Email Integration

Integrate email functionality using SMTP clients like MailKit or SendGrid.

Example interface

public interface IEmailService
{
    Task SendEmailAsync(string to, string subject, string body);
}

public class SmtpEmailService : IEmailService
{
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        // Use MailKit or SmtpClient to send emails
    }
}

Use cases include

  • User registration confirmation
  • Password reset
  • Alerts and notifications

Real-Time Communication with SignalR

Use SignalR for real-time features like chat or live dashboards.

public class NotificationHub : Hub
{
    public async Task SendNotification(string message)
    {
        await Clients.All.SendAsync("ReceiveNotification", message);
    }
}

Configure in your app

app.MapHub<NotificationHub>("/notifications");

Third-Party Integrations

Enterprise apps often need to integrate with external services.

  • Payment gateways: Stripe, PayPal, Razorpay
  • Cloud storage: AWS S3, Azure Blob Storage, Google Cloud Storage
  • Analytics: Google Analytics, Application Insights
  • Authentication: OAuth providers like Google, Facebook, Azure AD

Use abstraction layers and interfaces to keep these loosely coupled and swappable.

Health Checks and Monitoring

Monitor app health with built-in health checks.

services.AddHealthChecks()
        .AddSqlServer(Configuration.GetConnectionString("DefaultConnection"));

app.UseEndpoints(endpoints =>
{
    endpoints.MapHealthChecks("/health");
});

Combine with tools like Azure Monitor or Prometheus for full observability.

Logging with Serilog

Configure Serilog for structured logging.

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .WriteTo.File("Logs/log-.txt", rollingInterval: RollingInterval.Day)
    .CreateLogger();

Inject ILogger<T> into services for granular logs.

Summary Checklist

Feature Included
Clean Layered Architecture ✅
SOLID Principles ✅
Middleware (Error, Auth) ✅
JWT Authentication ✅
SMTP Email Service ✅
SignalR Real-Time ✅
Third-Party Integrations ✅
Health Checks ✅
Serilog Logging ✅

A well-architected .NET Core backend follows separation of concerns, solid principles, and integrates smoothly with third-party services. This ensures your enterprise app is scalable, secure, and easy to maintain.

Membership not found