The Ultimate Complete .NET Cheatsheet

// ── Primary Constructors for Classes (C# 12+) ──
public class ProductService(string connectionString, ILogger logger)
{
    // Parameters become fields automatically
    public List<Product> GetAll() => _db.Query(connectionString);
}

// ── params Collections (C# 13) ──
public void PrintItems(params ReadOnlySpan<string> items)
    => Console.WriteLine(string.Join(", ", items));

PrintItems("a", "b", "c"); // Works with any Add()-capable type

// ── field keyword (C# 13) ──
public class Person
{
    private string _name = "Unknown";
    public string Name
    {
        get => field;
        set => field = value.Trim();
    }
}

// ── System.Threading.Lock (C# 13) ──
public class SafeCache
{
    private Lock _lock = new();
    public void Add(string key, string value)
    {
        using (_lock.EnterScope())
        {
            // Thread-safe access
        }
    }
}

// ── Collection Expressions (C# 12) ──
int[] nums = [1, 2, 3, 4, 5];
List<string> names = ["Alice", "Bob", "Charlie"];
Span<int> span = [1, 2, 3];

// ── Minimal API (ASP.NET Core 9) ──
var builder = WebApplication.CreateBuilder(args);

// Services
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
builder.Services.AddScoped<IProductService, ProductService>();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddOpenApi();

// Rate Limiting
builder.Services.AddRateLimiter(opt => opt
    .AddFixedWindowLimiter("fixed", w =>
    {
        w.Window = TimeSpan.FromMinutes(1);
        w.PermitLimit = 100;
    }));

var app = builder.Build();
app.UseRateLimiter();
app.MapOpenApi();
app.MapGet("/api/products", async (AppDbContext db) =>
    await db.Products.ToListAsync())
    .WithName("GetProducts")
    .WithOpenApi();

app.MapGet("/api/products/{id:int}", async (int id, AppDbContext db) =>
    await db.Products.FindAsync(id) is Product p
        ? Results.Ok(p) : Results.NotFound());

app.MapPost("/api/products", async (Product p, AppDbContext db) =>
{
    db.Products.Add(p);
    await db.SaveChangesAsync();
    return Results.Created($"/api/products/{p.Id}", p);
}).RequireRateLimiting("fixed");

app.Run();

// ── Model Validation ──
public class CreateProductDto
{
    [Required] [MaxLength(100)]
    public string Name { get; set; } = string.Empty;

    [Range(0.01, 10000)]
    public decimal Price { get; set; }

    [EmailAddress]
    public string? ContactEmail { get; set; }
}

// JSON Options (Program.cs)
builder.Services.ConfigureHttpJsonOptions(opt =>
{
    opt.SerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
    opt.SerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
});

// ── Controller ──
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    [HttpGet]
    public async Task<ActionResult<IEnumerable<Product>>> GetAll(
        [FromQuery] int page = 1, [FromQuery] int pageSize = 20)
    {
        var products = await _service.GetPagedAsync(page, pageSize);
        return Ok(products);
    }

    [HttpGet("{id:int}")]
    public async Task<ActionResult<Product>> Get(int id)
    {
        var product = await _service.GetByIdAsync(id);
        return product is null ? NotFound() : Ok(product);
    }

    [HttpPost]
    [ProducesResponseType(typeof(Product), StatusCodes.Status201Created)]
    public async Task<ActionResult<Product>> Create(
        [FromBody] CreateProductDto dto)
    {
        var product = await _service.CreateAsync(dto);
        return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
    }
}

// ── Custom Action Filter ──
public class LoggingFilter : IAsyncActionFilter
{
    private readonly ILogger _logger;
    public LoggingFilter(ILogger<LoggingFilter> logger) => _logger = logger;

    public async Task OnActionExecutionAsync(
        ActionExecutingContext context, ActionExecutionDelegate next)
    {
        _logger.LogInformation("Executing {Action}", context.ActionDescriptor.DisplayName);
        var result = await next();
        _logger.LogInformation("Executed {Action} → {Status}",
            context.ActionDescriptor.DisplayName,
            result.HttpContext.Response.StatusCode);
    }
}

@* ── Blazor Component (.razor) ── *@
@page "/products"
@rendermode InteractiveServer
@inject IProductService ProductService
@inject ILogger<ProductList> Logger

<h3>Product Catalog</h3>

<input @bind="searchTerm" @bind:event="oninput"
       placeholder="Search products..." class="form-control" />

<Virtualize Items="@filteredProducts" Context="product" OverscanCount="10">
    <div class="card p-3 mb-2">
        <h5>@product.Name</h5>
        <p>@product.Description</p>
        <span class="badge bg-primary">$@product.Price</span>
        <button @onclick="() => Delete(product.Id)" class="btn btn-danger btn-sm">
            Delete
        </button>
    </div>
</Virtualize>

@code {
    private string searchTerm = "";
    private List<Product> products = new();
    private List<Product> filteredProducts => products
        .Where(p => p.Name.Contains(searchTerm, StringComparison.OrdinalIgnoreCase))
        .ToList();

    protected override async Task OnInitializedAsync()
    {
        products = await ProductService.GetAllAsync();
        Logger.LogInformation("Loaded {Count} products", products.Count);
    }

    private async Task Delete(int id)
    {
        await ProductService.DeleteAsync(id);
        products.RemoveAll(p => p.Id == id);
    }
}

// ── DbContext ──
public class AppDbContext : DbContext
{
    public DbSet<Product> Products => Set<Product>();
    public DbSet<Order> Orders => Set<Order>();

    public AppDbContext(DbContextOptions<AppDbContext> opts) : base(opts) { }

    protected override void OnModelCreating(ModelBuilder mb)
    {
        mb.Entity<Product>(e =>
        {
            e.HasKey(p => p.Id);
            e.Property(p => p.Name).HasMaxLength(200).IsRequired();
            e.HasIndex(p => p.Sku).IsUnique();
            e.HasOne(p => p.Category).WithMany(c => c.Products)
             .HasForeignKey(p => p.CategoryId);
            e.ComplexProperty(p => p.Dimensions, d =>
            {
                d.Property(x => x.Width).HasColumnName("Width");
                d.Property(x => x.Height).HasColumnName("Height");
            });
        });

        mb.Entity<Product>().OwnsMany(p => p.Tags, t =>
        {
            t.ToJson("TagsJson"); // EF Core 9: JSON column
        });
    }
}

// ── Efficient Queries ──
var products = await db.Products
    .AsNoTracking()                    // Read-only (no tracking overhead)
    .Include(p => p.Category)          // Eager loading
    .Include(p => p.OrderItems)
        .ThenInclude(oi => oi.Order)   // Multi-level eager load
    .Where(p => p.IsActive)
    .OrderByDescending(p => p.CreatedAt)
    .Skip((page - 1) * pageSize)
    .Take(pageSize)
    .Select(p => new ProductDto         // Projection (no entity materialization)
    {
        Id = p.Id,
        Name = p.Name,
        CategoryName = p.Category.Name,
        Price = p.Price
    })
    .ToListAsync();

// ── Bulk Update / Delete (EF Core 7+) ──
await db.Products
    .Where(p => !p.IsActive && p.CreatedAt < cutoff)
    .ExecuteDeleteAsync();

await db.Products
    .Where(p => p.CategoryId == oldCatId)
    .ExecuteUpdateAsync(s => s
        .SetProperty(p => p.CategoryId, newCatId)
        .SetProperty(p => p.UpdatedAt, DateTime.UtcNow));

// ── Program.cs — JWT Authentication ──
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(opt =>
    {
        opt.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"]!))
        };
    });

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("RequireAdmin", p => p.RequireRole("Admin"))
    .AddPolicy("MinimumAge", p => p.Requirements.Add(new MinimumAgeRequirement(18)));

builder.Services.AddSingleton<IAuthorizationHandler, MinimumAgeHandler>();

// ── Custom Policy Handler ──
public class MinimumAgeRequirement : IAuthorizationRequirement
{
    public int MinimumAge { get; }
    public MinimumAgeRequirement(int minimumAge) => MinimumAge = minimumAge;
}

public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context, MinimumAgeRequirement requirement)
    {
        var dob = context.User.FindFirst(c => c.Type == "DateOfBirth")?.Value;
        if (dob is not null)
        {
            var age = DateTime.Today.Year - DateTime.Parse(dob).Year;
            if (age >= requirement.MinimumAge)
                context.Succeed(requirement);
        }
        return Task.CompletedTask;
    }
}

// ── Custom Middleware (Class-based) ──
public class RequestTimingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestTimingMiddleware> _logger;

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

    public async Task InvokeAsync(HttpContext context)
    {
        var sw = Stopwatch.StartNew();
        try
        {
            await _next(context);
        }
        finally
        {
            sw.Stop();
            _logger.LogInformation(
                "{Method} {Path} → {Status} in {ElapsedMs}ms",
                context.Request.Method,
                context.Request.Path,
                context.Response.StatusCode,
                sw.ElapsedMilliseconds);
        }
    }
}

// ── Extension Method ──
public static class RequestTimingExtensions
{
    public static IApplicationBuilder UseRequestTiming(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestTimingMiddleware>();
    }
}

// Program.cs
app.UseRequestTiming();

// ── SignalR Hub ──
public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }

    public async Task JoinRoom(string room)
    {
        await Groups.AddToGroupAsync(Context.ConnectionId, room);
        await Clients.Group(room).SendAsync("UserJoined", user);
    }

    public async Task LeaveRoom(string room)
    {
        await Groups.RemoveFromGroupAsync(Context.ConnectionId, room);
    }

    // Server-to-client streaming
    public async IAsyncEnumerable<string> StreamData(
        [EnumeratorCancellation] CancellationToken ct)
    {
        for (int i = 0; i < 100 && !ct.IsCancellationRequested; i++)
        {
            yield return $"Data point {i}";
            await Task.Delay(100, ct);
        }
    }

    public override async Task OnConnectedAsync()
    {
        // Called when client connects
        await base.OnConnectedAsync();
    }
}

// Program.cs
builder.Services.AddSignalR();
app.MapHub<ChatHub>("/chathub");

// ── JavaScript Client ──
// const connection = new signalR.HubConnectionBuilder()
//     .withUrl("/chathub")
//     .withAutomaticReconnect()
//     .build();
// connection.on("ReceiveMessage", (user, msg) => { ... });
// await connection.start();

<!-- ── MAUI XAML Page ── -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:vm="clr-namespace:MyApp.ViewModels"
             x:Class="MyApp.Views.MainPage"
             x:DataType="vm:MainViewModel">

    <ScrollView>
        <VerticalStackLayout Spacing="20" Padding="20">
            <Label Text="Product List" FontSize="28" FontAttributes="Bold"/>

            <CollectionView ItemsSource="{Binding Products}"
                            SelectionMode="Single"
                            SelectedItem="{Binding SelectedProduct}">
                <CollectionView.ItemTemplate>
                    <DataTemplate>
                        <Frame Margin="0,0,0,10" Padding="15">
                            <VerticalStackLayout>
                                <Label Text="{Binding Name}"
                                       FontSize="18" FontAttributes="Bold"/>
                                <Label Text="{Binding Price, StringFormat='${0:F2}'}"
                                       TextColor="Green"/>
                            </VerticalStackLayout>
                        </Frame>
                    </DataTemplate>
                </CollectionView.ItemTemplate>
            </CollectionView>

            <Button Text="Add Product" Command="{Binding AddCommand}"/>
        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

// ── xUnit Unit Test ──
public class ProductServiceTests
{
    private readonly Mock<IProductRepository> _repo = new();
    private readonly ProductService _service;

    public ProductServiceTests()
    {
        _service = new ProductService(_repo.Object);
    }

    [Fact]
    public async Task GetById_Exists_ReturnsProduct()
    {
        // Arrange
        var expected = new Product { Id = 1, Name = "Test", Price = 10m };
        _repo.Setup(r => r.GetByIdAsync(1))
             .ReturnsAsync(expected);

        // Act
        var result = await _service.GetByIdAsync(1);

        // Assert
        result.Should().NotBeNull();
        result.Name.Should().Be("Test");
    }

    [Theory]
    [InlineData(0)]
    [InlineData(-1)]
    [InlineData(-100)]
    public void Create_InvalidPrice_ThrowsException(decimal price)
    {
        var act = () => _service.Create(new CreateProductDto
        {
            Name = "Test", Price = price
        });
        act.Should().Throw<ValidationException>();
    }
}

// ── Integration Test with WebApplicationFactory ──
public class ApiTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public ApiTests(WebApplicationFactory<Program> factory)
    {
        _client = factory
            .WithWebHostBuilder(builder =>
            {
                builder.ConfigureTestServices(services =>
                {
                    services.ReplaceDbContext<TestDbContext>();
                });
            })
            .CreateClient();
    }

    [Fact]
    public async Task GetProducts_ReturnsOk()
    {
        var response = await _client.GetAsync("/api/products");
        response.StatusCode.Should().Be(HttpStatusCode.OK);
    }
}

// ── gRPC Proto Definition ──
syntax = "proto3";

option csharp_namespace = "MyApp.Grpc";

package greet;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
  rpc StreamHellos (HelloRequest) returns (stream HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

// ── gRPC Service Implementation ──
public class GreeterService : Greeter.GreeterBase
{
    public override Task<HelloReply> SayHello(
        HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = $"Hello, {request.Name}!"
        });
    }

    public override async Task StreamHellos(
        HelloRequest request, IServerStreamWriter<HelloReply> responseStream,
        ServerCallContext context)
    {
        for (int i = 0; i < 10; i++)
        {
            await responseStream.WriteAsync(new HelloReply
            {
                Message = $"Hello #{i}, {request.Name}!"
            });
            await Task.Delay(500);
        }
    }
}

// Program.cs
builder.Services.AddGrpc();
app.MapGrpcService<GreeterService>();

// ── Background Service ──
public class EmailWorker : BackgroundService
{
    private readonly IEmailService _emailService;
    private readonly ILogger<EmailWorker> _logger;
    private readonly Channel<EmailJob> _channel;

    public EmailWorker(IEmailService emailService,
        ILogger<EmailWorker> logger,
        Channel<EmailJob> channel)
    {
        _emailService = emailService;
        _logger = logger;
        _channel = channel;
    }

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        await foreach (var job in _channel.Reader.ReadAllAsync(ct))
        {
            try
            {
                await _emailService.SendAsync(job.To, job.Subject, job.Body);
                _logger.LogInformation("Sent email to {To}", job.To);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to send email to {To}", job.To);
            }
        }
    }
}

// Program.cs (register)
builder.Services.AddSingleton(Channel.CreateUnbounded<EmailJob>());
builder.Services.AddHostedService<EmailWorker>();

// ── Channel<T> Producer (in controller/service) ──
public class OrderService
{
    private readonly Channel<EmailJob> _channel;
    public OrderService(Channel<EmailJob> channel) => _channel = channel;

    public async Task PlaceOrderAsync(Order order)
    {
        // ... save order ...
        await _channel.Writer.WriteAsync(new EmailJob
        {
            To = order.CustomerEmail,
            Subject = "Order Confirmed",
            Body = $"Your order #{order.Id} is confirmed!"
        });
    }
}

# ── Common Workflow ──
dotnet new webapi -n MyApi --use-minimal-apis
cd MyApi
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet ef migrations add InitialCreate
dotnet ef database update
dotnet watch run

# ── Publish for Production ──
dotnet publish -c Release -r linux-x64 --self-contained
dotnet publish -c Release -r win-x64 -p:PublishAot=true

# ── Check .NET SDK & Runtime ──
dotnet --list-sdks
dotnet --list-runtimes
dotnet --info

// ── appsettings.json ──
// {
//   "ConnectionStrings": {
//     "Default": "Server=localhost;Database=MyDb;Trusted_Connection=true"
//   },
//   "Email": {
//     "SmtpServer": "smtp.example.com",
//     "Port": 587,
//     "FromAddress": "noreply@example.com"
//   }
// }

// ── Strongly-typed Config ──
public class EmailSettings
{
    public string SmtpServer { get; set; } = string.Empty;
    public int Port { get; set; }
    public string FromAddress { get; set; } = string.Empty;
}

// Program.cs
builder.Services.Configure<EmailSettings>(
    builder.Configuration.GetSection("Email"));
builder.Services.AddSingleton(sp =>
    sp.GetRequiredService<IOptions<EmailSettings>>().Value);

// ── Serilog Setup ──
Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .WriteTo.File("logs/app-.log", rollingInterval: RollingInterval.Day)
    .WriteTo.Seq("http://localhost:5341")
    .Enrich.FromLogContext()
    .Enrich.WithMachineName()
    .CreateLogger();

builder.Host.UseSerilog(); // Use Serilog as the logging provider

// Usage
logger.LogInformation("Processing order {OrderId} for {Customer}", orderId, customer);
logger.LogWarning("Retry {Attempt} of {Max}", attempt, maxRetries);
logger.LogError(exception, "Failed to process payment for {OrderId}", orderId);

// ── Span<T> — Zero-allocation string processing ──
public static ReadOnlySpan<char> GetDomain(ReadOnlySpan<char> email)
{
    var atIndex = email.IndexOf('@');
    return atIndex >= 0 ? email[(atIndex + 1)..] : ReadOnlySpan<char>.Empty;
}

// Usage (no heap allocation)
var domain = GetDomain("user@example.com".AsSpan());

// ── ArrayPool<T> — Reduce GC pressure ──
public void ProcessLargeData()
{
    var pool = ArrayPool<byte>.Shared;
    byte[] buffer = pool.Rent(1024 * 1024); // Rent 1MB buffer
    try
    {
        // Use buffer[0..1023*1024]
        int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
    }
    finally
    {
        pool.Return(buffer, clearArray: true); // Return to pool
    }
}

// ── ValueTask — Avoid allocation for sync results ──
public ValueTask<int> GetCachedValueAsync(string key)
{
    if (_cache.TryGetValue(key, out var value))
        return ValueTask.FromResult(value); // No allocation!
    return new ValueTask<int>(LoadFromDbAsync(key)); // Allocates only when needed
}

// ── Async best practices ──
// ✅ DO: Use ConfigureAwait(false) in library code
await httpClient.GetStringAsync(url).ConfigureAwait(false);

// ✅ DO: Use CancellationToken
public async Task<List<Product>> GetAllAsync(CancellationToken ct = default)
{
    return await db.Products.ToListAsync(ct);
}

// ❌ DON'T: Use Task.Run in ASP.NET Core (already on thread pool)

# ── .NET Dockerfile (Multi-stage) ──
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY ["MyApi.csproj", "./"]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

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

// ── .NET Aspire App Host ──
var builder = DistributedApplication.CreateBuilder(args);

var api = builder.AddProject<Projects.MyApi>("api")
    .WithReplicas(3);

var postgres = builder.AddPostgres("postgres")
    .AddDatabase("mydb");

var redis = builder.AddRedis("cache");

api.WithReference(postgres)
   .WithReference(redis);

builder.AddNpmApp("frontend", "../frontend")
    .WithReference(api);

builder.Build().Run();

# ── GitHub Actions CI/CD ──
name: Build & Deploy
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.0.x'
      - run: dotnet restore
      - run: dotnet build -c Release --no-restore
      - run: dotnet test -c Release --no-build --verbosity normal
      - run: dotnet publish -c Release -o ./publish
      - uses: azure/webapps-deploy@v3
        with:
          app-name: my-api
          publish-profile: ${{ secrets.AZURE_PUBLISH_PROFILE }}
          package: ./publish