.NET Core

Runtime Execution Comparison:

// .NET Core application assembly reference
// References are granular NuGet packages
{
  "dependencies": {
    "Microsoft.NETCore.App": {
      "version": "6.0.0",
      "type": "platform"
    },
    "Microsoft.AspNetCore.App": {
      "version": "6.0.0"
    }
  }
}

// .NET Framework assembly reference
// References the entire framework
<Reference Include="System" />
<Reference Include="System.Web" />
        

Platform-Specific Code Implementation:

// Platform-specific code with seamless fallbacks
public string GetOSSpecificTempPath()
{
    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        return Environment.GetEnvironmentVariable("TEMP");
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || 
             RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
    {
        return "/tmp";
    }
    
    // Generic fallback
    return Path.GetTempPath();
}
        

Docker Container Optimization:

# Multi-stage build pattern leveraging cross-platform capabilities
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "./"]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]
        

Advanced Project Creation Examples:

# Create an ASP.NET Core Web API targeting .NET 6.0
dotnet new webapi -n MyApiProject -f net6.0

# Create a class library with a specific output directory
dotnet new classlib -n CoreLibrary -o ./src/Libraries/CoreLib

# Create a solution file
dotnet new sln -n MySolution

# Add projects to a solution
dotnet sln MySolution.sln add ./src/MyProject/MyProject.csproj

# Create a project with specific language version
dotnet new console -n ModernApp --langVersion 10.0
        

Modern Program.cs (NET 6+):

using Microsoft.AspNetCore.Builder;

var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure middleware
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();
        

CI/CD Pipeline Example:

#!/bin/bash
# Example CI/CD build script with optimizations

# Restore with locked dependencies
dotnet restore --locked-mode

# Build with deterministic outputs for reproducibility
dotnet build -c Release /p:ContinuousIntegrationBuild=true /p:EmbedUntrackedSources=true

# Run tests with coverage
dotnet test --no-build -c Release --collect:"XPlat Code Coverage"

# Create optimized single-file deployment
dotnet publish -c Release -r linux-x64 --self-contained true /p:PublishTrimmed=true /p:PublishSingleFile=true
        

Project File Integration:

<Project Sdk="Microsoft.NET.Sdk.Web">
    <PropertyGroup>
        <TargetFramework>net6.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
    
    <ItemGroup>
        <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.5" />
        <PackageReference Include="Serilog.AspNetCore" Version="5.0.0" />
    </ItemGroup>
</Project>
        

Central Package Management Example:

<!-- Directory.Packages.props -->
<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="6.0.5" />
    <PackageVersion Include="Serilog.AspNetCore" Version="5.0.0" />
  </ItemGroup>
</Project>

<!-- Individual project file now just references package without version -->
<ItemGroup>
  <PackageReference Include="Microsoft.EntityFrameworkCore" />
</ItemGroup>
        

Advanced Package Addition:

# Adding with version constraints (floating versions)
dotnet add package Microsoft.EntityFrameworkCore --version "6.0.*"

# Adding to a specific project in a solution
dotnet add ./src/MyProject/MyProject.csproj package Serilog

# Adding from a specific source
dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer --source https://api.nuget.org/v3/index.json

# Adding prerelease versions
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 7.0.0-preview.5.22302.2

# Adding with framework-specific dependencies
dotnet add package Newtonsoft.Json --framework net6.0
        

Listing Packages:

# List installed packages
dotnet list package

# Check for outdated packages
dotnet list package --outdated

# Check for vulnerable packages
dotnet list package --vulnerable

# Format output as JSON for further processing
dotnet list package --outdated --format json
        

Package Removal:

# Remove from all target frameworks
dotnet remove package Newtonsoft.Json

# Remove from specific project
dotnet remove ./src/MyProject/MyProject.csproj package Microsoft.EntityFrameworkCore

# Remove from specific framework
dotnet remove package Serilog --framework net6.0
        

Package Management:

# Install package with specific version
Install-Package Microsoft.AspNetCore.Authentication.JwtBearer -Version 6.0.5

# Install prerelease package
Install-Package Microsoft.EntityFrameworkCore -Pre

# Update package
Update-Package Newtonsoft.Json

# Update all packages in solution
Update-Package

# Uninstall package
Uninstall-Package Serilog

# Installing to specific project in a solution
Install-Package Npgsql.EntityFrameworkCore.PostgreSQL -ProjectName MyProject.Data
        

Advanced PackageReference Options:

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
  </PropertyGroup>
  
  <ItemGroup>
    <!-- Basic package reference -->
    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
    
    <!-- Floating version (latest minor/patch) -->
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.*" />
    
    <!-- Private assets (not exposed to dependent projects) -->
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" PrivateAssets="all" />
    
    <!-- Conditional package reference -->
    <PackageReference Include="Microsoft.Windows.Compatibility" Version="6.0.0" Condition="'$(OS)' == 'Windows_NT'" />
    
    <!-- Package with specific assets -->
    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
    
    <!-- Version range -->
    <PackageReference Include="Serilog" Version="[2.10.0,3.0.0)" />
  </ItemGroup>
</Project>
        

Package Locking:

# Generate lock file 
dotnet restore --use-lock-file

# Force update lock file even if packages seem up-to-date
dotnet restore --force-evaluate
        

Central Package Management:

<!-- Directory.Packages.props at solution root -->
<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
    <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.5" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="6.0.5" />
    <PackageVersion Include="Serilog.AspNetCore" Version="5.0.0" />
  </ItemGroup>
</Project>
        

Manual Configuration Setup:

// Program.cs in a .NET Core application
var builder = WebApplication.CreateBuilder(args);

// Adding configuration sources manually
builder.Configuration.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true)
    .AddEnvironmentVariables()
    .AddCommandLine(args);

// The configuration is automatically added to the DI container
var app = builder.Build();
        

Explicitly Configuring Providers:

var builder = WebApplication.CreateBuilder(args);

// Configure the host with explicit configuration providers
builder.Configuration.Sources.Clear(); // Remove default sources if needed
builder.Configuration
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true, reloadOnChange: true)
    .AddXmlFile("settings.xml", optional: true)
    .AddIniFile("config.ini", optional: true)
    .AddEnvironmentVariables()
    .AddCommandLine(args);

// Custom prefix for environment variables
builder.Configuration.AddEnvironmentVariables(prefix: "MYAPP_");

// Add user secrets in development
if (builder.Environment.IsDevelopment())
{
    builder.Configuration.AddUserSecrets<Program>();
}
        

Implementation Example:

// Service interfaces
public interface IOrderRepository
{
    Task<bool> SaveOrder(Order order);
}

public interface INotificationService
{
    Task NotifyCustomer(string customerId, string message);
}

// Service implementation with injected dependencies
public class OrderService : IOrderService
{
    private readonly IOrderRepository _repository;
    private readonly INotificationService _notificationService;
    private readonly ILogger<OrderService> _logger;
    
    public OrderService(
        IOrderRepository repository,
        INotificationService notificationService,
        ILogger<OrderService> logger)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _notificationService = notificationService ?? throw new ArgumentNullException(nameof(notificationService));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }
    
    public async Task ProcessOrderAsync(Order order)
    {
        _logger.LogInformation("Processing order {OrderId}", order.Id);
        
        await _repository.SaveOrder(order);
        await _notificationService.NotifyCustomer(order.CustomerId, "Your order has been processed");
    }
}

// Registration in Program.cs (for .NET 6+)
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddSingleton<INotificationService, EmailNotificationService>();
builder.Services.AddScoped<IOrderService, OrderService>();
        

Basic Registration Patterns:

// Type-based registration
services.AddTransient<IService, ServiceImplementation>();
services.AddScoped<IRepository, SqlRepository>();
services.AddSingleton<ICacheProvider, RedisCacheProvider>();

// Instance-based registration
var instance = new SingletonService();
services.AddSingleton<ISingletonService>(instance);

// Factory-based registration
services.AddTransient<IConfiguredService>(sp => {
    var config = sp.GetRequiredService<IConfiguration>();
    return new ConfiguredService(config["ServiceKey"]);
});

// Open generic registrations
services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));

// Multiple implementations of the same interface
services.AddTransient<IValidator, CustomerValidator>();
services.AddTransient<IValidator, OrderValidator>();
// Inject as IEnumerable<IValidator> to get all implementations
        

Core Resolution Techniques:

// 1. Constructor Injection (preferred)
public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly ILogger<OrderService> _logger;
    
    public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }
}

// 2. Service Location (avoid when possible, use judiciously)
public void SomeMethod(IServiceProvider serviceProvider)
{
    var service = serviceProvider.GetService<IMyService>(); // May return null
    var requiredService = serviceProvider.GetRequiredService<IMyService>(); // Throws if not registered
}

// 3. Explicit Activation via ActivatorUtilities
public static T CreateInstance<T>(IServiceProvider provider, params object[] parameters)
{
    return ActivatorUtilities.CreateInstance<T>(provider, parameters);
}

// 4. Action Injection in ASP.NET Core
public IActionResult MyAction([FromServices] IMyService service)
{
    // Use the injected service
}
        

Registration Extensions and Options:

// With configuration options
services.AddDbContext<ApplicationDbContext>(options => 
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

// Try-Add pattern (only registers if not already registered)
services.TryAddSingleton<IEmailSender, SmtpEmailSender>();

// Replace existing registrations
services.Replace(ServiceDescriptor.Singleton<IEmailSender, MockEmailSender>());

// Decorators pattern
services.AddSingleton<IMailService, MailService>();
services.Decorate<IMailService, CachingMailServiceDecorator>();
services.Decorate<IMailService, LoggingMailServiceDecorator>();

// Register with key (requires third-party extensions)
services.AddKeyedSingleton<IEmailProvider, SmtpEmailProvider>("smtp");
services.AddKeyedSingleton<IEmailProvider, SendGridProvider>("sendgrid");
        

Working with DI Scopes:

// Creating a scope (for background services or singletons that need scoped services)
public class BackgroundWorker : BackgroundService
{
    private readonly IServiceProvider _services;
    
    public BackgroundWorker(IServiceProvider services)
    {
        _services = services;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Create scope to access scoped services from a singleton
            using (var scope = _services.CreateScope())
            {
                var scopedProcessor = scope.ServiceProvider.GetRequiredService<IScopedProcessor>();
                await scopedProcessor.ProcessAsync(stoppingToken);
            }
            
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }
}
        

Request →  Middleware1.Begin
             →  Middleware2.Begin
                 →  Middleware3.Begin
                     →  Application Logic
                 ←  Middleware3.End
             ←  Middleware2.End
         ←  Middleware1.End
→ Response
        

1. Conventional Middleware Class:

The most flexible and maintainable approach is to create a dedicated middleware class:

public class RequestCultureMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestCultureMiddleware> _logger;

    // Constructor injects the next delegate and services
    public RequestCultureMiddleware(RequestDelegate next, ILogger<RequestCultureMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    // The InvokeAsync method is called for each request in the pipeline
    public async Task InvokeAsync(HttpContext context)
    {
        var cultureQuery = context.Request.Query["culture"];
        if (!string.IsNullOrWhiteSpace(cultureQuery))
        {
            var culture = new CultureInfo(cultureQuery);
            CultureInfo.CurrentCulture = culture;
            CultureInfo.CurrentUICulture = culture;
            
            _logger.LogInformation("Culture set to {Culture}", culture.Name);
        }

        // Call the next delegate/middleware in the pipeline
        await _next(context);
    }
}

// Extension method to make it easier to add the middleware
public static class RequestCultureMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestCulture(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestCultureMiddleware>();
    }
}
        

2. Factory-based Middleware:

When middleware needs additional configuration at registration time:

public class ConfigurableMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _message;

    public ConfigurableMiddleware(RequestDelegate next, string message)
    {
        _next = next;
        _message = message;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        context.Items["CustomMessage"] = _message;
        await _next(context);
    }
}

// Extension method with configuration parameter
public static class ConfigurableMiddlewareExtensions
{
    public static IApplicationBuilder UseConfigurable(
        this IApplicationBuilder builder, string message)
    {
        return builder.UseMiddleware<ConfigurableMiddleware>(message);
    }
}

// Usage:
app.UseConfigurable("Custom message here");
        

3. Inline Middleware:

For simple, one-off middleware that doesn't warrant a full class:

app.Use(async (context, next) => {
    // Pre-processing
    var timer = Stopwatch.StartNew();
    var originalBodyStream = context.Response.Body;
    
    using var memoryStream = new MemoryStream();
    context.Response.Body = memoryStream;
    
    try
    {
        // Call the next middleware
        await next();
        
        // Post-processing
        memoryStream.Position = 0;
        await memoryStream.CopyToAsync(originalBodyStream);
    }
    finally
    {
        context.Response.Body = originalBodyStream;
        timer.Stop();
        
        // Log timing information
        context.Response.Headers.Add("X-Response-Time-Ms", 
            timer.ElapsedMilliseconds.ToString());
    }
});
        

4. Terminal Middleware:

For middleware that handles the request completely and doesn't call the next middleware:

app.Run(async context => {
    context.Response.ContentType = "text/plain";
    await context.Response.WriteAsync("Terminal middleware - Pipeline ends here");
});
        

5. Branch Middleware:

For middleware that only executes on specific paths or conditions:

// Map a specific path to a middleware branch
app.Map("/api", api => {
    api.Use(async (context, next) => {
        // API-specific middleware
        context.Response.Headers.Add("X-API-Version", "1.0");
        await next();
    });
});

// MapWhen for conditional branching
app.MapWhen(
    context => context.Request.Headers.ContainsKey("X-Custom-Header"),
    appBuilder => {
        appBuilder.Use(async (context, next) => {
            // Custom header middleware
            await next();
        });
    });
        

Implementation Example:

// Define entity classes with relationships
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    public List<Post> Posts { get; set; } = new List<Post>();
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

// DbContext configuration
public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(
            @"Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True");
    }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasMany(b => b.Posts)
            .WithOne(p => p.Blog)
            .HasForeignKey(p => p.BlogId);
            
        modelBuilder.Entity<Post>()
            .Property(p => p.Title)
            .IsRequired()
            .HasMaxLength(100);
    }
}

// Querying with EF Core
using (var context = new BloggingContext())
{
    // Deferred execution with LINQ-to-Entities
    var query = context.Blogs
        .Where(b => b.Url.Contains("dotnet"))
        .Include(b => b.Posts)
        .OrderBy(b => b.Url);
        
    // Query is executed here
    var blogs = query.ToList();
    
    // Modification with change tracking
    var blog = blogs.First();
    blog.Url = "https://devblogs.microsoft.com/dotnet/";
    blog.Posts.Add(new Post { Title = "What's new in EF Core" });
    
    // Unit of work pattern
    context.SaveChanges();
}
        

Domain Entity Implementation:

// Domain entity with proper encapsulation
public class Order
{
    private readonly List<OrderItem> _items = new List<OrderItem>();
    
    // Private setter keeps encapsulation intact
    public int Id { get; private set; }
    public DateTime OrderDate { get; private set; }
    public OrderStatus Status { get; private set; }
    public CustomerId CustomerId { get; private set; }
    
    // Value object for money
    public Money TotalAmount => CalculateTotalAmount();
    
    // Navigation property with controlled access
    public IReadOnlyCollection<OrderItem> Items => _items.AsReadOnly();
    
    // EF Core requires parameterless constructor, but we can make it protected
    protected Order() { }
    
    // Domain logic enforced through constructor
    public Order(CustomerId customerId)
    {
        CustomerId = customerId ?? throw new ArgumentNullException(nameof(customerId));
        OrderDate = DateTime.UtcNow;
        Status = OrderStatus.Draft;
    }
    
    // Domain behavior enforces consistency
    public void AddItem(Product product, int quantity)
    {
        if (Status != OrderStatus.Draft)
            throw new InvalidOperationException("Cannot modify a finalized order");
            
        var existingItem = _items.SingleOrDefault(i => i.ProductId == product.Id);
        
        if (existingItem != null)
            existingItem.IncreaseQuantity(quantity);
        else
            _items.Add(new OrderItem(this.Id, product.Id, product.Price, quantity));
    }
    
    public void Finalize()
    {
        if (!_items.Any())
            throw new InvalidOperationException("Cannot finalize an empty order");
            
        Status = OrderStatus.Submitted;
    }
    
    private Money CalculateTotalAmount() => 
        new Money(_items.Sum(i => i.LineTotal.Amount), Currency.USD);
}
        

Context Configuration:

public class OrderingContext : DbContext
{
    // Define DbSets for aggregate roots only
    public DbSet<Order> Orders { get; set; }
    public DbSet<Customer> Customers { get; set; }
    public DbSet<Product> Products { get; set; }
    
    private readonly string _connectionString;
    
    // Constructor injection for connection string
    public OrderingContext(string connectionString)
    {
        _connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
    }
    
    // Constructor for DI with DbContextOptions
    public OrderingContext(DbContextOptions<OrderingContext> options) : base(options)
    {
    }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // Only configure if not done externally
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder
                .UseSqlServer(_connectionString)
                .EnableSensitiveDataLogging(sensitiveDataLoggingEnabled: false)
                .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
        }
    }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Apply all configurations from current assembly
        modelBuilder.ApplyConfigurationsFromAssembly(typeof(OrderingContext).Assembly);
        
        // Global query filters
        modelBuilder.Entity<Customer>().HasQueryFilter(c => !c.IsDeleted);
        
        // Computed column example
        modelBuilder.Entity<Order>()
            .Property(o => o.TotalItems)
            .HasComputedColumnSql("(SELECT COUNT(*) FROM OrderItems WHERE OrderId = Order.Id)");
    }
    
    // Override SaveChanges to handle audit properties
    public override int SaveChanges()
    {
        AuditEntities();
        return base.SaveChanges();
    }
    
    public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        AuditEntities();
        return base.SaveChangesAsync(cancellationToken);
    }
    
    private void AuditEntities()
    {
        var entries = ChangeTracker.Entries()
            .Where(e => e.Entity is IAuditable && 
                       (e.State == EntityState.Added || e.State == EntityState.Modified));
                       
        foreach (var entityEntry in entries)
        {
            var entity = (IAuditable)entityEntry.Entity;
            
            if (entityEntry.State == EntityState.Added)
                entity.CreatedAt = DateTime.UtcNow;
                
            entity.LastModifiedAt = DateTime.UtcNow;
        }
    }
}
        

// Separate configuration class for Order entity
public class OrderConfiguration : IEntityTypeConfiguration<Order>
{
    public void Configure(EntityTypeBuilder<Order> builder)
    {
        // Table configuration
        builder.ToTable("Orders", "ordering");
        
        // Key configuration
        builder.HasKey(o => o.Id);
        builder.Property(o => o.Id)
               .UseHiLo("orderseq", "ordering");
        
        // Property configurations
        builder.Property(o => o.OrderDate)
               .IsRequired();
               
        builder.Property(o => o.Status)
               .HasConversion(
                   o => o.ToString(),
                   o => (OrderStatus)Enum.Parse(typeof(OrderStatus), o))
               .HasMaxLength(20);
        
        // Complex/owned type configuration
        builder.OwnsOne(o => o.ShippingAddress, sa =>
        {
            sa.Property(a => a.Street).HasColumnName("ShippingStreet");
            sa.Property(a => a.City).HasColumnName("ShippingCity");
            sa.Property(a => a.Country).HasColumnName("ShippingCountry");
            sa.Property(a => a.ZipCode).HasColumnName("ShippingZipCode");
        });
        
        // Value object mapping
        builder.Property(o => o.TotalAmount)
               .HasConversion(
                   m => m.Amount,
                   a => new Money(a, Currency.USD))
               .HasColumnName("TotalAmount")
               .HasColumnType("decimal(18,2)");
        
        // Relationship configuration
        builder.HasOne<Customer>()
               .WithMany()
               .HasForeignKey(o => o.CustomerId)
               .OnDelete(DeleteBehavior.Restrict);
        
        // Collection navigation property
        builder.HasMany(o => o.Items)
               .WithOne()
               .HasForeignKey(i => i.OrderId)
               .OnDelete(DeleteBehavior.Cascade);
        
        // Shadow properties
        builder.Property<DateTime>("CreatedAt");
        builder.Property<DateTime?>("LastModifiedAt");
        
        // Query splitting hint
        builder.Navigation(o => o.Items).AutoInclude();
    }
}

// Separate configuration class for OrderItem entity
public class OrderItemConfiguration : IEntityTypeConfiguration<OrderItem>
{
    public void Configure(EntityTypeBuilder<OrderItem> builder)
    {
        builder.ToTable("OrderItems", "ordering");
        
        builder.HasKey(i => i.Id);
        
        builder.Property(i => i.Quantity)
               .IsRequired();
        
        builder.Property(i => i.UnitPrice)
               .HasColumnType("decimal(18,2)")
               .IsRequired();
    }
}
        

public static class EntityFrameworkServiceExtensions
{
    public static IServiceCollection AddOrderingContext(
        this IServiceCollection services, 
        string connectionString,
        ILoggerFactory loggerFactory = null)
    {
        services.AddDbContext<OrderingContext>(options =>
        {
            options.UseSqlServer(connectionString, sqlOptions =>
            {
                // Configure connection resiliency
                sqlOptions.EnableRetryOnFailure(
                    maxRetryCount: 5,
                    maxRetryDelay: TimeSpan.FromSeconds(30),
                    errorNumbersToAdd: null);
                    
                // Optimize for multi-tenant databases
                sqlOptions.MigrationsHistoryTable("__EFMigrationsHistory", "ordering");
            });
            
            // Configure JSON serialization
            options.ReplaceService<IValueConverterSelector, StronglyTypedIdValueConverterSelector>();
            
            // Add logging
            if (loggerFactory != null)
                options.UseLoggerFactory(loggerFactory);
        });
        
        // Add read-only context with NoTracking behavior for queries
        services.AddDbContext<ReadOnlyOrderingContext>((sp, options) =>
        {
            var dbContext = sp.GetRequiredService<OrderingContext>();
            options.UseSqlServer(dbContext.Database.GetDbConnection());
            options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
        });
        
        return services;
    }
}
        

Migration Class Structure:

public partial class AddCustomerEmail : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.AddColumn<string>(
            name: "Email",
            table: "Customers",
            type: "nvarchar(max)",
            nullable: true);
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropColumn(
            name: "Email",
            table: "Customers");
    }
}
        

Command Syntax:

# Package Manager Console
Add-Migration MigrationName -Context YourDbContext -OutputDir Migrations/SubDirectory -Project ProjectName -StartupProject StartupProjectName

# .NET CLI
dotnet ef migrations add MigrationName --context YourDbContext --output-dir Migrations/SubDirectory --project ProjectName --startup-project StartupProjectName
        

public partial class CustomMigration : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        // Standard schema operations
        migrationBuilder.CreateTable(
            name: "Orders",
            columns: table => new
            {
                Id = table.Column<int>(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Date = table.Column<DateTime>(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_Orders", x => x.Id);
            });
            
        // Custom SQL for complex operations
        migrationBuilder.Sql(@"
            CREATE PROCEDURE dbo.GetOrderCountByDate
                @date DateTime
            AS
            BEGIN
                SELECT COUNT(*) FROM Orders WHERE Date = @date
            END
        ");
        
        // Data seeding
        migrationBuilder.InsertData(
            table: "Orders",
            columns: new[] { "Date" },
            values: new object[] { new DateTime(2025, 1, 1) });
    }
    
    protected override void Down(MigrationBuilder migrationBuilder)
    {
        // Clean up in reverse order
        migrationBuilder.Sql("DROP PROCEDURE dbo.GetOrderCountByDate");
        migrationBuilder.DropTable(name: "Orders");
    }
}
        

Command Syntax:

# Package Manager Console
Update-Database -Migration MigrationName -Context YourDbContext -Connection "YourConnectionString" -Project ProjectName

# .NET CLI
dotnet ef database update MigrationName --context YourDbContext --connection "YourConnectionString" --project ProjectName
        

// For application startup scenarios
public static void MigrateDatabase(IHost host)
{
    using (var scope = host.Services.CreateScope())
    {
        var services = scope.ServiceProvider;
        var context = services.GetRequiredService<YourDbContext>();
        var logger = services.GetRequiredService<ILogger<Program>>();
        
        try
        {
            logger.LogInformation("Migrating database...");
            context.Database.Migrate();
            logger.LogInformation("Database migration complete");
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "An error occurred during migration");
            throw;
        }
    }
}

// For more control over the migration process
public static void ApplySpecificMigration(YourDbContext context, string targetMigration)
{
    var migrator = context.GetService<IMigrator>();
    migrator.Migrate(targetMigration);
}
        

# Generate SQL script for migrations without applying them
dotnet ef migrations script PreviousMigration TargetMigration --context YourDbContext --output migration-script.sql --idempotent
        

# Revert to a specific previous migration
dotnet ef database update TargetMigrationName
        

# Remove all migrations
dotnet ef database update 0
        

# Remove the latest migration (if not applied to database)
dotnet ef migrations remove
        

Example: Renaming a column with data preservation

// In Up() method:
// 1. Add new column
migrationBuilder.AddColumn<string>(
    name: "NewName",
    table: "Customers",
    nullable: true);

// 2. Copy data
migrationBuilder.Sql("UPDATE Customers SET NewName = OldName");

// 3. Make new column required if needed
migrationBuilder.AlterColumn<string>(
    name: "NewName",
    table: "Customers",
    nullable: false,
    defaultValue: "");

// 4. Drop old column
migrationBuilder.DropColumn(
    name: "OldName",
    table: "Customers");
        

Internal Flow Diagram:

┌───────────┐     ┌───────────────┐     ┌─────────────────┐
│ ILogger<T>│────▶│ LoggerFactory │────▶│ ILoggerProviders │
└───────────┘     └───────────────┘     └─────────────────┘
                                                 │
                                                 ▼
                                         ┌───────────────┐
                                         │ Output Target │
                                         └───────────────┘
        

Advanced Usage with LoggerMessage Source Generation:

public static partial class LoggerExtensions
{
    [LoggerMessage(
        EventId = 1001,
        Level = LogLevel.Warning,
        Message = "Database connection failed after {RetryCount} retries. Error: {ErrorMessage}")]
    public static partial void DatabaseConnectionFailed(
        this ILogger logger,
        int retryCount, 
        string errorMessage);
}

// Usage
logger.DatabaseConnectionFailed(3, ex.Message);
        

Minimal API Style (NET 6+):

var builder = WebApplication.CreateBuilder(args);

// Configure logging
builder.Logging.ClearProviders()
    .AddConsole()
    .AddDebug()
    .AddEventSourceLogger()
    .SetMinimumLevel(LogLevel.Information);
        

Host Builder Style:

Host.CreateDefaultBuilder(args)
    .ConfigureLogging((hostContext, logging) =>
    {
        logging.ClearProviders();
        logging.AddConfiguration(hostContext.Configuration.GetSection("Logging"));
        logging.AddConsole(options => options.IncludeScopes = true);
        logging.AddDebug();
        logging.AddEventSourceLogger();
        logging.AddFilter("Microsoft", LogLevel.Warning);
    })
    .ConfigureWebHostDefaults(webBuilder => 
    {
        webBuilder.UseStartup<Startup>();
    });
        

1. Cookie Authentication (Server-rendered Applications):

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options => 
    {
        options.Cookie.HttpOnly = true;
        options.Cookie.SameSite = SameSiteMode.Lax;
        options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
        options.ExpireTimeSpan = TimeSpan.FromHours(1);
        options.SlidingExpiration = true;
        options.LoginPath = "/Account/Login";
        options.AccessDeniedPath = "/Account/AccessDenied";
        options.Events = new CookieAuthenticationEvents
        {
            OnValidatePrincipal = async context => 
            {
                // Custom validation logic
            }
        };
    });
        

2. JWT Authentication (Web APIs):

services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = Configuration["Jwt:Issuer"],
        ValidAudience = Configuration["Jwt:Audience"],
        IssuerSigningKey = new SymmetricSecurityKey(
            Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))
    };
    
    options.Events = new JwtBearerEvents
    {
        OnMessageReceived = context =>
        {
            // Custom token extraction logic
            return Task.CompletedTask;
        },
        OnTokenValidated = context =>
        {
            // Additional validation
            return Task.CompletedTask;
        }
    };
});
        

3. ASP.NET Core Identity (Full Identity System):

services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

services.AddIdentity<ApplicationUser, IdentityRole>(options =>
{
    // Password settings
    options.Password.RequireDigit = true;
    options.Password.RequiredLength = 8;
    options.Password.RequireNonAlphanumeric = true;
    
    // Lockout settings
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15);
    options.Lockout.MaxFailedAccessAttempts = 5;
    
    // User settings
    options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();

// Add authentication with Identity
services.AddAuthentication(options =>
{
    options.DefaultScheme = IdentityConstants.ApplicationScheme;
    options.DefaultSignInScheme = IdentityConstants.ExternalScheme;
})
.AddIdentityCookies();
        

4. External Authentication Providers:

services.AddAuthentication()
    .AddGoogle(options =>
    {
        options.ClientId = Configuration["Authentication:Google:ClientId"];
        options.ClientSecret = Configuration["Authentication:Google:ClientSecret"];
        options.CallbackPath = "/signin-google";
        options.SaveTokens = true;
    })
    .AddMicrosoftAccount(options =>
    {
        options.ClientId = Configuration["Authentication:Microsoft:ClientId"];
        options.ClientSecret = Configuration["Authentication:Microsoft:ClientSecret"];
        options.CallbackPath = "/signin-microsoft";
    })
    .AddFacebook(options =>
    {
        options.AppId = Configuration["Authentication:Facebook:AppId"];
        options.AppSecret = Configuration["Authentication:Facebook:AppSecret"];
        options.CallbackPath = "/signin-facebook";
    });
        

[AllowAnonymous]
[HttpPost("login")]
public async Task<IActionResult> Login(LoginDto model)
{
    // Validate user credentials
    var user = await _userManager.FindByNameAsync(model.Username);
    if (user == null || !await _userManager.CheckPasswordAsync(user, model.Password))
    {
        return Unauthorized();
    }
    
    // Create claims for the user
    var claims = new List<Claim>
    {
        new Claim(ClaimTypes.Name, user.UserName),
        new Claim(ClaimTypes.NameIdentifier, user.Id),
        new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
    };
    
    // Get user roles and add them as claims
    var roles = await _userManager.GetRolesAsync(user);
    foreach (var role in roles)
    {
        claims.Add(new Claim(ClaimTypes.Role, role));
    }
    
    // Create signing credentials
    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
    var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
    
    // Create JWT token
    var token = new JwtSecurityToken(
        issuer: _configuration["Jwt:Issuer"],
        audience: _configuration["Jwt:Audience"],
        claims: claims,
        expires: DateTime.Now.AddHours(3),
        signingCredentials: creds);
    
    return Ok(new
    {
        token = new JwtSecurityTokenHandler().WriteToken(token),
        expiration = token.ValidTo
    });
}
        

1. Basic Policy Registration:

services.AddAuthorization(options =>
{
    // Simple claim-based policy
    options.AddPolicy("EmployeeOnly", policy => 
        policy.RequireClaim("EmployeeNumber"));
    
    // Policy with claim value checking
    options.AddPolicy("PremiumTier", policy =>
        policy.RequireClaim("SubscriptionLevel", "Premium", "Enterprise"));
    
    // Policy combining multiple requirements
    options.AddPolicy("AdminFromHeadquarters", policy =>
        policy.RequireRole("Administrator")
             .RequireClaim("Location", "Headquarters"));
    
    // Policy with custom requirement
    options.AddPolicy("AtLeast21", policy =>
        policy.Requirements.Add(new MinimumAgeRequirement(21)));
});
        

2. Custom Authorization Requirements and Handlers:

// A requirement is a simple container for authorization parameters
public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public MinimumAgeRequirement(int minimumAge)
    {
        MinimumAge = minimumAge;
    }

    public int MinimumAge { get; }
}

// A handler evaluates the requirement against a specific context
public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        MinimumAgeRequirement requirement)
    {
        // No DateOfBirth claim means we can't evaluate
        if (!context.User.HasClaim(c => c.Type == "DateOfBirth"))
        {
            return Task.CompletedTask;
        }

        var dateOfBirth = Convert.ToDateTime(
            context.User.FindFirst(c => c.Type == "DateOfBirth").Value);

        int age = DateTime.Today.Year - dateOfBirth.Year;
        if (dateOfBirth > DateTime.Today.AddYears(-age))
        {
            age--;
        }

        if (age >= requirement.MinimumAge)
        {
            context.Succeed(requirement);
        }

        return Task.CompletedTask;
    }
}

// Register the handler
services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();
        

3. Resource-Based Authorization:

// Document ownership requirement
public class DocumentOwnerRequirement : IAuthorizationRequirement { }

// Handler that checks if user owns the document
public class DocumentOwnerHandler : AuthorizationHandler<DocumentOwnerRequirement, Document>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        DocumentOwnerRequirement requirement,
        Document resource)
    {
        if (context.User.FindFirstValue(ClaimTypes.NameIdentifier) == resource.OwnerId)
        {
            context.Succeed(requirement);
        }
        
        return Task.CompletedTask;
    }
}

// In a controller
[HttpGet("documents/{id}")]
public async Task<IActionResult> GetDocument(int id)
{
    var document = await _documentService.GetDocumentAsync(id);
    
    if (document == null)
    {
        return NotFound();
    }
    
    var authorizationResult = await _authorizationService.AuthorizeAsync(
        User, document, "DocumentOwnerPolicy");
    
    if (!authorizationResult.Succeeded)
    {
        return Forbid();
    }
    
    return Ok(document);
}
        

4. Operation-Based Authorization:

// Define operations for a resource
public static class Operations
{
    public static OperationAuthorizationRequirement Create = 
        new OperationAuthorizationRequirement { Name = nameof(Create) };
    
    public static OperationAuthorizationRequirement Read = 
        new OperationAuthorizationRequirement { Name = nameof(Read) };
    
    public static OperationAuthorizationRequirement Update = 
        new OperationAuthorizationRequirement { Name = nameof(Update) };
    
    public static OperationAuthorizationRequirement Delete = 
        new OperationAuthorizationRequirement { Name = nameof(Delete) };
}

// Handler for document operations
public class DocumentAuthorizationHandler : 
    AuthorizationHandler<OperationAuthorizationRequirement, Document>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        OperationAuthorizationRequirement requirement,
        Document resource)
    {
        var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
        
        // Check for operation-specific permissions
        if (requirement.Name == Operations.Read.Name)
        {
            // Anyone can read public documents
            if (resource.IsPublic || resource.OwnerId == userId)
            {
                context.Succeed(requirement);
            }
        }
        else if (requirement.Name == Operations.Update.Name || 
                 requirement.Name == Operations.Delete.Name)
        {
            // Only owner can update or delete
            if (resource.OwnerId == userId)
            {
                context.Succeed(requirement);
            }
        }
        
        return Task.CompletedTask;
    }
}

// Usage in controller
[HttpPut("documents/{id}")]
public async Task<IActionResult> UpdateDocument(int id, DocumentDto dto)
{
    var document = await _documentService.GetDocumentAsync(id);
    
    if (document == null)
    {
        return NotFound();
    }
    
    var authorizationResult = await _authorizationService.AuthorizeAsync(
        User, document, Operations.Update);
    
    if (!authorizationResult.Succeeded)
    {
        return Forbid();
    }
    
    // Process update...
    return NoContent();
}
        

Multiple Handlers for a Requirement (ANY Logic):

// Custom requirement
public class DocumentAccessRequirement : IAuthorizationRequirement { }

// Handler for document owners
public class DocumentOwnerAuthHandler : AuthorizationHandler<DocumentAccessRequirement, Document>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        DocumentAccessRequirement requirement,
        Document resource)
    {
        var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
        
        if (resource.OwnerId == userId)
        {
            context.Succeed(requirement);
        }
        
        return Task.CompletedTask;
    }
}

// Handler for administrators
public class DocumentAdminAuthHandler : AuthorizationHandler<DocumentAccessRequirement, Document>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        DocumentAccessRequirement requirement,
        Document resource)
    {
        if (context.User.IsInRole("Administrator"))
        {
            context.Succeed(requirement);
        }
        
        return Task.CompletedTask;
    }
}
        

With multiple handlers for the same requirement, access is granted if ANY handler succeeds.

Advanced Health Check Implementation:

// Registration with dependency health checks and custom response
public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks()
        .AddSqlServer(
            connectionString: Configuration["ConnectionStrings:DefaultConnection"],
            name: "sql-db",
            failureStatus: HealthStatus.Degraded,
            tags: new[] { "db", "sql", "sqlserver" })
        .AddRedis(
            redisConnectionString: Configuration["ConnectionStrings:Redis"],
            name: "redis-cache",
            failureStatus: HealthStatus.Degraded,
            tags: new[] { "redis", "cache" })
        .AddCheck(
            name: "Custom", 
            failureStatus: HealthStatus.Degraded,
            tags: new[] { "custom" });
            
    // Add health check publisher for pushing status to monitoring systems
    services.Configure<HealthCheckPublisherOptions>(options =>
    {
        options.Delay = TimeSpan.FromSeconds(5);
        options.Period = TimeSpan.FromSeconds(30);
        options.Timeout = TimeSpan.FromSeconds(5);
        options.Predicate = check => check.Tags.Contains("critical");
    });
    services.AddSingleton<IHealthCheckPublisher, PrometheusHealthCheckPublisher>();
}

// Configuration with custom response writer and filtering by tags
public void Configure(IApplicationBuilder app)
{
    app.UseHealthChecks("/health/live", new HealthCheckOptions
    {
        Predicate = _ => true,
        ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
    });
    
    app.UseHealthChecks("/health/ready", new HealthCheckOptions
    {
        Predicate = check => check.Tags.Contains("ready"),
        ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
    });
    
    app.UseHealthChecks("/health/database", new HealthCheckOptions
    {
        Predicate = check => check.Tags.Contains("db"),
        ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
    });
}
        

Registration in Program.cs (.NET 6+) or Startup.cs:

// Add services to the container
builder.Services.AddHealthChecks()
    // Check database with custom configuration
    .AddSqlServer(
        connectionString: builder.Configuration.GetConnectionString("DefaultConnection"),
        healthQuery: "SELECT 1;",
        name: "sql-server-database",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "db", "sql", "sqlserver" },
        timeout: TimeSpan.FromSeconds(3))
    
    // Check Redis cache
    .AddRedis(
        redisConnectionString: builder.Configuration.GetConnectionString("Redis"),
        name: "redis-cache",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "cache", "redis" })
    
    // Check SMTP server
    .AddSmtpHealthCheck(
        options =>
        {
            options.Host = builder.Configuration["Smtp:Host"];
            options.Port = int.Parse(builder.Configuration["Smtp:Port"]);
        },
        name: "smtp",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "smtp", "email" })
    
    // Check URL availability
    .AddUrlGroup(
        new Uri("https://api.external-service.com/health"),
        name: "external-api",
        failureStatus: HealthStatus.Degraded,
        timeout: TimeSpan.FromSeconds(10),
        tags: new[] { "api", "external" })
    
    // Custom health check
    .AddCheck<CustomBackgroundServiceHealthCheck>(
        "background-processing",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "service", "internal" })
    
    // Check disk space
    .AddDiskStorageHealthCheck(
        setup => setup.AddDrive("C:\\", 1024), // 1GB minimum
        name: "disk-space",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "system" });

// Add health checks UI
builder.Services.AddHealthChecksUI(options =>
{
    options.SetEvaluationTimeInSeconds(30);
    options.MaximumHistoryEntriesPerEndpoint(60);
    options.AddHealthCheckEndpoint("API", "/health");
}).AddInMemoryStorage();
        

Configuration in Program.cs (.NET 6+) or Configure method:

// Configure the HTTP request pipeline
app.UseRouting();

// Advanced health check configuration
app.UseHealthChecks("/health", new HealthCheckOptions
{
    Predicate = _ => true,
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse,
    ResultStatusCodes =
    {
        [HealthStatus.Healthy] = StatusCodes.Status200OK,
        [HealthStatus.Degraded] = StatusCodes.Status200OK,
        [HealthStatus.Unhealthy] = StatusCodes.Status503ServiceUnavailable
    },
    AllowCachingResponses = false
});

// Different endpoints for different types of checks
app.UseHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("ready"),
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

app.UseHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("live"),
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

// Expose health checks as Prometheus metrics
app.UseHealthChecksPrometheusExporter("/metrics", options => options.ResultStatusCodes[HealthStatus.Unhealthy] = 200);

// Add health checks UI
app.UseHealthChecksUI(options =>
{
    options.UIPath = "/health-ui";
    options.ApiPath = "/health-api";
});
        

public class CustomBackgroundServiceHealthCheck : IHealthCheck
{
    private readonly IBackgroundJobService _jobService;
    private readonly ILogger<CustomBackgroundServiceHealthCheck> _logger;
    
    public CustomBackgroundServiceHealthCheck(
        IBackgroundJobService jobService,
        ILogger<CustomBackgroundServiceHealthCheck> logger)
    {
        _jobService = jobService;
        _logger = logger;
    }
    
    public async Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context, 
        CancellationToken cancellationToken = default)
    {
        try
        {
            // Check if the background job queue is processing
            var queueStatus = await _jobService.GetQueueStatusAsync(cancellationToken);
            
            // Get queue statistics
            var jobCount = queueStatus.TotalJobs;
            var failedJobs = queueStatus.FailedJobs;
            var processingRate = queueStatus.ProcessingRatePerMinute;
            
            var data = new Dictionary<string, object>
            {
                { "TotalJobs", jobCount },
                { "FailedJobs", failedJobs },
                { "ProcessingRate", processingRate },
                { "LastProcessedJob", queueStatus.LastProcessedJobId }
            };
            
            // Logic to determine health status
            if (queueStatus.IsProcessing && failedJobs < 5)
            {
                return HealthCheckResult.Healthy("Background processing is operating normally", data);
            }
            
            if (!queueStatus.IsProcessing)
            {
                return HealthCheckResult.Unhealthy("Background processing has stopped", data);
            }
            
            if (failedJobs >= 5 && failedJobs < 20)
            {
                return HealthCheckResult.Degraded(
                    $"Background processing has {failedJobs} failed jobs", data);
            }
            
            return HealthCheckResult.Unhealthy(
                $"Background processing has critical errors with {failedJobs} failed jobs", data);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error checking background service health");
            return HealthCheckResult.Unhealthy("Error checking background service", new Dictionary<string, object>
            {
                { "ExceptionMessage", ex.Message },
                { "ExceptionType", ex.GetType().Name }
            });
        }
    }
}
        

public class CustomHealthCheckPublisher : IHealthCheckPublisher
{
    private readonly ILogger<CustomHealthCheckPublisher> _logger;
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly string _monitoringEndpoint;
    
    public CustomHealthCheckPublisher(
        ILogger<CustomHealthCheckPublisher> logger,
        IHttpClientFactory httpClientFactory,
        IConfiguration configuration)
    {
        _logger = logger;
        _httpClientFactory = httpClientFactory;
        _monitoringEndpoint = configuration["Monitoring:HealthReportEndpoint"];
    }
    
    public async Task PublishAsync(
        HealthReport report, 
        CancellationToken cancellationToken)
    {
        // Create a detailed health report payload
        var payload = new
        {
            Status = report.Status.ToString(),
            TotalDuration = report.TotalDuration,
            TimeStamp = DateTime.UtcNow,
            MachineName = Environment.MachineName,
            Entries = report.Entries.Select(e => new
            {
                Component = e.Key,
                Status = e.Value.Status.ToString(),
                Duration = e.Value.Duration,
                Description = e.Value.Description,
                Error = e.Value.Exception?.Message,
                Data = e.Value.Data
            }).ToArray()
        };
        
        // Log health status locally
        _logger.LogInformation("Health check status: {Status}", report.Status);
        
        try
        {
            // Send to external monitoring system
            using var client = _httpClientFactory.CreateClient("HealthReporting");
            using var content = new StringContent(
                JsonSerializer.Serialize(payload),
                Encoding.UTF8,
                "application/json");
            
            var response = await client.PostAsync(_monitoringEndpoint, content, cancellationToken);
            
            if (!response.IsSuccessStatusCode)
            {
                _logger.LogWarning(
                    "Failed to publish health report. Status code: {StatusCode}",
                    response.StatusCode);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error publishing health report to monitoring system");
        }
    }
}

// Register publisher in DI
services.Configure<HealthCheckPublisherOptions>(options =>
{
    options.Delay = TimeSpan.FromSeconds(5);  // Initial delay
    options.Period = TimeSpan.FromMinutes(1); // How often to publish updates
    options.Timeout = TimeSpan.FromSeconds(30);
    options.Predicate = check => check.Tags.Contains("critical");
});

services.AddSingleton<IHealthCheckPublisher, CustomHealthCheckPublisher>();
        

Health Check Filtering by Environment:

// Only add certain checks in production
if (builder.Environment.IsProduction())
{
    healthChecks.AddCheck<ResourceIntensiveHealthCheck>("production-only-check");
}

// Configure different sets of health checks
var liveChecks = new[] { "self", "live" };
var readyChecks = new[] { "db", "cache", "redis", "messaging", "ready" };

// Register endpoints with appropriate checks
app.UseHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = check => liveChecks.Any(t => check.Tags.Contains(t))
});

app.UseHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => readyChecks.Any(t => check.Tags.Contains(t))
});