<!-- Modern .NET 8 Project File (.csproj) -->
<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
</Project>

// C# Source Code
public int Add(int a, int b) => a + b;

// Generated Common Intermediate Language (CIL):
// .method public hidebysig instance int32 Add(int32 a, int32 b) cil managed
// {
//     IL_0000: ldarg.1   // Load parameter a onto evaluation stack
//     IL_0001: ldarg.2   // Load parameter b onto evaluation stack
//     IL_0002: add       // Add both values
//     IL_0003: ret       // Return result
// }

// Value Type (struct) - Independent copies
int x = 10;
int y = x;
y = 20;
// Result: x remains 10, y is 20

// Reference Type (class) - Shared heap object
public class Customer { public string Name { get; set; } }
var c1 = new Customer { Name = "Alice" };
var c2 = c1; // Copies reference pointer
c2.Name = "Bob";
// Result: c1.Name is now "Bob" because both point to the same heap address

var data = new byte[1024]; // Allocated in Gen 0
Console.WriteLine($"Generation: {GC.GetGeneration(data)}"); // Output: 0

GC.Collect(0); // Trigger Gen 0 collection
Console.WriteLine($"Generation after collection: {GC.GetGeneration(data)}"); // Promoted to Gen 1

// Total allocated managed memory in bytes
long allocated = GC.GetTotalMemory(forceFullCollection: false);

// 1. Abstraction via Interface
public interface IPaymentProcessor {
    Task<bool> ProcessPaymentAsync(decimal amount);
}

// 2. Encapsulation & Inheritance
public abstract class BaseProcessor : IPaymentProcessor {
    // Encapsulated backing field with validation
    private decimal _feeRate = 0.02m;
    protected decimal CalculateFee(decimal amount) => amount * _feeRate;

    // Polymorphic method to be overridden
    public abstract Task<bool> ProcessPaymentAsync(decimal amount);
}

// 3. Polymorphism in Derived Implementation
public class StripeProcessor : BaseProcessor {
    public override async Task<bool> ProcessPaymentAsync(decimal amount) {
        decimal total = amount + CalculateFee(amount);
        // Process via Stripe API
        return await Task.FromResult(true);
    }
}

// Controllers/ProductsController.cs
public class ProductsController : Controller {
    private readonly IProductService _service;
    
    public ProductsController(IProductService service) {
        _service = service;
    }

    // Handles GET: /Products/Details/5
    [HttpGet]
    public async Task<IActionResult> Details(int id) {
        var product = await _service.GetByIdAsync(id);
        if (product == null) return NotFound();
        
        return View(product); // Passes Product Model to Details.cshtml View
    }
}

var builder = WebApplication.CreateBuilder(args);

// Explicitly configure Kestrel limits
builder.WebHost.ConfigureKestrel(options => {
    options.Limits.MaxConcurrentConnections = 100;
    options.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // 10 MB limit
    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
});

var app = builder.Build();
app.Run();

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

var app = builder.Build();

// 1. Exception Handling & Diagnostics
if (!app.Environment.IsDevelopment()) {
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

// 2. Protocol & Static Files
app.UseHttpsRedirection();
app.UseStaticFiles();

// 3. Routing & Security Policies
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();

// 4. Endpoint Execution
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

public IActionResult Register(UserRegistrationModel model) {
    if (ModelState.IsValid) {
        // Save user to database...
        
        // TempData survives the redirect to the Login page
        TempData["SuccessMessage"] = "Registration successful! Please log in.";
        return RedirectToAction("Login");
    }

    // ViewData & ViewBag are available only to the rendered Register view
    ViewData["PageTitle"] = "Create an Account";
    ViewBag.RoleList = GetAvailableRoles();
    return View(model);
}

[ApiController]
[Route("api/v1/[controller]")] // Resolves to: /api/v1/orders
public class OrdersController : ControllerBase {
    
    // GET: /api/v1/orders/1042
    [HttpGet("{id:int:min(1)}")] // Enforces integer >= 1
    public IActionResult GetById(int id) => Ok(new { OrderId = id });

    // GET: /api/v1/orders/by-code/ORD-998877
    [HttpGet("by-code/{code:regex(^ORD-[0-9]{{6}}$)}")]
    public IActionResult GetByCode(string code) => Ok(new { Code = code });
}

// appsettings.json
// { "SmtpConfig": { "Host": "smtp.mailgun.org", "Port": 587 } }

// 1. Strongly Typed POCO
public class SmtpConfig {
    public string Host { get; set; } = string.Empty;
    public int Port { get; set; }
}

// 2. Program.cs Registration
builder.Services.Configure<SmtpConfig>(builder.Configuration.GetSection("SmtpConfig"));

// 3. Injecting via IOptions<T> in Service
public class EmailService {
    private readonly SmtpConfig _config;
    public EmailService(IOptions<SmtpConfig> options) {
        _config = options.Value;
    }
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Direct endpoint mapping with type-safe parameter binding & OpenAPI metadata
app.MapGet("/api/users/{id:int}", async (int id, IUserService service) => {
    var user = await service.GetByIdAsync(id);
    return user is not null ? Results.Ok(user) : Results.NotFound();
})
.WithName("GetUserById")
.Produces<UserDto>(StatusCodes.Status200OK)
.Produces(StatusCodes.Status404NotFound);

app.Run();

[HttpPost("tenants/{tenantId}/invoices")]
public async Task<IActionResult> CreateInvoice(
    [FromRoute] string tenantId,
    [FromQuery] bool sendEmailNotification,
    [FromHeader("X-Correlation-ID")] string correlationId,
    [FromBody] CreateInvoiceRequest requestDto)
{
    // tenantId comes from the URL route
    // sendEmailNotification comes from ?sendEmailNotification=true
    // correlationId comes from the HTTP Header
    // requestDto is deserialized from the JSON body
    return Ok();
}

public class CreateUserDto {
    [Required(ErrorMessage = "Full Name is required.")]
    [StringLength(50, MinimumLength = 2)]
    public string FullName { get; set; } = string.Empty;

    [Required]
    [EmailAddress(ErrorMessage = "Invalid corporate email address.")]
    public string Email { get; set; } = string.Empty;

    [Range(18, 120, ErrorMessage = "Age must be at least 18.")]
    public int Age { get; set; }
}

// IEnumerable<T>: Forward-only read iteration
IEnumerable<string> names = new List<string> { "Alice", "Bob" };
foreach (var name in names) { /* read only */ }

// ICollection<T>: Adds mutation and Count
ICollection<string> col = new List<string>();
col.Add("Charlie");
int total = col.Count;

// IList<T>: Adds zero-based indexer access
IList<string> indexedList = new List<string> { "First", "Second" };
string first = indexedList[0];
indexedList.Insert(1, "Inserted");</code

// Inefficient: Allocates 10,000 distinct string objects on the Managed Heap!
string result = "";
for (int i = 0; i < 10000; i++) {
    result += i.ToString(); // Generates massive Gen 0 GC pressure
}

// Efficient: Allocates a single mutable buffer
var sb = new System.Text.StringBuilder(capacity: 50000);
for (int i = 0; i < 10000; i++) {
    sb.Append(i);
}
string finalString = sb.ToString();

// C# 8+ Concise using declaration (disposes at end of method scope)
public async Task ProcessFileAsync(string filePath) {
    using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
    using var reader = new StreamReader(fileStream);

    string line = await reader.ReadLineAsync();
    Console.WriteLine(line);
    // fileStream and reader are automatically disposed here, even if an exception occurs
}

// Equivalent legacy try-finally expansion generated by compiler:
// FileStream fileStream = new FileStream(...);
// try { ... }
// finally { if (fileStream != null) ((IDisposable)fileStream).Dispose(); }

// Interface: Capabilities that can be shared across completely unrelated types
public interface IAuditable {
    DateTime CreatedAt { get; set; }
}

// Abstract Class: Core identity with shared baseline logic
public abstract class EntityBase : IAuditable {
    public int Id { get; protected set; }
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

    // Common concrete implementation
    public bool IsNew => Id == 0;

    // Abstract method must be implemented by derived classes
    public abstract void Validate();
}

// 1. Static extension class
public static class StringExtensions {
    public static bool IsValidEmail(this string input) {
        if (string.IsNullOrWhiteSpace(input)) return false;
        return input.Contains('@') && input.Contains('.');
    }
}

// 2. Invocation as if it were an instance method
string userEmail = "admin@rtsall.com";
bool isValid = userEmail.IsValidEmail(); // Fluent syntax

// Compiler translates behind the scenes to:
// bool isValid = StringExtensions.IsValidEmail(userEmail);

// Boxing: int (value on stack) -> boxed into object (heap allocation)
int number = 42;
object boxed = number; // IL instruction: box [System.Runtime]System.Int32

// Unboxing: object on heap -> unboxed back to stack int
int unboxed = (int)boxed; // IL instruction: unbox.any [System.Runtime]System.Int32

// Common hidden boxing pitfall: String formatting with value types
// In older .NET, this boxed 'number':
Console.WriteLine(string.Format("Value: {0}", number)); // 'number' was cast to object!
// In modern .NET, string interpolation uses DefaultInterpolatedStringHandler avoiding boxing:
Console.WriteLine($"Value: {number}");

// 1. In-line Use and Terminal Run
app.Use(async (context, next) =>
{
    var timer = Stopwatch.StartNew();
    // Pre-processing
    await next(context);
    // Post-processing
    timer.Stop();
    context.Response.Headers.Append("X-Response-Time-Ms", timer.ElapsedMilliseconds.ToString());
});

// Branching pipeline
app.Map("/webhook", webhookApp =>
{
    webhookApp.Run(async context =>
    {
        await context.Response.WriteAsync("Handled by dedicated webhook pipeline.");
    });
});

// 2. Class-Based Custom Middleware
public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;

    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("HTTP {Method} {Path} received", context.Request.Method, context.Request.Path);
        await _next(context);
        _logger.LogInformation("HTTP {Method} {Path} responded with {StatusCode}", 
            context.Request.Method, context.Request.Path, context.Response.StatusCode);
    }
}

// Dangerous: Capturing Scoped DbContext inside Singleton
// builder.Services.AddSingleton<WorkerCacheManager>(); // Injecting Scoped DbContext here crashes!

// Correct Pattern: Inject IServiceScopeFactory into the Singleton
public class WorkerCacheManager : IHostedService
{
    private readonly IServiceScopeFactory _scopeFactory;

    public WorkerCacheManager(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    public async Task ProcessOrdersAsync()
    {
        // Explicitly create a scope to resolve scoped services safely
        using var scope = _scopeFactory.CreateScope();
        var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        
        var orders = await dbContext.Orders.Where(o => o.IsPending).ToListAsync();
        // Do processing...
    }
}

// High-level C# written by developer:
public async Task<int> FetchDataLengthAsync(string url)
{
    var content = await _httpClient.GetStringAsync(url);
    return content.Length;
}

// Low-level representation generated by Roslyn:
[CompilerGenerated]
private struct <FetchDataLengthAsync>d__1 : IAsyncStateMachine
{
    public int <>1__state;
    public AsyncTaskMethodBuilder<int> <>t__builder;
    public string url;
    private TaskAwaiter<string> <>u__1;

    public void MoveNext()
    {
        switch (<>1__state)
        {
            case -1:
                // Start call, await GetStringAsync
                TaskAwaiter<string> awaiter = _httpClient.GetStringAsync(url).GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    <>1__state = 0;
                    <>u__1 = awaiter;
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                    return; // Release current thread back to ThreadPool!
                }
                break;
            case 0:
                // Resumed after I/O completed
                string result = <>u__1.GetResult();
                <>t__builder.SetResult(result.Length);
                return;
        }
    }
}

public class ProductCacheService
{
    private readonly IMemoryCache _cache;
    private readonly AppDbContext _db;

    public ProductCacheService(IMemoryCache cache, AppDbContext db)
    {
        _cache = cache;
        _db = db;
    }

    // Returns ValueTask<Product?> to avoid heap allocation on cache hits
    public ValueTask<Product?> GetProductAsync(int id)
    {
        if (_cache.TryGetValue(id, out Product? cachedProduct))
        {
            // Synchronous completion: 0 bytes heap allocation!
            return ValueTask.FromResult(cachedProduct);
        }

        // Asynchronous completion fallback: delegates to Task
        return new ValueTask<Product?>(FetchAndCacheAsync(id));
    }

    private async Task<Product?> FetchAndCacheAsync(int id)
    {
        var product = await _db.Products.FindAsync(id);
        if (product != null)
        {
            _cache.Set(id, product, TimeSpan.FromMinutes(10));
        }
        return product;
    }
}

// 1. Read-Only Query with AsNoTracking (High Performance)
[HttpGet("orders")]
public async Task<IActionResult> GetOrders([FromServices] AppDbContext db)
{
    var orders = await db.Orders
        .AsNoTracking()
        .Where(o => o.Status == OrderStatus.Completed)
        .Select(o => new OrderDto(o.Id, o.TotalAmount, o.CreatedAt))
        .ToListAsync();

    return Ok(orders);
}

// 2. Modifying Tracked Entity
[HttpPut("orders/{id}/cancel")]
public async Task<IActionResult> CancelOrder(int id, [FromServices] AppDbContext db)
{
    var order = await db.Orders.FindAsync(id); // Tracked by default
    if (order == null) return NotFound();

    order.Status = OrderStatus.Cancelled; // ChangeTracker detects this modification!
    await db.SaveChangesAsync();          // Generates UPDATE Orders SET Status = ... WHERE Id = ...

    return NoContent();
}

public class AuditLogFilter : IAsyncActionFilter
{
    private readonly ILogger<AuditLogFilter> _logger;

    public AuditLogFilter(ILogger<AuditLogFilter> logger)
    {
        _logger = logger;
    }

    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        // 1. Logic BEFORE the action executes
        var user = context.HttpContext.User.Identity?.Name ?? "Anonymous";
        var action = context.ActionDescriptor.DisplayName;
        _logger.LogInformation("Action {Action} invoked by {User}", action, user);

        // 2. Invoke the controller action
        var resultContext = await next();

        // 3. Logic AFTER the action executes
        if (resultContext.Exception != null && !resultContext.ExceptionHandled)
        {
            _logger.LogError(resultContext.Exception, "Action {Action} failed", action);
        }
        else
        {
            _logger.LogInformation("Action {Action} completed successfully", action);
        }
    }
}

// Registration via ServiceFilter attribute to support DI
[ServiceFilter(typeof(AuditLogFilter))]
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase { /* ... */ }

// 1. Backing C# View Component Class
public class ShoppingCartSummaryViewComponent : ViewComponent
{
    private readonly ICartService _cartService;

    public ShoppingCartSummaryViewComponent(ICartService cartService)
    {
        _cartService = cartService;
    }

    public async Task<IViewComponentResult> InvokeAsync(string customerId)
    {
        var cart = await _cartService.GetCartAsync(customerId);
        return View(cart); // Looks for Views/Shared/Components/ShoppingCartSummary/Default.cshtml
    }
}

// 2. Invocation in Razor View via Tag Helper:
// <vc:shopping-cart-summary customer-id="@Model.CurrentCustomerId"></vc:shopping-cart-summary>
// Or via C# helper:
// @await Component.InvokeAsync("ShoppingCartSummary", new { customerId = Model.CurrentCustomerId })

// 1. Add Authentication Services in Program.cs
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!)),
            ClockSkew = TimeSpan.Zero // Eliminate default 5-minute clock drift grace period
        };
    });

builder.Services.AddAuthorization();

// 2. Middleware pipeline order (crucial):
app.UseAuthentication();
app.UseAuthorization();

// 3. Generating a Token in Controller:
public string GenerateJwtToken(User user, IConfiguration config)
{
    var claims = new[]
    {
        new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
        new Claim(JwtRegisteredClaimNames.Email, user.Email),
        new Claim(ClaimTypes.Role, user.Role),
        new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
    };

    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config["Jwt:Key"]!));
    var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

    var token = new JwtSecurityToken(
        issuer: config["Jwt:Issuer"],
        audience: config["Jwt:Audience"],
        claims: claims,
        expires: DateTime.UtcNow.AddMinutes(60),
        signingCredentials: creds
    );

    return new JwtSecurityTokenHandler().WriteToken(token);
}

// 1. Typed Client Registration in Program.cs
builder.Services.AddHttpClient<IGithubClient, GithubClient>(client =>
{
    client.BaseAddress = new Uri("https://api.github.com/");
    client.DefaultRequestHeaders.Add("User-Agent", "RtsallApp");
    client.Timeout = TimeSpan.FromSeconds(15);
});

// 2. Consumption via Constructor Injection
public class GithubClient : IGithubClient
{
    private readonly HttpClient _httpClient;

    public GithubClient(HttpClient httpClient)
    {
        _httpClient = httpClient; // Lifecycle managed automatically by factory
    }

    public async Task<UserSummary?> GetUserAsync(string username)
    {
        return await _httpClient.GetFromJsonAsync<UserSummary>($"users/{username}");
    }
}

// DTO Model stays clean and pure:
public record CreateUserRequest(string Email, string Password, int Age);

// Validator class in Application Layer with DI:
public class CreateUserRequestValidator : AbstractValidator<CreateUserRequest>
{
    public CreateUserRequestValidator(IUserRepository userRepo)
    {
        RuleFor(x => x.Email)
            .NotEmpty().WithMessage("Email address is required.")
            .EmailAddress().WithMessage("Invalid email format.")
            .MustAsync(async (email, cancellation) => 
                !await userRepo.EmailExistsAsync(email, cancellation))
            .WithMessage("This email address is already registered.");

        RuleFor(x => x.Password)
            .NotEmpty()
            .MinimumLength(8).WithMessage("Password must be at least 8 characters.")
            .Matches(@"[A-Z]").WithMessage("Password must contain at least one uppercase letter.")
            .Matches(@"[0-9]").WithMessage("Password must contain at least one number.");

        RuleFor(x => x.Age)
            .InclusiveBetween(18, 120).WithMessage("User must be of legal adult age.");
    }
}

// 1. IQueryable: Filtering happens in SQL Server (Server-Side)
// SQL Generated: SELECT TOP 10 * FROM Products WHERE Price > 100
IQueryable<Product> query = dbContext.Products;
var expensiveProducts = query
    .Where(p => p.Price > 100)
    .Take(10)
    .ToList(); // Database only transmits 10 rows over the network!

// 2. IEnumerable: Disaster pitfall!
// SQL Generated: SELECT * FROM Products (Fetches 1,000,000 rows into RAM!)
IEnumerable<Product> memoryQuery = dbContext.Products;
var slowProducts = memoryQuery
    .Where(p => p.Price > 100) // Filter executed in C# memory AFTER downloading everything!
    .Take(10)
    .ToList();

// 1. Eager Loading: 1 SQL Query with LEFT JOIN
var order = await db.Orders
    .Include(o => o.Items)
        .ThenInclude(i => i.Product)
    .FirstOrDefaultAsync(o => o.Id == orderId);

// 2. Explicit Loading: Explicit second query on an existing entity
var blog = await db.Blogs.FindAsync(blogId);

// Later, conditionally fetch posts only if needed:
if (needComments)
{
    await db.Entry(blog)
        .Collection(b => b.Posts)
        .Query()
        .Where(p => p.IsPublished)
        .LoadAsync(); // Executes SELECT * FROM Posts WHERE BlogId = ... AND IsPublished = 1
}

// 1. Strongly typed options POCO
public class SmtpConfig
{
    public const string SectionName = "Smtp";
    public string Host { get; set; } = string.Empty;
    public int Port { get; set; }
    public bool EnableSsl { get; set; }
}

// 2. Registration in Program.cs with validation:
builder.Services.AddOptions<SmtpConfig>()
    .Bind(builder.Configuration.GetSection(SmtpConfig.SectionName))
    .ValidateDataAnnotations()
    .ValidateOnStart(); // Crashes app immediately at startup if config is invalid!

// 3. Injecting IOptionsSnapshot in a Controller:
public class NotificationController : ControllerBase
{
    private readonly SmtpConfig _config;

    public NotificationController(IOptionsSnapshot<SmtpConfig> options)
    {
        _config = options.Value; // Fresh per HTTP request
    }
}

// 1. Implement IExceptionHandler
public class GlobalExceptionHandler : IExceptionHandler
{
    private readonly ILogger<GlobalExceptionHandler> _logger;

    public GlobalExceptionHandler(ILogger<GlobalExceptionHandler> logger)
    {
        _logger = logger;
    }

    public async ValueTask<bool> TryHandleAsync(
        HttpContext httpContext,
        Exception exception,
        CancellationToken cancellationToken)
    {
        _logger.LogError(exception, "Unhandled exception occurred: {Message}", exception.Message);

        var (statusCode, title) = exception switch
        {
            KeyNotFoundException => (StatusCodes.Status404NotFound, "Resource Not Found"),
            UnauthorizedAccessException => (StatusCodes.Status401Unauthorized, "Unauthorized Access"),
            ArgumentException => (StatusCodes.Status400BadRequest, "Invalid Parameter"),
            _ => (StatusCodes.Status500InternalServerError, "Internal Server Error")
        };

        var problemDetails = new ProblemDetails
        {
            Status = statusCode,
            Title = title,
            Detail = exception.Message,
            Instance = httpContext.Request.Path
        };

        httpContext.Response.StatusCode = statusCode;
        await httpContext.Response.WriteAsJsonAsync(problemDetails, cancellationToken);

        return true; // Exception has been successfully handled
    }
}

// 2. Registration in Program.cs
builder.Services.AddExceptionHandler<GlobalExceptionHandler>();
builder.Services.AddProblemDetails();

// Middleware pipeline
app.UseExceptionHandler();

// In Program.cs
var allowedOriginsPolicy = "_rtsallFrontendPolicy";

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: allowedOriginsPolicy, policy =>
    {
        policy.WithOrigins(
                "https://rtsall.com",
                "https://admin.rtsall.com"
            )
            .WithMethods("GET", "POST", "PUT", "DELETE")
            .WithHeaders("Content-Type", "Authorization", "X-Requested-With")
            .AllowCredentials() // Allowed only with explicit origins
            .SetPreflightMaxAge(TimeSpan.FromHours(1)); // Cache preflight OPTIONS for 1hr
    });
});

var app = builder.Build();

// Must be placed between UseRouting and UseAuthorization!
app.UseRouting();
app.UseCors(allowedOriginsPolicy);
app.UseAuthentication();
app.UseAuthorization();

// Positional Record: Concisely generates constructor, properties, deconstruct, and equality
public record UserDto(int Id, string Email, string Role);

// Non-destructive mutation using the 'with' expression:
var user1 = new UserDto(101, "dev@rtsall.com", "User");
var adminUser = user1 with { Role = "Administrator" }; // Clones user1, alters Role

// Value equality:
var user2 = new UserDto(101, "dev@rtsall.com", "User");
bool areEqual = (user1 == user2); // Returns TRUE! (Class would return false)

// 1. Requirement Definition
public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public int MinimumAge { get; }
    public MinimumAgeRequirement(int minimumAge) => MinimumAge = minimumAge;
}

// 2. Authorization Handler
public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context, 
        MinimumAgeRequirement requirement)
    {
        var dobClaim = context.User.FindFirst(c => c.Type == ClaimTypes.DateOfBirth);
        if (dobClaim != null && DateTime.TryParse(dobClaim.Value, out var dob))
        {
            var calculatedAge = DateTime.Today.Year - dob.Year;
            if (dob.Date > DateTime.Today.AddYears(-calculatedAge)) calculatedAge--;

            if (calculatedAge >= requirement.MinimumAge)
            {
                context.Succeed(requirement); // Access granted!
            }
        }
        return Task.CompletedTask;
    }
}

// 3. Register in Program.cs
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AtLeast21", policy =>
        policy.Requirements.Add(new MinimumAgeRequirement(21)));
});
builder.Services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();

// 4. Usage on Controller or Endpoint
[Authorize(Policy = "AtLeast21")]
[HttpGet("vip-lounge")]
public IActionResult GetVipContent() => Ok("Welcome to the VIP Lounge");

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Route Group with common prefix and validation filter
var products = app.MapGroup("/api/products")
    .AddEndpointFilter(async (invocationContext, next) =>
    {
        var id = invocationContext.GetArgument<int>(0);
        if (id <= 0) return Results.BadRequest("Product ID must be greater than zero.");
        return await next(invocationContext);
    });

// Typed endpoint with Results<T>
products.MapGet("/{id:int}", async (int id, AppDbContext db) =>
{
    var product = await db.Products.FindAsync(id);
    return product is not null 
        ? Results.Ok(product) 
        : Results.NotFound();
})
.WithName("GetProductById")
.WithOpenApi();

app.Run();

// 1. Literal strings are automatically interned:
string s1 = "rtsall";
string s2 = "rtsall";
bool sameReference = object.ReferenceEquals(s1, s2); // TRUE! Identical heap pointer

// 2. Dynamically constructed strings are NOT interned by default:
string s3 = new StringBuilder().Append("rts").Append("all").ToString();
bool dynReference = object.ReferenceEquals(s1, s3); // FALSE! Different heap objects

// 3. Manual Interning:
string s4 = string.Intern(s3);
bool internedRef = object.ReferenceEquals(s1, s4); // TRUE! Returned existing pool instance

[HttpPost("stream-upload")]
[DisableFormValueModelBinding] // Disables automatic MVC memory buffering
[RequestSizeLimit(500 * 1024 * 1024)] // 500 MB max limit
public async Task<IActionResult> StreamUpload()
{
    var boundary = HeaderUtilities.RemoveQuotes(
        MediaTypeHeaderValue.Parse(Request.ContentType).Boundary).Value;
    
    var reader = new MultipartReader(boundary, Request.Body);
    var section = await reader.ReadNextSectionAsync();

    while (section != null)
    {
        var hasContentDisposition = ContentDispositionHeaderValue.TryParse(
            section.ContentDisposition, out var contentDisposition);

        if (hasContentDisposition && contentDisposition.IsFileDisposition())
        {
            var trustedFileName = Path.GetRandomFileName() + Path.GetExtension(contentDisposition.FileName.Value);
            var savePath = Path.Combine(_targetStorageFolder, trustedFileName);

            using var targetStream = System.IO.File.Create(savePath);
            await section.Body.CopyToAsync(targetStream); // Direct stream-to-disk!
        }

        section = await reader.ReadNextSectionAsync();
    }

    return Ok(new { message = "Streaming upload completed successfully." });
}

// 1. Program.cs Registration
builder.Services.AddOutputCache(options =>
{
    // Default base policy: 60s cache
    options.AddBasePolicy(builder => builder.Expire(TimeSpan.FromSeconds(60)));
    
    // Custom tagged policy
    options.AddPolicy("CatalogCache", builder => 
        builder.Expire(TimeSpan.FromMinutes(10)).Tag("catalog_tag"));
});

// 2. Cache an Endpoint
app.MapGet("/api/products", async (AppDbContext db) =>
{
    return await db.Products.AsNoTracking().ToListAsync();
})
.CacheOutput("CatalogCache");

// 3. Purge cache on mutation endpoint
app.MapPost("/api/products", async (Product product, AppDbContext db, IOutputCacheStore cacheStore) =>
{
    db.Products.Add(product);
    await db.SaveChangesAsync();
    
    // Instant cache invalidation across all nodes
    await cacheStore.EvictByTagAsync("catalog_tag", default);
    return Results.Created($"/api/products/{product.Id}", product);
});

public class OrderProcessingWorker : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger<OrderProcessingWorker> _logger;

    public OrderProcessingWorker(IServiceScopeFactory scopeFactory, ILogger<OrderProcessingWorker> logger)
    {
        _scopeFactory = scopeFactory;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // PeriodicTimer introduced in .NET 6 avoids timer callback drift
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(30));

        while (!stoppingToken.IsCancellationRequested && 
               await timer.WaitForNextTickAsync(stoppingToken))
        {
            try
            {
                // Create dedicated scope for this execution tick
                using var scope = _scopeFactory.CreateScope();
                var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();

                var pendingOrders = await dbContext.Orders
                    .Where(o => o.Status == OrderStatus.Pending)
                    .Take(50)
                    .ToListAsync(stoppingToken);

                foreach (var order in pendingOrders)
                {
                    order.Status = OrderStatus.Processing;
                }

                await dbContext.SaveChangesAsync(stoppingToken);
                _logger.LogInformation("Processed {Count} pending orders", pendingOrders.Count);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                _logger.LogError(ex, "Error processing background orders batch");
            }
        }
    }
}

public class BankAccount
{
    public int Id { get; set; }
    public decimal Balance { get; set; }

    [Timestamp] // Concurrency Token
    public byte[] RowVersion { get; set; } = null!;
}

// Handling Concurrency Conflict in Service:
public async Task<bool> WithdrawMoneyAsync(int accountId, decimal amount)
{
    const int maxRetries = 3;
    for (int retry = 0; retry < maxRetries; retry++)
    {
        try
        {
            var account = await _db.BankAccounts.FindAsync(accountId);
            if (account == null || account.Balance < amount) return false;

            account.Balance -= amount;
            await _db.SaveChangesAsync();
            return true; // Success!
        }
        catch (DbUpdateConcurrencyException ex)
        {
            // Another transaction updated the balance concurrently
            if (retry == maxRetries - 1) throw; // Rethrow if exhausted

            // Reload original values from database and retry
            var entry = ex.Entries.Single();
            await entry.ReloadAsync();
        }
    }
    return false;
}

// 1. Single Query (Default): Risk of Cartesian Product
// Generates massive SQL with multiple JOINs duplicating parent data
var author = await db.Authors
    .Include(a => a.Books)
    .Include(a => a.Awards)
    .AsSingleQuery()
    .FirstOrDefaultAsync(a => a.Id == authorId);

// 2. Split Query: High Performance for Multiple Collections
// Generates 3 clean, independent SQL SELECT statements:
// SELECT ... FROM Authors WHERE Id = @id;
// SELECT ... FROM Books WHERE AuthorId = @id;
// SELECT ... FROM Awards WHERE AuthorId = @id;
var authorClean = await db.Authors
    .Include(a => a.Books)
    .Include(a => a.Awards)
    .AsSplitQuery()
    .FirstOrDefaultAsync(a => a.Id == authorId);

builder.Services.AddHealthChecks()
    // Liveness tag: Self-check
    .AddCheck("self", () => HealthCheckResult.Healthy(), tags: new[] { "live" })
    // Readiness tags: External dependencies
    .AddSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")!,
        name: "sqlserver-check", tags: new[] { "ready" })
    .AddRedis(builder.Configuration.GetConnectionString("Redis")!,
        name: "redis-check", tags: new[] { "ready" });

var app = builder.Build();

// 1. Kubernetes Liveness Probe: Fast, checks only process alive
app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("live")
});

// 2. Kubernetes Readiness Probe: Checks DB + Redis availability
app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("ready"),
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse // Formatted JSON
});

// 1. Define Client Contract Interface
public interface IChatClient
{
    Task ReceiveMessage(string user, string message);
    Task UserJoined(string user);
}

// 2. Strongly Typed Hub
[Authorize]
public class NotificationHub : Hub<IChatClient>
{
    public async Task SendMessageToGroup(string groupName, string message)
    {
        var userName = Context.User?.Identity?.Name ?? "Anonymous";
        // Strongly typed invocation: compile-time safe, no magic strings!
        await Clients.Group(groupName).ReceiveMessage(userName, message);
    }

    public async Task JoinGroup(string groupName)
    {
        await Groups.AddToGroupAsync(Context.ConnectionId, groupName);
        await Clients.Group(groupName).UserJoined(Context.User?.Identity?.Name ?? "New User");
    }
}

// 3. Program.cs Registration
app.MapHub<NotificationHub>("/hubs/notifications");

// 1. Program.cs Serilog Setup
Log.Logger = new LoggerConfiguration()
    .Enrich.FromLogContext()
    .Enrich.WithMachineName()
    .WriteTo.Console(new JsonFormatter())
    .CreateLogger();

builder.Host.UseSerilog();

// 2. Correlation ID Middleware
app.Use(async (context, next) =>
{
    var correlationId = context.Request.Headers["X-Correlation-ID"].FirstOrDefault() 
                        ?? Guid.NewGuid().ToString();
    
    context.Response.Headers["X-Correlation-ID"] = correlationId;

    // Push into Serilog LogContext for all downstream logs
    using (LogContext.PushProperty("CorrelationId", correlationId))
    {
        await next(context);
    }
});

// 3. Structured log consumption in controller:
// Log properties are captured as structured JSON attributes, not flat strings!
_logger.LogInformation("Order {OrderId} placed for Customer {CustomerId} totaling {Amount:C}",
    order.Id, customer.Id, order.TotalAmount);

// 1. Program.cs Registration
builder.Services.AddRateLimiter(options =>
{
    options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;

    // Token Bucket: Burst allowance up to 20, replenishes 5 tokens every 10 seconds
    options.AddTokenBucketLimiter(policyName: "token-bucket-policy", opt =>
    {
        opt.TokenLimit = 20;
        opt.TokensPerPeriod = 5;
        opt.ReplenishmentPeriod = TimeSpan.FromSeconds(10);
        opt.QueueLimit = 0; // Reject immediately, no queuing
    });
});

var app = builder.Build();
app.UseRateLimiter();

// 2. Applying Rate Limit to Endpoint
app.MapPost("/api/login", () => Results.Ok("Login allowed"))
   .RequireRateLimiting("token-bucket-policy");

public class CustomWebApplicationFactory : WebApplicationFactory<Program>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices(services =>
        {
            // Remove real DbContext registration
            var descriptor = services.SingleOrDefault(d => 
                d.ServiceType == typeof(DbContextOptions<AppDbContext>));
            if (descriptor != null) services.Remove(descriptor);

            // Add SQLite or Testcontainer DB
            services.AddDbContext<AppDbContext>(options =>
                options.UseSqlite("DataSource=:memory:"));
        });
    }
}

public class ProductsApiTests : IClassFixture<CustomWebApplicationFactory>
{
    private readonly HttpClient _client;

    public ProductsApiTests(CustomWebApplicationFactory factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task GetProducts_ReturnsSuccessStatusCodeAndJson()
    {
        var response = await _client.GetAsync("/api/products");
        response.EnsureSuccessStatusCode();

        var products = await response.Content.ReadFromJsonAsync<List<ProductDto>>();
        Assert.NotNull(products);
    }
}

// In Program.cs
builder.Services.AddControllers(options =>
{
    // Return 406 Not Acceptable if client requests an unsupported media type
    options.ReturnHttpNotAcceptable = true;
})
.AddXmlDataContractSerializerFormatters(); // Enables XML serializer

// Controller Action automatically respects Accept header:
[HttpGet("data")]
public ActionResult<UserProfile> GetData()
{
    // If client sends Accept: application/xml -> XML returned
    // If client sends Accept: application/json -> JSON returned
    return Ok(new UserProfile { Id = 1, Username = "admin" });
}

# Generate idempotent SQL script in CI/CD pipeline
dotnet ef migrations script --idempotent --output ./migrations/apply_migrations.sql --context AppDbContext

# The generated SQL uses safety guards:
# IF NOT EXISTS(SELECT * FROM [__EFMigrationsHistory] WHERE [MigrationId] = N'20260926_AddOrderIndex')
# BEGIN
#     CREATE INDEX [IX_Orders_CustomerId] ON [Orders] ([CustomerId]);
#     INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion]) VALUES (N'20260926_AddOrderIndex', N'8.0.0');
# END;

[HttpGet("stream-records")]
public async IAsyncEnumerable<SensorDataDto> StreamSensorData(
    [FromServices] AppDbContext db,
    [EnumeratorCancellation] CancellationToken cancellationToken)
{
    // Stream records one-by-one directly from SQL to client:
    // Change tracking is off; memory consumption is virtually zero!
    var dataStream = db.SensorReadings
        .AsNoTracking()
        .OrderByDescending(r => r.Timestamp)
        .AsAsyncEnumerable();

    await foreach (var item in dataStream.WithCancellation(cancellationToken))
    {
        yield return new SensorDataDto(item.Id, item.Temperature, item.Timestamp);
    }
}

public class IdempotentAttribute : Attribute, IAsyncActionFilter
{
    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        var cache = context.HttpContext.RequestServices.GetRequiredService<IDistributedCache>();
        
        if (!context.HttpContext.Request.Headers.TryGetValue("Idempotency-Key", out var key))
        {
            context.Result = new BadRequestObjectResult("Missing Idempotency-Key header.");
            return;
        }

        string cacheKey = $"idempotency:{key}";
        var cachedResponse = await cache.GetStringAsync(cacheKey);

        if (cachedResponse != null)
        {
            // Return identical cached response directly to client!
            context.Result = new ContentResult
            {
                Content = cachedResponse,
                ContentType = "application/json",
                StatusCode = StatusCodes.Status200OK
            };
            return;
        }

        // Execute downstream action
        var executedContext = await next();

        // Cache the successful JSON response for 24 hours
        if (executedContext.Result is ObjectResult objResult && objResult.Value != null)
        {
            var json = JsonSerializer.Serialize(objResult.Value);
            await cache.SetStringAsync(cacheKey, json, new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(24)
            });
        }
    }
}

// Lethal Anti-Pattern: Sync-Over-Async
[HttpGet("bad")]
public IActionResult BadAction()
{
    // Blocks ThreadPool worker synchronously waiting for HTTP I/O
    var result = _httpClient.GetStringAsync("https://api.external.com").Result; // DON'T DO THIS!
    return Ok(result);
}

// Clean Non-Blocking Async Pattern:
[HttpGet("good")]
public async Task<IActionResult> GoodAction(CancellationToken cancellationToken)
{
    // Releases ThreadPool worker immediately during network transit!
    var result = await _httpClient.GetStringAsync("https://api.external.com", cancellationToken);
    return Ok(result);
}

builder.Services.AddDataProtection()
    .SetApplicationName("RtsallUnifiedApp") // Must match across all cluster nodes!
    .PersistKeysToDbContext<AppDbContext>()  // Persist keys to shared SQL database
    .ProtectKeysWithCertificate(certificate); // Encrypt keys at rest using X509 cert

// Or using Redis + Azure Key Vault:
// builder.Services.AddDataProtection()
//     .SetApplicationName("RtsallApp")
//     .PersistKeysToStackExchangeRedis(redisConnection, "DataProtection-Keys")
//     .ProtectKeysWithAzureKeyVault(new Uri(keyVaultUrl), new DefaultAzureCredential());

public class AuditSaveChangesInterceptor : SaveChangesInterceptor
{
    private readonly ICurrentUserContext _userContext;

    public AuditSaveChangesInterceptor(ICurrentUserContext userContext)
    {
        _userContext = userContext;
    }

    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
        DbContextEventData eventData, 
        InterceptionResult<int> result, 
        CancellationToken cancellationToken = default)
    {
        var context = eventData.Context;
        if (context == null) return base.SavingChangesAsync(eventData, result, cancellationToken);

        var currentUserId = _userContext.UserId ?? "System";
        var now = DateTime.UtcNow;

        foreach (var entry in context.ChangeTracker.Entries<IAuditableEntity>())
        {
            if (entry.State == EntityState.Added)
            {
                entry.Entity.CreatedAt = now;
                entry.Entity.CreatedBy = currentUserId;
            }
            else if (entry.State == EntityState.Modified)
            {
                entry.Entity.LastModifiedAt = now;
                entry.Entity.LastModifiedBy = currentUserId;
            }
            else if (entry.State == EntityState.Deleted && entry.Entity is ISoftDeletable softDeletable)
            {
                // Convert hard DELETE into soft UPDATE
                entry.State = EntityState.Modified;
                softDeletable.IsDeleted = true;
                softDeletable.DeletedAt = now;
            }
        }

        return base.SavingChangesAsync(eventData, result, cancellationToken);
    }
}

// In Program.cs
builder.Services.AddApiVersioning(options =>
{
    options.DefaultApiVersion = new ApiVersion(1, 0);
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.ReportApiVersions = true; // Adds 'api-supported-versions' header to response
    options.ApiVersionReader = ApiVersionReader.Combine(
        new UrlSegmentApiVersionReader(),
        new HeaderApiVersionReader("X-Api-Version")
    );
}).AddApiExplorer(options =>
{
    options.GroupNameFormat = "'v'VVV";
    options.SubstituteApiVersionInUrl = true;
});

// Controller Usage
[ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")]
public class ProductsV1Controller : ControllerBase { /* ... */ }

[ApiVersion("2.0")]
[Route("api/v{version:apiVersion}/[controller]")]
public class ProductsV2Controller : ControllerBase { /* ... */ }

// Custom Security Headers Middleware
app.Use(async (context, next) =>
{
    var headers = context.Response.Headers;

    headers.Append("X-Content-Type-Options", "nosniff");
    headers.Append("X-Frame-Options", "DENY");
    headers.Append("X-XSS-Protection", "0"); // Modern standard (CSP supersedes this)
    headers.Append("Referrer-Policy", "strict-origin-when-cross-origin");
    headers.Append("Permissions-Policy", "camera=(), microphone=(), geolocation=()");

    headers.Append("Content-Security-Policy",
        "default-src 'self'; " +
        "script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; " +
        "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; " +
        "font-src 'self' https://fonts.gstatic.com; " +
        "img-src 'self' data: https:;");

    await next();
});

// Enable HSTS in Production
if (!app.Environment.IsDevelopment())
{
    app.UseHsts();
}

// The Memory Leak Trap:
public class OrderNotifier
{
    // Long-lived Singleton publisher
    public event EventHandler? OrderPlaced;
}

public class OrderInvoicePdfGenerator : IDisposable
{
    private readonly OrderNotifier _notifier;

    public OrderInvoicePdfGenerator(OrderNotifier notifier)
    {
        _notifier = notifier;
        // Strong reference from publisher to this instance!
        _notifier.OrderPlaced += OnOrderPlaced; 
    }

    private void OnOrderPlaced(object? sender, EventArgs e) { /* ... */ }

    // Crucial: Must unsubscribe upon disposal!
    public void Dispose()
    {
        _notifier.OrderPlaced -= OnOrderPlaced; // Break the GC root!
    }
}

[HttpGet("reports/quarterly")]
public async Task<IActionResult> GenerateQuarterlyReport(
    [FromServices] AppDbContext db,
    [FromServices] IExternalAnalyticsClient analyticsClient,
    CancellationToken cancellationToken) // Injected from HttpContext.RequestAborted
{
    try
    {
        // 1. Database query cancels if client disconnects:
        var orders = await db.Orders
            .Where(o => o.IsCompleted)
            .ToListAsync(cancellationToken);

        // 2. External HTTP call cancels if client disconnects:
        var analytics = await analyticsClient.FetchMetricsAsync(orders, cancellationToken);

        return Ok(new ReportDto(orders, analytics));
    }
    catch (OperationCanceledException)
    {
        // Clean cancellation - HTTP status 499 (Client Closed Request)
        return StatusCode(499);
    }
}

// Solution Structure:
// ├── RTSALL.Domain           (Pure C#, Zero Dependencies)
// ├── RTSALL.Application      (Depends on Domain, MediatR, FluentValidation)
// ├── RTSALL.Infrastructure   (Depends on Application, EF Core, Redis, SendGrid)
// └── RTSALL.Api              (Startup project, Web API, Middleware, Swagger)

// In RTSALL.Application (Defines contract):
public interface IOrderRepository
{
    Task<Order?> GetByIdAsync(OrderId id, CancellationToken ct);
    Task AddAsync(Order order, CancellationToken ct);
}

// In RTSALL.Infrastructure (Implements contract):
public class OrderRepository : IOrderRepository
{
    private readonly AppDbContext _db;
    public OrderRepository(AppDbContext db) => _db = db;

    public async Task<Order?> GetByIdAsync(OrderId id, CancellationToken ct) =>
        await _db.Orders.FirstOrDefaultAsync(o => o.Id == id, ct);

    public async Task AddAsync(Order order, CancellationToken ct) =>
        await _db.Orders.AddAsync(order, ct);
}

// 1. Generic MediatR Pipeline Behavior for FluentValidation
public class ValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<IValidator<TRequest>> _validators;

    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
    {
        _validators = validators;
    }

    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        if (_validators.Any())
        {
            var context = new ValidationContext<TRequest>(request);
            var validationResults = await Task.WhenAll(
                _validators.Select(v => v.ValidateAsync(context, cancellationToken)));

            var failures = validationResults
                .SelectMany(r => r.Errors)
                .Where(f => f != null)
                .ToList();

            if (failures.Count != 0)
            {
                throw new ValidationException(failures); // Intercepted by Global Exception Handler!
            }
        }

        return await next(); // Proceed to Command Handler
    }
}

// 2. Program.cs Registration
builder.Services.AddMediatR(cfg =>
{
    cfg.RegisterServicesFromAssembly(typeof(CreateOrderCommand).Assembly);
    cfg.AddOpenBehavior(typeof(ValidationBehavior<,>));
});

// In Program.cs using Microsoft.Extensions.Http.Resilience
builder.Services.AddHttpClient<IPaymentService, PaymentService>(client =>
{
    client.BaseAddress = new Uri("https://api.payments.com/");
})
.AddResilienceHandler("payment-pipeline", builder =>
{
    // 1. Total Request Timeout
    builder.AddTimeout(TimeSpan.FromSeconds(10));

    // 2. Retry with Exponential Backoff and Jitter
    builder.AddRetry(new HttpRetryStrategyOptions
    {
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromMilliseconds(500),
        BackoffType = DelayBackoffType.Exponential,
        UseJitter = true
    });

    // 3. Circuit Breaker
    builder.AddCircuitBreaker(new HttpCircuitBreakerStrategyOptions
    {
        SamplingDuration = TimeSpan.FromSeconds(30),
        FailureRatio = 0.5, // Break if 50% requests fail
        MinimumThroughput = 10,
        BreakDuration = TimeSpan.FromSeconds(15)
    });
});

// 1. Proto Contract (order.proto)
syntax = "proto3";
option csharp_namespace = "Rtsall.GrpcServices";

service OrderGrpc {
  rpc GetOrderStatus (OrderStatusRequest) returns (OrderStatusResponse);
}

message OrderStatusRequest {
  int32 order_id = 1;
}

message OrderStatusResponse {
  int32 order_id = 1;
  string status = 2;
  double total_amount = 3;
}

// 2. C# gRPC Service Implementation in ASP.NET Core
public class OrderGrpcService : OrderGrpc.OrderGrpcBase
{
    private readonly AppDbContext _db;
    public OrderGrpcService(AppDbContext db) => _db = db;

    public override async Task<OrderStatusResponse> GetOrderStatus(
        OrderStatusRequest request, ServerCallContext context)
    {
        var order = await _db.Orders.FindAsync(request.OrderId);
        if (order == null)
            throw new RpcException(new Status(StatusCode.NotFound, "Order not found"));

        return new OrderStatusResponse
        {
            OrderId = order.Id,
            Status = order.Status.ToString(),
            TotalAmount = (double)order.TotalAmount
        };
    }
}

// Inspecting memory segments and generations
long gen0Count = GC.CollectionCount(0);
long gen1Count = GC.CollectionCount(1);
long gen2Count = GC.CollectionCount(2);

long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
GCMemoryInfo memoryInfo = GC.GetGCMemoryInfo();

Console.WriteLine($"Heap Size: {memoryInfo.HeapSizeBytes / (1024 * 1024)} MB");
Console.WriteLine($"Gen 2 Full GCs: {gen2Count}");

// Requesting LOH compaction on the next Full GC (use sparingly)
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(2, GCCollectionMode.Forced, blocking: false);

# Monitor ThreadPool queue live in terminal
dotnet-counters monitor -p 18452 --counters System.Runtime

# Key Indicators of ThreadPool Starvation:
# [System.Runtime]
#     ThreadPool Completed Work Item Count         1,240
#     ThreadPool Queue Length                     14,890  <-- RED ALERT: Backlogged!
#     ThreadPool Thread Count                         84  <-- Climbing slowly (1-2/sec)

# Tuning MinThreads in Program.cs (Bandaid only; refactor async code first!)
ThreadPool.GetMinThreads(out int workerThreads, out int completionPortThreads);
ThreadPool.SetMinThreads(200, completionPortThreads); // Pre-allocates pool capacity

// 1. Immutable Event Message Contract
public record OrderSubmittedEvent(Guid OrderId, decimal Amount, DateTime Timestamp);

// 2. Strongly Typed Consumer
public class OrderSubmittedConsumer : IConsumer<OrderSubmittedEvent>
{
    private readonly ILogger<OrderSubmittedConsumer> _logger;
    public OrderSubmittedConsumer(ILogger<OrderSubmittedConsumer> logger) => _logger = logger;

    public async Task Consume(ConsumeContext<OrderSubmittedEvent> context)
    {
        var msg = context.Message;
        _logger.LogInformation("Processing order {OrderId} for {Amount:C}", msg.OrderId, msg.Amount);
        
        // Asynchronous message processing logic...
        await Task.Delay(100, context.CancellationToken);
    }
}

// 3. Program.cs Registration
builder.Services.AddMassTransit(x =>
{
    x.AddConsumer<OrderSubmittedConsumer>();

    x.UsingRabbitMq((context, cfg) =>
    {
        cfg.Host("rabbitmq://localhost", h =>
        {
            h.Username("guest");
            h.Password("guest");
        });

        // Configure automatic retry and consumer endpoint
        cfg.ReceiveEndpoint("order-submitted-queue", e =>
        {
            e.UseMessageRetry(r => r.Interval(3, TimeSpan.FromSeconds(5)));
            e.ConfigureConsumer<OrderSubmittedConsumer>(context);
        });
    });
});

builder.Services.AddMassTransit(x =>
{
    x.AddEntityFrameworkOutbox<AppDbContext>(o =>
    {
        o.UseSqlServer();
        o.UseBusOutbox(); // Automatically routes Publish() to Outbox table
        o.DuplicateDetectionWindow = TimeSpan.FromMinutes(30);
    });

    x.UsingRabbitMq((context, cfg) =>
    {
        cfg.Host("rabbitmq://localhost");
        cfg.ConfigureEndpoints(context);
    });
});

// Inside Order Service:
public async Task CreateOrderAsync(CreateOrderDto dto)
{
    using var transaction = await _db.Database.BeginTransactionAsync();

    var order = new Order { Id = Guid.NewGuid(), Total = dto.Total };
    _db.Orders.Add(order);

    // This publish doesn't hit RabbitMQ immediately; 
    // it writes into the Outbox table in the SAME atomic SQL transaction!
    await _publishEndpoint.Publish(new OrderCreatedEvent(order.Id, order.Total));

    await _db.SaveChangesAsync();
    await transaction.CommitAsync();
}

<!-- In .csproj -->
<PropertyGroup>
  <TargetFramework>net8.0</TargetFramework>
  <PublishAot>true</PublishAot>
  <InvariantGlobalization>true</InvariantGlobalization>
</PropertyGroup>

<!-- C# Source-Generated JSON Serializer Context -->
[JsonSerializable(typeof(TodoItem))]
[JsonSerializable(typeof(List<TodoItem>))]
internal partial class AppJsonSerializerContext : JsonSerializerContext
{
}

// In Program.cs
var builder = WebApplication.CreateSlimBuilder(args); // Ultra-lightweight slim builder
builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
});

// Parsing "FirstName LastName" without Substring() allocations
public static (ReadOnlySpan<char> First, ReadOnlySpan<char> Last) ParseFullName(ReadOnlySpan<char> fullName)
{
    int spaceIndex = fullName.IndexOf(' ');
    if (spaceIndex == -1)
    {
        return (fullName, ReadOnlySpan<char>.Empty);
    }

    // Slice creates a lightweight window into existing memory without allocating new strings!
    ReadOnlySpan<char> first = fullName.Slice(0, spaceIndex);
    ReadOnlySpan<char> last = fullName.Slice(spaceIndex + 1);

    return (first, last);
}

// Stack-allocated scratch buffer for formatting (0 heap allocation):
Span<char> buffer = stackalloc char[64];
if (Guid.NewGuid().TryFormat(buffer, out int charsWritten))
{
    // Process buffer without allocating new String object
}

public class Order : AggregateRoot<OrderId>
{
    private readonly List<OrderItem> _items = new();
    public IReadOnlyCollection<OrderItem> Items => _items.AsReadOnly();
    public OrderStatus Status { get; private set; }

    private Order() { } // Required by EF Core

    public Order(OrderId id, CustomerId customerId) : base(id)
    {
        Status = OrderStatus.Created;
    }

    // Invariant-protecting business method (Never expose public setters!)
    public void AddItem(ProductId productId, decimal unitPrice, int quantity)
    {
        if (Status != OrderStatus.Created)
            throw new DomainRuleValidationException("Cannot add items to a finalized order.");

        _items.Add(new OrderItem(productId, unitPrice, quantity));

        // Raise domain event to be dispatched on SaveChanges
        AddDomainEvent(new OrderItemAddedEvent(Id, productId, quantity));
    }
}

public class OrderState : SagaStateMachineInstance
{
    public Guid CorrelationId { get; set; }
    public string CurrentState { get; set; } = null!;
    public Guid OrderId { get; set; }
    public decimal Amount { get; set; }
}

public class OrderStateMachine : MassTransitStateMachine<OrderState>
{
    public State Submitted { get; private set; } = null!;
    public State Paid { get; private set; } = null!;

    public Event<OrderSubmittedEvent> OrderSubmitted { get; private set; } = null!;
    public Event<PaymentFailedEvent> PaymentFailed { get; private set; } = null!;

    public OrderStateMachine()
    {
        InstanceState(x => x.CurrentState);

        Initially(
            When(OrderSubmitted)
                .Then(context => context.Saga.OrderId = context.Message.OrderId)
                .TransitionTo(Submitted)
                .Publish(context => new ProcessPaymentCommand(context.Saga.OrderId, context.Saga.Amount))
        );

        During(Submitted,
            When(PaymentFailed)
                // Execute compensating transaction!
                .Publish(context => new CancelOrderInventoryCommand(context.Saga.OrderId))
                .Finalize()
        );
    }
}

{
  "configProperties": {
    "System.GC.Server": true,
    "System.GC.HeapCount": 2,               // Limit heaps to 2 instead of total host CPU cores
    "System.GC.HighMemoryPercent": 80,      // Trigger GC when memory reaches 80% container limit
    "System.GC.RetainVM": false             // Return freed virtual memory pages back to OS
  }
}

// 1. Register Certificate Authentication
builder.Services.AddAuthentication(CertificateAuthenticationDefaults.AuthenticationScheme)
    .AddCertificate(options =>
    {
        options.AllowedCertificateTypes = CertificateTypes.All;
        options.Events = new CertificateAuthenticationEvents
        {
            OnCertificateValidated = context =>
            {
                var cert = context.ClientCertificate;
                // Validate against trusted thumbprint whitelist
                var allowedThumbprints = builder.Configuration
                    .GetSection("Security:AllowedThumbprints").Get<string[]>() ?? Array.Empty<string>();

                if (allowedThumbprints.Contains(cert.Thumbprint, StringComparer.OrdinalIgnoreCase))
                {
                    var claims = new[]
                    {
                        new Claim(ClaimTypes.NameIdentifier, cert.Subject),
                        new Claim(ClaimTypes.Role, "ServiceAccount")
                    };
                    context.Principal = new ClaimsPrincipal(new ClaimsIdentity(claims, context.Scheme.Name));
                    context.Success();
                }
                else
                {
                    context.Fail("Certificate thumbprint is untrusted.");
                }
                return Task.CompletedTask;
            }
        };
    });

// 2. Kestrel mTLS Port Configuration
builder.WebHost.ConfigureKestrel(options =>
{
    options.ConfigureHttpsDefaults(https =>
    {
        https.ClientCertificateMode = ClientCertificateMode.RequireCertificate;
    });
});

public class ProductRepository : IProductRepository
{
    private readonly AppDbContext _db;

    // Static compiled query delegate: compiled ONCE for the lifetime of the process!
    private static readonly Func<AppDbContext, int, CancellationToken, Task<ProductSummaryDto?>> 
        GetProductByIdCompiled = EF.CompileAsyncQuery(
            (AppDbContext context, int id, CancellationToken ct) =>
                context.Products
                    .AsNoTracking()
                    .Where(p => p.Id == id)
                    .Select(p => new ProductSummaryDto(p.Id, p.Name, p.Price))
                    .FirstOrDefault());

    public ProductRepository(AppDbContext db) => _db = db;

    public Task<ProductSummaryDto?> GetByIdAsync(int id, CancellationToken ct)
    {
        // Executes pre-compiled delegate directly against DbContext!
        return GetProductByIdCompiled(_db, id, ct);
    }
}

// 1. Channel Registration as Singleton
var channel = Channel.CreateBounded<LogMessageItem>(new BoundedChannelOptions(capacity: 50_000)
{
    FullMode = BoundedChannelFullMode.Wait, // Applies backpressure to producers
    SingleWriter = false,
    SingleReader = true // Optimization flag for single consumer
});
builder.Services.AddSingleton(channel);

// 2. Producer (Web Controller / Middleware):
public class TelemetryProducer
{
    private readonly ChannelWriter<LogMessageItem> _writer;
    public TelemetryProducer(Channel<LogMessageItem> channel) => _writer = channel.Writer;

    public async ValueTask EnqueueAsync(LogMessageItem item)
    {
        await _writer.WriteAsync(item); // Non-blocking async write!
    }
}

// 3. Consumer (BackgroundService):
public class LogConsumerService : BackgroundService
{
    private readonly ChannelReader<LogMessageItem> _reader;
    public LogConsumerService(Channel<LogMessageItem> channel) => _reader = channel.Reader;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // Consumes items asynchronously as they arrive:
        await foreach (var log in _reader.ReadAllAsync(stoppingToken))
        {
            await BatchFlushLogToStorageAsync(log);
        }
    }
}

public interface IExecutionPlanContext
{
    bool IsReadOnly { get; set; }
}

public class ReplicaRoutingDbConnectionInterceptor : DbConnectionInterceptor
{
    private readonly IExecutionPlanContext _context;
    private readonly string _readOnlyConnectionString;

    public ReplicaRoutingDbConnectionInterceptor(
        IExecutionPlanContext context, 
        IConfiguration config)
    {
        _context = context;
        _readOnlyConnectionString = config.GetConnectionString("ReadOnlyReplica")!;
    }

    public override InterceptionResult ConnectionOpening(
        DbConnection connection, 
        ConnectionEventData eventData, 
        InterceptionResult result)
    {
        if (_context.IsReadOnly)
        {
            // Dynamically redirect connection to read replica!
            connection.ConnectionString = _readOnlyConnectionString;
        }
        return base.ConnectionOpening(connection, eventData, result);
    }
}

# 1. Install diagnostic tools inside running pod:
dotnet tool install --global dotnet-trace
dotnet tool install --global dotnet-dump
dotnet tool install --global dotnet-counters

# 2. View live metrics (Process ID 1 in containers):
dotnet-counters monitor -p 1 --counters System.Runtime,Microsoft.AspNetCore.Hosting

# 3. Capture 30-second CPU trace for high CPU spikes:
dotnet-trace collect -p 1 --duration 00:00:30 --format Speedscope -o cpu_spike.speedscope

# 4. Capture memory dump for memory leaks:
dotnet-dump collect -p 1 -o memory_leak.dmp

# 5. Analyze the dump interactively:
dotnet-dump analyze memory_leak.dmp
# Inside analyzer:
> dumpheap -stat
> gcroot <object-address>

// 1. Source-Generated Regular Expression (Introduced in .NET 7)
public static partial class StringValidators
{
    // Compiler generates optimized native C# matcher code at build time!
    // No regex interpretation, zero runtime compilation!
    [GeneratedRegex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$", RegexOptions.IgnoreCase)]
    public static partial Regex EmailRegex();
}

// Usage:
bool isValid = StringValidators.EmailRegex().IsMatch("dev@rtsall.com");

// 2. Source-Generated Logging (High-performance zero-allocation logger)
public static partial class LogExtensions
{
    [LoggerMessage(EventId = 101, Level = LogLevel.Information, 
        Message = "Order {OrderId} processed in {ElapsedMs} ms")]
    public static partial void LogOrderProcessed(this ILogger logger, Guid orderId, long elapsedMs);
}

// 1. EF Core Command Handler (Write Operation with Business Invariants)
public class UpdateOrderCommandHandler : IRequestHandler<UpdateOrderCommand>
{
    private readonly AppDbContext _db;
    public UpdateOrderCommandHandler(AppDbContext db) => _db = db;

    public async Task Handle(UpdateOrderCommand cmd, CancellationToken ct)
    {
        var order = await _db.Orders.Include(o => o.Items).SingleAsync(o => o.Id == cmd.OrderId, ct);
        order.UpdateShippingAddress(cmd.Address); // Invariant checks executed
        await _db.SaveChangesAsync(ct);
    }
}

// 2. Dapper Query Handler (Ultra-Fast Read Operation with Complex Join)
public class GetOrderDashboardQueryHandler : IRequestHandler<GetOrderDashboardQuery, DashboardDto>
{
    private readonly IDbConnectionFactory _connectionFactory;
    public GetOrderDashboardQueryHandler(IDbConnectionFactory factory) => _connectionFactory = factory;

    public async Task<DashboardDto> Handle(GetOrderDashboardQuery qry, CancellationToken ct)
    {
        using var connection = _connectionFactory.CreateConnection();
        const string sql = @"
            SELECT o.Id, o.TotalAmount, c.CompanyName, 
                   COUNT(i.Id) AS ItemCount
            FROM Orders o
            INNER JOIN Customers c ON o.CustomerId = c.Id
            LEFT JOIN OrderItems i ON o.Id = i.OrderId
            WHERE o.TenantId = @TenantId
            GROUP BY o.Id, o.TotalAmount, c.CompanyName";

        var data = await connection.QueryAsync<DashboardRowDto>(sql, new { qry.TenantId });
        return new DashboardDto(data.ToList());
    }
}

// In Program.cs
builder.Services.AddOpenTelemetry()
    .ConfigureResource(resource => resource.AddService(
        serviceName: "OrderProcessingService",
        serviceVersion: "2.4.0"))
    .WithTracing(tracing =>
    {
        tracing
            .AddAspNetCoreInstrumentation(opts =>
            {
                opts.RecordException = true;
                opts.Filter = httpContext => !httpContext.Request.Path.StartsWithSegments("/health");
            })
            .AddHttpClientInstrumentation()
            .AddEntityFrameworkCoreInstrumentation()
            .AddRedisInstrumentation()
            .AddOtlpExporter(opt => opt.Endpoint = new Uri("http://otel-collector:4317"));
    })
    .WithMetrics(metrics =>
    {
        metrics
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddRuntimeInstrumentation()
            .AddPrometheusExporter();
    });

// Manual Span Instrumentation in Domain Handler:
private static readonly ActivitySource OrderActivitySource = new("Rtsall.Orders");

public async Task ProcessOrderAsync(Order order)
{
    using var activity = OrderActivitySource.StartActivity("AuthorizePaymentSpan");
    activity?.SetTag("order.id", order.Id);
    activity?.SetTag("order.amount", order.TotalAmount);

    // Business operation...
}

// In appsettings.json
{
  "ReverseProxy": {
    "Routes": {
      "catalog-route": {
        "ClusterId": "catalog-cluster",
        "Match": {
          "Path": "/catalog/{**catch-all}"
        },
        "Transforms": [
          { "PathPattern": "{**catch-all}" }, // Strip /catalog prefix
          { "RequestHeader": "X-Gateway-Identity", "Set": "RtsallCoreGateway" }
        ]
      }
    },
    "Clusters": {
      "catalog-cluster": {
        "LoadBalancingPolicy": "RoundRobin", // RoundRobin, LeastRequests, PowerOfTwoChoices
        "Destinations": {
          "node-1": { "Address": "https://catalog-service-1:5001" },
          "node-2": { "Address": "https://catalog-service-2:5001" }
        }
      }
    }
  }
}

// In Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));

var app = builder.Build();
app.MapReverseProxy();
app.Run();

// 1. Tenant Context Service (Scoped)
public interface ITenantContext
{
    string? TenantId { get; set; }
}
public class TenantContext : ITenantContext
{
    public string? TenantId { get; set; }
}

// 2. Tenant Resolution Middleware (Subdomain, Header, or JWT Claim)
app.Use(async (context, next) =>
{
    var tenantContext = context.RequestServices.GetRequiredService<ITenantContext>();
    
    // Resolve via subdomain (e.g. acme.rtsall.com) or header:
    if (context.Request.Headers.TryGetValue("X-Tenant-ID", out var tenantId))
    {
        tenantContext.TenantId = tenantId.ToString();
    }
    
    await next();
});

// 3. EF Core DbContext with Global Query Filter
public class AppDbContext : DbContext
{
    private readonly ITenantContext _tenantContext;
    public AppDbContext(DbContextOptions<AppDbContext> opts, ITenantContext tenantContext) 
        : base(opts) => _tenantContext = tenantContext;

    public DbSet<Order> Orders => Set<Order>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Automatically inject WHERE TenantId = @currentTenant into EVERY query!
        modelBuilder.Entity<Order>()
            .HasQueryFilter(o => o.TenantId == _tenantContext.TenantId);
    }
}

-- STEP 1: EXPAND (Zero-downtime, fully non-breaking)
ALTER TABLE Users ADD FirstName NVARCHAR(100) NULL;
ALTER TABLE Users ADD LastName NVARCHAR(100) NULL;

-- STEP 2: BACKFILL (Batched to prevent table lock escalation)
WHILE 1 = 1
BEGIN
    UPDATE TOP (5000) Users
    SET FirstName = PARSENAME(REPLACE(FullName, ' ', '.'), 2),
        LastName  = PARSENAME(REPLACE(FullName, ' ', '.'), 1)
    WHERE FirstName IS NULL AND FullName IS NOT NULL;

    IF @@ROWCOUNT = 0 BREAK;
    WAITFOR DELAY '00:00:01'; -- Prevent transaction log choking
END;

-- STEP 3: CONTRACT (Executed days later after verification)
ALTER TABLE Users DROP COLUMN FullName;

// OpenIddict Enterprise Configuration
builder.Services.AddOpenIddict()
    .AddCore(options =>
    {
        options.UseEntityFrameworkCore()
               .UseDbContext<AppDbContext>();
    })
    .AddServer(options =>
    {
        // Endpoints
        options.SetAuthorizationEndpointUris("/connect/authorize")
               .SetTokenEndpointUris("/connect/token")
               .SetUserinfoEndpointUris("/connect/userinfo");

        // Flows
        options.AllowAuthorizationCodeFlow()
               .RequireProofKeyForCodeExchange() // Mandatory PKCE!
               .AllowClientCredentialsFlow()
               .AllowRefreshTokenFlow();

        // Register encryption and signing keys
        options.AddDevelopmentEncryptionCertificate()
               .AddDevelopmentSigningCertificate();

        options.UseAspNetCore()
               .EnableAuthorizationEndpointPassthrough()
               .EnableTokenEndpointPassthrough();
    })
    .AddValidation(options =>
    {
        options.UseLocalServer();
        options.UseAspNetCore();
    });

public async Task ProcessNetworkPayloadAsync(Stream networkStream, int payloadLength)
{
    // Rent a buffer from the shared pool
    byte[] rentedBuffer = ArrayPool<byte>.Shared.Rent(payloadLength);

    try
    {
        int bytesRead = await networkStream.ReadAsync(rentedBuffer.AsMemory(0, payloadLength));
        
        // Pass rented slice to processing engine
        ProcessMemorySlice(rentedBuffer.AsSpan(0, bytesRead));
    }
    finally
    {
        // CRUCIAL: Always return the buffer inside a finally block!
        // clearArray: true wipes sensitive data (passwords/keys) from RAM
        ArrayPool<byte>.Shared.Return(rentedBuffer, clearArray: true);
    }
}

// Azure Front Door Global Routing Policy (Bicep snippet)
resource frontDoorEndpoint 'Microsoft.Cdn/profiles/afdEndpoints@2023-05-01' = {
  name: 'rtsall-global-gateway'
  properties: {
    enabledState: 'Enabled'
  }
}

// Health Probe Settings for Automatic Regional Failover
resource healthProbe 'Microsoft.Cdn/profiles/originGroups/healthProbeSettings@2023-05-01' = {
  properties: {
    probePath: '/health/ready'
    probeRequestType: 'HEAD'
    probeProtocol: 'Https'
    probeIntervalInSeconds: 10
  }
}

using System.Numerics.Tensors;

public class EmbeddingSearchEngine
{
    // Calculates Cosine Similarity between two 1536-dimension vectors:
    // CosineSimilarity(A, B) = DotProduct(A, B) / (Norm(A) * Norm(B))
    public static float ComputeCosineSimilarity(
        ReadOnlySpan<float> vectorA, 
        ReadOnlySpan<float> vectorB)
    {
        // Hardware-accelerated SIMD under the hood:
        // Automatically maps to AVX-512 or ARM64 Neon registers!
        return TensorPrimitives.CosineSimilarity(vectorA, vectorB);
    }

    public static int FindBestMatch(ReadOnlySpan<float> queryEmbedding, List<float[]> documentEmbeddings)
    {
        float highestSimilarity = float.MinValue;
        int bestIndex = -1;

        for (int i = 0; i < documentEmbeddings.Count; i++)
        {
            float sim = TensorPrimitives.CosineSimilarity(queryEmbedding, documentEmbeddings[i]);
            if (sim > highestSimilarity)
            {
                highestSimilarity = sim;
                bestIndex = i;
            }
        }

        return bestIndex;
    }
}

public class BankAccountAggregate
{
    public Guid Id { get; private set; }
    public decimal Balance { get; private set; }
    public int Version { get; private set; }

    private readonly List<object> _uncommittedEvents = new();
    public IReadOnlyCollection<object> UncommittedEvents => _uncommittedEvents;

    // Left Fold: Mutates internal state based on past events
    public void Apply(object @event)
    {
        switch (@event)
        {
            case AccountCreatedEvent e:
                Id = e.AccountId;
                Balance = e.InitialDeposit;
                break;
            case MoneyWithdrawnEvent e:
                Balance -= e.Amount;
                break;
        }
        Version++;
    }

    // Business Command Method
    public void Withdraw(decimal amount)
    {
        if (Balance < amount) throw new InvalidOperationException("Insufficient funds.");
        var evt = new MoneyWithdrawnEvent(Id, amount, DateTime.UtcNow);
        Apply(evt);
        _uncommittedEvents.Add(evt);
    }
}

// Zero-Trust Passwordless Connection: No passwords or secrets anywhere!
builder.Services.AddDbContext<AppDbContext>(options =>
{
    var connectionString = "Server=tcp:rtsall-db.database.windows.net,1433;Database=EnterpriseCore;";
    var sqlConnection = new SqlConnection(connectionString)
    {
        // Authenticates using Azure Managed Workload Identity (OAuth token exchange)
        AccessToken = new DefaultAzureCredential()
            .GetToken(new TokenRequestContext(new[] { "https://database.windows.net/.default" }))
            .Token
    };

    options.UseSqlServer(sqlConnection);
});

[Fact]
public void OrdersModule_ShouldNotReference_BillingModuleInternals()
{
    // NetArchTest automated architectural rule validation
    var result = Types.InAssembly(typeof(OrdersModule).Assembly)
        .That()
        .ResideInNamespace("Rtsall.Modules.Orders")
        .ShouldNot()
        .HaveDependencyOn("Rtsall.Modules.Billing.Internal")
        .GetResult();

    Assert.True(result.IsSuccessful, "Architecture violation: Orders depends on Billing internals!");
}

// In Program.cs (.NET 9)
builder.Services.AddHybridCache(options =>
{
    options.MaximumPayloadBytes = 1024 * 1024; // 1 MB
    options.DefaultEntryOptions = new HybridCacheEntryOptions
    {
        Expiration = TimeSpan.FromMinutes(5),
        LocalCacheExpiration = TimeSpan.FromMinutes(1)
    };
});

// Consumption in API Endpoint:
app.MapGet("/api/catalog", async (HybridCache cache, AppDbContext db, CancellationToken ct) =>
{
    // HybridCache automatically locks concurrent requests!
    // Even under 50,000 concurrent RPS, the database query executes EXACTLY ONCE!
    return await cache.GetOrCreateAsync("catalog-key", async cancelToken =>
    {
        return await db.Products
            .AsNoTracking()
            .Where(p => p.IsActive)
            .ToListAsync(cancelToken);
    }, cancellationToken: ct);
});

public static class ThreadPoolTuning
{
    public static void OptimizeForHighThroughput(int targetMinWorkerThreads = 250)
    {
        ThreadPool.GetMinThreads(out int currentMinWorkers, out int currentMinIOCP);
        ThreadPool.GetMaxThreads(out int maxWorkers, out int maxIOCP);

        // Pre-allocate thread capacity to handle sudden traffic surges without delay
        if (currentMinWorkers < targetMinWorkerThreads)
        {
            ThreadPool.SetMinThreads(targetMinWorkerThreads, currentMinIOCP);
        }

        Console.WriteLine($"ThreadPool Min Workers adjusted from {currentMinWorkers} to {targetMinWorkerThreads}");
    }
}

syntax = "proto3";
package rtsall.events;

message UserRegisteredEvent {
  // Immutable Field Numbers:
  string user_id = 1;
  string email = 2;

  // Obsolete fields reserved to prevent collision:
  reserved 3, 4;
  reserved "phone_number", "legacy_hash";

  // New additions must always use fresh tag numbers:
  string display_name = 5;
  int64 registered_at_unix_ms = 6;
}

// Configure Chaos Injection via Microsoft.Extensions.Resilience
builder.Services.AddHttpClient("ExternalService")
    .AddResilienceHandler("chaos-pipeline", builder =>
    {
        // Production resilience first
        builder.AddTimeout(TimeSpan.FromSeconds(2));
        builder.AddRetry(new HttpRetryStrategyOptions { MaxRetryAttempts = 3 });

        // Simmy Fault Injection (enabled only in Staging/Dev environments)
        if (builder.Environment.IsDevelopment() || builder.Environment.IsStaging())
        {
            builder.AddChaosLatency(new ChaosLatencyStrategyOptions
            {
                InjectionRate = 0.2, // Inject on 20% of requests
                Latency = TimeSpan.FromSeconds(3) // Delay longer than timeout to test circuit breaker
            });

            builder.AddChaosFault(new ChaosFaultStrategyOptions
            {
                InjectionRate = 0.05, // 5% HTTP 500 errors
                FaultGenerator = _ => new ValueTask<Exception?>(new HttpRequestException("Simulated Chaos Outage!"))
            });
        }
    });

// Configuring CosmosClient for Application Region Proximity
CosmosClient client = new CosmosClientBuilder(connectionString)
    .WithApplicationRegion(Regions.NorthEurope) // Prefers local datacenter
    .WithConnectionModeDirect()                // Direct TCP mode for lowest latency
    .WithCustomSerializer(new CosmosSystemTextJsonSerializer())
    .Build();

// Conflict Resolution Policy (Last-Write-Wins based on epoch timestamp)
ContainerProperties containerProperties = new("Orders", "/partitionKey")
{
    ConflictResolutionPolicy = ConflictResolutionPolicy.CreateLastWriteWinsPolicy("/_ts")
};

// Preventing CPU Cache Line Contention (64-byte alignment)
[StructLayout(LayoutKind.Explicit, Size = 128)]
public struct PaddedAtomicSequence
{
    // Offset by 64 bytes to guarantee dedicated CPU cache line
    [FieldOffset(64)]
    private long _value;

    public long Value => Volatile.Read(ref _value);

    public void Set(long value) => Volatile.Write(ref _value, value);

    public bool CompareAndSet(long expected, long update) =>
        Interlocked.CompareExchange(ref _value, update, expected) == expected;
}

// In Program.cs
builder.Configuration.AddAzureKeyVault(
    new Uri("https://rtsall-vault.vault.azure.net/"),
    new DefaultAzureCredential(),
    new AzureKeyVaultConfigurationOptions
    {
        // Automatically polls and refreshes secrets every 15 minutes!
        ReloadInterval = TimeSpan.FromMinutes(15)
    });

// Dynamic Redis Connection Multiplexer reacting to rotated passwords:
public class DynamicRedisManager
{
    private IConnectionMultiplexer _multiplexer;
    private readonly IOptionsMonitor<RedisOptions> _optionsMonitor;

    public DynamicRedisManager(IOptionsMonitor<RedisOptions> optionsMonitor)
    {
        _optionsMonitor = optionsMonitor;
        _multiplexer = ConnectionMultiplexer.Connect(_optionsMonitor.CurrentValue.ConnectionString);

        // React immediately when password rotates in Azure Key Vault!
        _optionsMonitor.OnChange(newOptions =>
        {
            var oldMultiplexer = _multiplexer;
            _multiplexer = ConnectionMultiplexer.Connect(newOptions.ConnectionString);
            oldMultiplexer.Dispose();
        });
    }
}

builder.WebHost.ConfigureKestrel(options =>
{
    // Maximize socket throughput
    options.Limits.MaxConcurrentConnections = 100_000;
    options.Limits.MaxConcurrentUpgradedConnections = 50_000;
    options.Limits.MinRequestBodyDataRate = null; // Disable timeout for WebSockets
    
    // HTTP/3 and HTTP/2 Protocol Multiplexing
    options.ConfigureEndpointDefaults(listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
    });

    // Thread socket binding tuning
    options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(15);
});

// In AppHost Program.cs (.NET 8/9 Aspire Orchestrator)
var builder = DistributedApplication.CreateBuilder(args);

// Spin up containerized Redis cache
var cache = builder.AddRedis("redis");

// Spin up containerized PostgreSQL with dedicated database
var postgres = builder.AddPostgres("postgres")
                      .AddDatabase("sqldata");

// Backend API Service with dependencies injected
var apiService = builder.AddProject<Projects.Rtsall_ApiService>("apiservice")
                        .WithReference(cache)
                        .WithReference(postgres);

// Frontend Web Application
builder.AddProject<Projects.Rtsall_WebFrontend>("webfrontend")
       .WithReference(apiService);

builder.Build().Run();