DEV Community: Vikrant Bagal

TypeScript 7.0 Beta: The 10x Faster Revolution Built on Go

Vikrant Bagal — Mon, 11 May 2026 13:40:16 +0000

TypeScript 7.0 Beta has arrived, and it's not just an incremental update—it's a complete architectural revolution. Built on a new Go foundation, Microsoft claims a 10x performance improvement over TypeScript 6.0. After testing the beta extensively, I can confirm: the speed gains are real, and they're game-changing for large-scale TypeScript projects.

The Big Rewrite: TypeScript in Go

For over a decade, TypeScript has been bootstrapped in TypeScript itself, compiling to JavaScript. While this worked well, it had fundamental limitations when it came to parallelization and raw performance.

TypeScript 7.0 changes everything by rewriting the compiler in Go. This isn't just a language switch—it's a complete architectural overhaul that leverages:

Native code speed: Go compiles to machine code, eliminating JavaScript interpreter overhead
Shared-memory parallelism: Multiple type-checkers can run simultaneously without conflicts
Deterministic output: New stable type ordering ensures consistent results across runs

As Daniel Rosenwasser, TypeScript Product Manager, stated: "The new Go codebase was methodically ported from our existing implementation rather than rewritten from scratch, and its type-checking logic is structurally identical to TypeScript 6.0."

Performance Benchmarks: The Numbers Don't Lie

Let's look at real-world benchmarks from developer testing:

Project	TypeScript 6.0	TypeScript 7.0 Beta	Speedup
Material-UI	42.3s	4.1s	10.3x
VS Code	127.8s	12.4s	10.3x
React	89.2s	8.7s	10.2x

These aren't synthetic benchmarks—they're real codebases with thousands of files being type-checked. For teams waiting minutes for CI builds, this is transformative.

Parallel Compilation: The Secret Sauce

TypeScript 7.0 introduces two new flags that unlock multi-core performance:

{
  "compilerOptions": {
    "checkers": 4,    // Number of parallel type-checker workers (default: 4)
    "builders": 2,    // Number of parallel project builders (default: 1)
    "singleThreaded": false  // Disable for debugging
  }
}

--checkers: Splits type-checking work across multiple workers, each with its own view of the program
--builders: Builds multiple project references simultaneously, perfect for monorepos
--singleThreaded: Forces single-threaded operation for debugging and comparison

For a monorepo with 8 projects and --checkers 4 --builders 4, you can theoretically run up to 16 parallel type-checkers!

Getting Started with TypeScript 7.0 Beta

Installation

npm install -D @typescript/native-preview@beta

Using the New Compiler

# Check your version
npx tsgo --version

# Compile your project
npx tsgo -p tsconfig.json

Note: The package name will eventually be typescript, but for now it's @typescript/native-preview.

VS Code Integration

For the best editor experience, install the TypeScript Native Preview extension:

TypeScript Native Preview - VS Code Marketplace

This extension uses the same Go-based foundation, bringing 10x speed improvements directly to your editor—faster autocompletions, quicker error detection, and snappier refactoring.

Breaking Changes: What You Need to Know

TypeScript 7.0 adopts TypeScript 6.0's new defaults and introduces stricter settings. Here's what changed:

New tsconfig.json Defaults

Setting	Old Default	New Default	Impact
`strict`	`false`	`true`	Enables all strict type-checking options
`module`	`commonjs`	`esnext`	Modern module resolution
`target`	Varies	Stable ECMAScript	Consistent JavaScript output
`rootDir`	Auto-detected	`./`	May need explicit setting
`types`	`["*"]`	`[]`	Global types must be listed explicitly
`libReplacement`	`true`	`false`	Different lib handling

Migration Checklist

If you're upgrading to TypeScript 7.0, here's what to check:

Update tsconfig.json:

{
  "compilerOptions": {
    "strict": true,           // Explicitly set if you want strict mode
    "rootDir": "./src",       // Add if tsconfig is outside src/
    "types": ["node"],        // List global @types packages
    "module": "esnext",       // Modern modules
    "target": "es2024"        // Stable ECMAScript
  },
  "include": ["./src"]
}

Review type errors: Stricter defaults may reveal previously hidden issues
Test in CI first: Run TypeScript 7.0 in your CI pipeline before production

Parallelization in Action

Let's look at a practical example of parallel compilation:

// tsconfig.json for a monorepo
{
  "compilerOptions": {
    "checkers": 6,      // 6 parallel type-checkers
    "builders": 3,      // Build 3 projects simultaneously
    "incremental": true // Faster incremental builds
  },
  "references": [
    { "path": "./packages/ui" },
    { "path": "./packages/api" },
    { "path": "./packages/shared" }
  ]
}

For a project with 6 CPU cores and 32GB RAM, this configuration can achieve:

2x faster builds with --checkers 6
3x faster monorepo builds with --builders 3
Combined effect: Up to 6x total improvement

Memory Considerations

Parallelization comes with a memory tradeoff. Here are recommended settings:

System RAM	Recommended --checkers
8GB	2
16GB	4
32GB	6-8
64GB+	8-12

If you encounter OOM errors, reduce --checkers or switch to --singleThreaded mode.

Real-World Adoption

Major companies are already testing TypeScript 7.0 Beta:

Bloomberg: Reduced build times from 3+ minutes to 18 seconds in their 500K+ line financial codebase
Vercel: Achieved 9.8x faster type-checking in CI pipelines
Notion: Improved editor responsiveness by 40% with the native preview extension
Slack: Reduced monorepo build time by 85% using parallel builders

Running TypeScript 7.0 Side-by-Side with 6.0

Want to test TypeScript 7.0 without replacing your current setup? Use the compatibility package:

npm install -D typescript@npm:@typescript/typescript6

{
  "devDependencies": {
    "typescript": "npm:@typescript/typescript6@^6.0.0"
  }
}

This allows you to run both compilers simultaneously:

tsc uses TypeScript 6.0
tsgo uses TypeScript 7.0 Beta

Best Practices for Production Adoption

1. Start with TypeScript 6.0 First

TypeScript 6.0 is the bridge release that prepares your codebase for 7.0. Adopt 6.0 and address any deprecation warnings before moving to 7.0.

2. Test in Development First

Run TypeScript 7.0 Beta on your development machines and CI pipeline before considering production use.

3. Monitor Build Performance

Track actual build times and memory usage. Adjust --checkers and --builders based on your infrastructure.

4. Leverage Project References

For monorepos, use TypeScript project references to maximize parallelization benefits.

5. Plan for Breaking Changes

Review the new defaults and update your tsconfig.json accordingly.

What's Next for TypeScript 7.0

The TypeScript team has shared their roadmap:

TypeScript 7.0 RC: Expected mid-June 2026
TypeScript 7.0 Stable: Expected late July/early August 2026
Stable Programmatic API: Coming in TypeScript 7.1
Watch Mode Improvements: More efficient incremental compilation

Conclusion

TypeScript 7.0 Beta represents a massive leap forward for TypeScript performance. The 10x speed improvement isn't marketing hype—it's a real, measurable improvement that transforms the development experience for large codebases.

The Go-based foundation opens new possibilities for parallelization that simply weren't feasible before. Combined with the stability of the existing type-checking logic, TypeScript 7.0 offers the best of both worlds: blazing speed and rock-solid type safety.

If you're working on a large TypeScript project, now is the time to start testing TypeScript 7.0 Beta. The performance gains are too significant to ignore.

Try TypeScript 7.0 Beta today:

npm install -D @typescript/native-preview@beta
npx tsgo --version

Resources:

Follow me on LinkedIn for more technical content and insights!

Copilot Studio gets faster with .NET 10 on WebAssembly

Vikrant Bagal — Fri, 08 May 2026 14:46:54 +0000

Blazing Fast AI: How Copilot Studio is Leveling Up with .NET 10 and WebAssembly 🚀

Let’s be honest: we’ve all been there. You open a powerful low-code tool or a complex AI orchestrator, and you spend the first thirty seconds staring at a loading spinner or feeling that slight "input lag" as you drag a node across a canvas.

When you're building complex conversational flows in Copilot Studio, fluidity is everything. If the UI stutters, the creative flow breaks. For a long time, the trade-off was simple: you either had the flexibility of the web (JavaScript/TypeScript) or the raw power of native code.

But the gap is closing. With the evolution of .NET 10 and WebAssembly (Wasm), Copilot Studio is pushing the boundaries of what "web-based" performance actually feels like. As a developer who has spent years wrestling with browser memory limits and JS heap overflows, seeing .NET run at near-native speeds in the browser is nothing short of magic.

The Magic Sauce: Why .NET 10 + WebAssembly?

To understand why this matters, we have to talk about the architecture. Traditionally, complex logic in the browser is handled by JavaScript. While JS engines (like V8) are incredibly fast, they still struggle with heavy computational tasks—like the graph rendering and state management required for an AI Copilot's orchestration canvas.

Enter WebAssembly (Wasm). Wasm allows us to run compiled code (like C#) in the browser at speeds that rival native applications.

.NET 10 takes this further by optimizing the runtime specifically for the browser environment. We aren't just talking about "running C# in the browser"; we're talking about:

Reduced Binary Size: Faster initial loads (less time staring at that spinner).
Enhanced AOT (Ahead-of-Time) Compilation: Code is pre-compiled to Wasm, removing the "warm-up" time typical of interpreted languages.
Improved Interop: The bridge between the .NET logic and the browser's DOM is now significantly thinner and faster.

Breaking Down the Performance Gain

If you're wondering how this actually translates to the Copilot Studio experience, think about the Canvas. When you have a Copilot with 50+ nodes, variables, and complex trigger logic, the browser has to constantly recalculate positions and state transitions.

In the "Old World" (Standard JS/Wasm), every time you moved a node, the bridge between the logic layer and the UI layer created a slight overhead. With .NET 10's optimizations, the execution loop is tighter.

The Conceptual "Speed-Up" Flow:

Standard Web App: UI Event $\rightarrow$ JS Engine $\rightarrow$ Logic Processing $\rightarrow$ DOM Update
.NET 10 Wasm: UI Event $\rightarrow$ Highly Optimized Wasm Binary $\rightarrow$ Direct Memory Access $\rightarrow$ Optimized UI Update

A Glimpse Under the Hood: Working with Wasm

While Copilot Studio handles the heavy lifting for you, if you're building your own high-performance web tools using .NET 10, you'll likely be interacting with Microsoft.AspNetCore.Components.WebAssembly.

Here is a simplified example of how a high-performance calculation (like a node-positioning algorithm for a flow chart) looks in a .NET Wasm project:

// This logic runs in the browser via WebAssembly
public class FlowCanvasEngine
{
    public Point CalculateNodePosition(Node node, List<Node> siblings)
    {
        // Complex math that would typically choke a JS main thread
        // .NET 10 leverages SIMD (Single Instruction, Multiple Data) 
        // for lightning-fast vector calculations in Wasm.
        var offset = siblings.Count * 150;
        return new Point(node.Id * 10, offset);
    }
}

And the way we call this from the UI remains seamless:

@page "/canvas"
@inject FlowCanvasEngine Engine

<div class="canvas-container">
    @foreach (var node in Nodes)
    {
        var pos = Engine.CalculateNodePosition(node, Nodes);
        <NodeComponent X="@pos.X" Y="@pos.Y" />
    }
</div>

Real-World Impact: What this means for the User

For the average Copilot Studio creator, this isn't about "C# vs JS." It's about the UX.

Instantaneous Node Manipulation: Dragging and dropping complex logic blocks feels "snappy."
Faster Project Load Times: Thanks to .NET 10's leaner runtime, your massive Copilots load faster, even on lower-spec machines.
Complex Logic Validation: When the system checks your flow for errors in real-time, that validation happens in milliseconds, not seconds.

Common Pitfalls to Watch Out For

Even with the power of .NET 10, there are things to keep in mind if you're implementing similar Wasm architectures:

The "Payload" Problem: While .NET 10 is smaller, Wasm binaries are still larger than a few lines of JS. Always implement lazy loading for your heavy modules.
DOM Access: Wasm cannot access the DOM directly; it has to go through JS interop. If you call InvokeInterOp 1,000 times a second, you'll kill your performance. Batch your updates!
Memory Management: Wasm has its own memory heap. Be mindful of large object allocations to avoid browser-side memory pressure.

Pro-Tips for Maximum Performance 🛠️

If you're leveraging .NET 10 for your web-based AI tools, follow these best practices:

Use AOT Compilation: Enable Ahead-of-Time compilation in your .csproj to maximize execution speed.
Leverage SIMD: If you're doing heavy math (like AI token processing or layout engines), use System.Numerics to take advantage of hardware acceleration in the browser.
Profile with Browser DevTools: Don't guess. Use the "Performance" tab in Chrome/Edge to see exactly where the Wasm execution is spending its time.

Final Thoughts: The Future of Low-Code

The marriage of .NET 10 and WebAssembly is a game-changer for tools like Copilot Studio. It proves that we no longer have to choose between the reach of the web and the power of the desktop.

By moving the "heavy lifting" into an optimized Wasm runtime, Microsoft is essentially turning the browser into a professional-grade IDE for AI orchestration. For us developers, it's a signal that the boundary between "Web App" and "Application" is officially disappearing.

What do you think? Are you using .NET Wasm in your current projects, or are you sticking with the traditional JS ecosystem? Let me know in the comments! If you've noticed a speed bump in your Copilot Studio flows, try clearing your cache and seeing if the latest runtime updates have hit your region.

Next Steps:

🚀 Check out the .NET 10 Preview documentation.
🛠️ Try building a small Blazor WebAssembly app to feel the performance difference.
🤖 Dive deeper into Copilot Studio to see these optimizations in action.

Production-Grade Engineering Skills for AI Coding Agents

Vikrant Bagal — Fri, 08 May 2026 02:55:30 +0000

AI coding agents have revolutionized how we write software. They can implement features, fix bugs, and review code at incredible speed. But there's a catch: AI agents default to the shortest path, which often means skipping specs, tests, security reviews, and the practices that make software reliable.

The solution? Production-grade engineering skills for AI coding agents—structured workflows that enforce the same discipline senior engineers bring to production code.

The Problem: AI Agents Need Guardrails

When you give an AI agent a vague prompt like "build a dashboard," it will produce something that looks functional. But will it be:

✅ Well-specified with clear success criteria?
✅ Tested with comprehensive coverage?
✅ Secure against common vulnerabilities?
✅ Performant and maintainable?

Without structured workflows, the answer is often "no." The agent optimizes for "looks right" rather than "is right."

The Solution: Agent Skills

Agent Skills is a production-grade collection of 20 structured workflows for AI coding agents. With 33,000+ stars on GitHub, it's become the de facto standard for reliable AI-assisted development.

Each skill encodes hard-won engineering judgment from Google's engineering culture, including concepts from Software Engineering at Google and Google's engineering practices guide.

The 20 Skills Cover the Entire Lifecycle

Define Phase:

Idea Refinement - Structured divergent/convergent thinking
Spec-Driven Development - Write a PRD before any code

Plan Phase:

Planning and Task Breakdown - Decompose specs into verifiable tasks

Build Phase:

Incremental Implementation - Thin vertical slices with feature flags
Context Engineering - Feed agents the right information at the right time
Source-Driven Development - Ground decisions in official documentation
Frontend UI Engineering - Component architecture, design systems, accessibility
API and Interface Design - Contract-first design, error semantics
Test-Driven Development - RED-GREEN-REFACTOR workflow

Verify Phase:

Browser Testing with DevTools - Chrome DevTools MCP for runtime data
Debugging and Error Recovery - Five-step triage: reproduce, localize, reduce, fix, guard

Review Phase:

Code Review and Quality - Five-axis review, change sizing, severity labels
Code Simplification - Chesterton's Fence, Rule of 500
Security and Hardening - OWASP Top 10 prevention, auth patterns
Performance Optimization - Measure-first approach, Core Web Vitals

Ship Phase:

Git Workflow and Versioning - Trunk-based development, atomic commits
CI/CD and Automation - Shift Left, Faster is Safer, feature flags
Deprecation and Migration - Code-as-liability mindset
Documentation and ADRs - Architecture Decision Records
Shipping and Launch - Pre-launch checklists, staged rollouts

Deep Dive: Spec-Driven Development

The most critical skill is Spec-Driven Development. Before writing any code, the agent creates a specification covering:

The Six-Core Spec Template

# Spec: [Project/Feature Name]

## Objective
What we're building and why. User stories or acceptance criteria.

## Tech Stack
Framework, language, key dependencies with versions

## Commands
Build: npm run build
Test: npm test -- --coverage
Lint: npm run lint --fix
Dev: npm run dev

## Project Structure
src/ → Application source code
src/components → React components
src/lib → Shared utilities
tests/ → Unit and integration tests

## Code Style
Example snippet + key conventions

## Testing Strategy
Framework, test locations, coverage requirements

## Boundaries
- Always: Run tests before commits, follow naming conventions
- Ask first: Database schema changes, adding dependencies
- Never: Commit secrets, edit vendor directories

## Success Criteria
Specific, testable conditions for completion

## Open Questions
Anything unresolved that needs human input

Why This Works

Surfaces Assumptions Early - The spec forces clarity before code
Shared Source of Truth - Human and agent agree on what "done" means
Prevents Rework - A 15-minute spec prevents hours of debugging
Living Document - Updated when decisions change, committed to version control

Deep Dive: Test-Driven Development

The Test-Driven Development skill enforces the RED-GREEN-REFACTOR cycle:

The Cycle

RED: Write a test that fails (proves the test works)
GREEN: Write minimal code to make it pass
REFACTOR: Clean up the implementation
Repeat for each new behavior

Example: Task Service

// RED: This test fails because createTask doesn't exist yet
describe('TaskService', () => {
  it('creates a task with title and default status', async () => {
    const task = await taskService.createTask({ title: 'Buy groceries' });
    expect(task.id).toBeDefined();
    expect(task.title).toBe('Buy groceries');
    expect(task.status).toBe('pending');
    expect(task.createdAt).toBeInstanceOf(Date);
  });
});

// GREEN: Minimal implementation
export async function createTask(input: { title: string }): Promise<Task> {
  const task = {
    id: generateId(),
    title: input.title,
    status: 'pending' as const,
    createdAt: new Date(),
  };
  await db.tasks.insert(task);
  return task;
}

Test Pyramid

80% Unit Tests (small, fast, isolated)
15% Integration Tests (component interactions, API boundaries)
5% E2E Tests (full user flows, real browser)

Real-World Examples

Example 1: Bug Fix with TDD

Bug Report: "Completing a task doesn't update completedAt timestamp"

Agent writes failing test that reproduces the bug
Test confirms bug exists (RED)
Agent implements fix (GREEN)
Agent runs full test suite to ensure no regressions
Result: Bug fixed with guaranteed correctness

Example 2: Parallel Agent Workflow

Scenario: Full-stack feature implementation

Agent 1 (backend): Implements API endpoints in feature branch A
Agent 2 (frontend): Builds React components in feature branch B
Agent 3 (tests): Writes integration tests in feature branch C
Human: Reviews and merges all branches after parallel completion

Result: 3x faster than sequential development

Example 3: Security Review

Agent Skills includes security-and-hardening skill:

OWASP Top 10 prevention patterns
Authentication and authorization patterns
Secrets management and dependency auditing
Three-tier boundary system

Before any code merge, the security skill runs automatically, catching vulnerabilities early.

Common Pitfalls (And How to Avoid Them)

1. Over-Prompting

Problem: Long, repetitive, contradictory prompts confuse agents
Solution: Say what you need once, clearly. Restate rather than append.

2. Under-Reviewing

Problem: Assuming AI-generated code is correct because it looks right
Solution: Review every diff like a pull request from a teammate

3. Skipping Git Isolation

Problem: Running agents on main branch leads to conflicts
Solution: Always use feature branches; use git worktrees for parallel agents

4. Ignoring Session Boundaries

Problem: One long session leads to context bloat and inconsistent decisions
Solution: Start fresh sessions for new tasks; keep sessions focused

5. Testing Implementation Details

Problem: Tests break when refactoring even if behavior unchanged
Solution: Test inputs and outputs, not internal structure

Getting Started

Install Agent Skills

For Claude Code:

/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills

For Cursor: Copy SKILL.md files into .cursor/rules/

For Gemini CLI:

gemini skills install https://github.com/addyosmani/agent-skills.git --path skills

Create Your First AGENTS.md

Create an AGENTS.md file at your repository root with:

Project layout and important directories
Build, test, lint commands
Engineering conventions
Constraints and do-not rules

Start with Spec-Driven Development

Create a new feature branch
Run the spec-driven development skill
Write the spec with human review
Break into tasks with acceptance criteria
Implement incrementally with tests

The Bottom Line

AI coding agents are powerful but need guardrails. Production-grade engineering skills provide the structure, workflows, and best practices that make AI-assisted development reliable.

The agents who write the best prompts aren't the most productive. The ones with the best processes around prompting are.

Start with spec-driven development. Add test-driven development. Review everything. Manage context like a resource. And watch your AI coding agents transform from fast code generators to reliable engineering partners.

Ready to level up your AI coding workflow? Start with the Agent Skills repository and implement one skill at a time. Your future self (and your production environment) will thank you.

LinkedIn: https://www.linkedin.com/in/vikrant-bagal

ASP.NET Middleware: Complete Guide from Basics to Advanced Patterns, Tips, and Performance

Vikrant Bagal — Thu, 30 Apr 2026 17:57:45 +0000

The ASP.NET Core middleware pipeline is the backbone of every HTTP request your application processes. Yet most developers only scratch the surface—registering UseAuthentication() and UseAuthorization() without understanding what actually happens in between. This comprehensive guide takes you from fundamental concepts to advanced patterns, performance optimization, and real-world usage scenarios.

What is ASP.NET Middleware?

Middleware in ASP.NET Core is software that's assembled into an app pipeline to handle requests and responses. Each middleware component:

Chooses whether to pass the request to the next middleware
Can perform work before and after the next middleware
Can short-circuit the pipeline entirely

Think of it as an assembly line: each station does one specific job (logging, authentication, CORS headers, compression), and the request moves from station to station. The response then travels back through the same chain in reverse order.

The Middleware Pipeline Basics

Request Delegates and HttpContext

At the core of every middleware component are request delegates—functions that process HTTP requests. There are three ways to define them:

Inline middleware with app.Use() - passes to next middleware
Terminal middleware with app.Run() - short-circuits the pipeline
Convention-based middleware classes - reusable components

The HttpContext object carries everything about the current HTTP request and response. Every middleware receives it, and it's how components communicate:

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

app.Use(async (context, next) =>
{
    Console.WriteLine($"Before: {context.Request.Path}");
    await next();  // Call next middleware
    Console.WriteLine($"After: {context.Response.StatusCode}");
});

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello, World!");
});

app.Run();

Execution Order: The Golden Rule

Registration order = execution order. This is the most critical concept. The request flows forward through middleware, the response flows backward. Get the order wrong, and your application silently misbehaves.

Here's what happens when you register three middleware components:

app.Use(async (context, next) =>
{
    Console.WriteLine("Middleware 1: Incoming request");
    await next();
    Console.WriteLine("Middleware 1: Outgoing response");
});

app.Use(async (context, next) =>
{
    Console.WriteLine("Middleware 2: Incoming request");
    await next();
    Console.WriteLine("Middleware 2: Outgoing response");
});

app.Run(async context =>
{
    Console.WriteLine("Middleware 3: Terminal - handling request");
    await context.Response.WriteAsync("Hello, world!");
});

Console output:

Middleware 1: Incoming request
Middleware 2: Incoming request
Middleware 3: Terminal - handling request
Middleware 2: Outgoing response
Middleware 1: Outgoing response

Notice the nesting pattern—it's like Russian dolls. Middleware 1 wraps Middleware 2, which wraps Middleware 3.

Common Built-in Middleware in .NET 10

ASP.NET Core ships with middleware for the most common cross-cutting concerns:

Exception Handling Middleware

Catches unhandled exceptions and returns structured error responses.

app.UseExceptionHandler();

Routing Middleware

Maps incoming requests to endpoints. In .NET 10 with minimal APIs, routing is implicit.

app.UseRouting();

Authentication and Authorization

Establishes user identity and enforces access policies. Always register authentication before authorization.

app.UseAuthentication();
app.UseAuthorization();

HTTPS Redirection

Redirects HTTP requests to HTTPS.

app.UseHttpsRedirection();

CORS Middleware

Controls cross-origin request access for browser-based clients.

app.UseCors("AllowFrontend");

Response Compression Middleware

Compresses responses using gzip or Brotli to reduce bandwidth.

app.UseResponseCompression();

Output Caching Middleware (.NET 10)

Server-side response caching with tag-based invalidation.

app.UseOutputCache();

Rate Limiting Middleware (.NET 10)

Built-in rate limiting with fixed window, sliding window, token bucket, and concurrency algorithms.

app.UseRateLimiter();

Custom Middleware: Patterns and Best Practices

Convention-Based Middleware

This is the most common approach for custom middleware. A convention-based middleware class must:

Accept a RequestDelegate in its constructor (represents the next middleware)
Implement an InvokeAsync method that takes HttpContext and returns Task
Call await next(context) to pass control (or skip it to short-circuit)

Request Logging Middleware Example:

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)
    {
        var startTime = DateTime.UtcNow;
        _logger.LogInformation("Incoming {Method} {Path}", 
            context.Request.Method, context.Request.Path);

        await _next(context);

        var elapsed = DateTime.UtcNow - startTime;
        _logger.LogInformation("Completed {Method} {Path} with {StatusCode} in {Elapsed}ms",
            context.Request.Method, context.Request.Path, 
            context.Response.StatusCode, elapsed.TotalMilliseconds);
    }
}

Registration:

// Option 1: Direct registration
app.UseMiddleware<RequestLoggingMiddleware>();

// Option 2: Extension method (preferred)
public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseRequestLogging(this IApplicationBuilder app)
    {
        return app.UseMiddleware<RequestLoggingMiddleware>();
    }
}

app.UseRequestLogging();

IMiddleware Interface: DI-Friendly Alternative

Convention-based middleware has a limitation: it's registered as a singleton by default. If you need scoped services (like DbContext), you'll encounter lifetime mismatch issues. The IMiddleware interface solves this:

public class CorrelationIdMiddleware : IMiddleware
{
    private readonly ILogger<CorrelationIdMiddleware> _logger;

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

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var correlationId = context.Request.Headers["X-Correlation-Id"].FirstOrDefault()
            ?? Guid.NewGuid().ToString();

        context.Items["CorrelationId"] = correlationId;
        context.Response.Headers["X-Correlation-Id"] = correlationId;

        using (_logger.BeginScope(new Dictionary<string, object> 
            { ["CorrelationId"] = correlationId }))
        {
            _logger.LogInformation("Request {Path} assigned CorrelationId {CorrelationId}",
                context.Request.Path, correlationId);
            await next(context);
        }
    }
}

Registration:

// Step 1: Register in DI container
builder.Services.AddTransient<CorrelationIdMiddleware>();

// Step 2: Add to pipeline
app.UseMiddleware<CorrelationIdMiddleware>();

When to use which:

Convention-based: Middleware only needs singleton services (ILogger, IConfiguration)
IMiddleware: Middleware needs scoped services (DbContext, IHttpClientFactory) or per-request activation

Branching the Pipeline

ASP.NET Core provides three methods for branching the middleware pipeline:

1. Map() - Path-Based Branching

Creates a separate pipeline for matching paths:

app.Map("/health", async ctx =>
{
    await ctx.Response.WriteAsync("OK");
});

2. MapWhen() - Predicate-Based Permanent Fork

Creates a permanent fork based on a predicate:

app.MapWhen(
    context => context.Request.Query.ContainsKey("branch"),
    appBuilder => appBuilder.Run(async context =>
    {
        var branchVer = context.Request.Query["branch"];
        await context.Response.WriteAsync($"Branch used = '{branchVer}'");
    })
);

3. UseWhen() - Conditional Branch That Rejoins

Runs middleware for matching requests, then rejoins the main pipeline:

app.UseWhen(
    context => context.Request.Path.StartsWithSegments("/api"),
    appBuilder => appBuilder.UseMiddleware<RequestLoggingMiddleware>()
);

Key Difference:

MapWhen: Creates a permanent fork (main pipeline is abandoned)
UseWhen: Temporary branch that rejoins the main pipeline

Short-Circuiting the Pipeline

Short-circuiting means returning a response without calling next(), preventing downstream middleware from executing. This is crucial for performance.

Maintenance Mode Example

public class MaintenanceMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IConfiguration _configuration;

    public MaintenanceMiddleware(RequestDelegate next, IConfiguration configuration)
    {
        _next = next;
        _configuration = configuration;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var isMaintenanceMode = _configuration.GetValue<bool>("MaintenanceMode");
        if (isMaintenanceMode)
        {
            context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
            context.Response.ContentType = "application/json";
            await context.Response.WriteAsJsonAsync(new
            {
                Status = 503,
                Message = "Service is under maintenance. Please try again later."
            });
            return; // Short-circuit - do not call next
        }
        await next(context);
    }
}

Performance Optimization Tips

1. Short-Circuit Early

If you can return a response without calling next(), do it immediately. Every skipped middleware saves CPU cycles.

app.Use(async (context, next) =>
{
    // Cheap check first — skip entire pipeline for OPTIONS
    if (context.Request.Method == HttpMethods.Options)
    {
        context.Response.StatusCode = StatusCodes.Status204NoContent;
        return; // no next() — short-circuit
    }
    await next();
});

2. Order is Everything

Put cheap, high-skip-rate middleware first. Authentication, CORS, and routing should run before expensive operations.

Recommended Order:

app.UseExceptionHandler();        // Only fires on errors
app.UseHttpsRedirection();        // Cheap redirect
app.UseRouting();                 // Essential
app.UseAuthentication();          // May short-circuit unauthorized
app.UseAuthorization();           // Same
app.UseResponseCompression();     // Compress responses
app.UseEndpoints();               // Execute endpoints

3. Never Sync-over-Async

Using .Result, .Wait(), or GetAwaiter().GetResult() inside middleware will deadlock your thread pool.

// ❌ BAD — blocks thread pool
app.Use(async (context, next) =>
{
    var data = GetSomethingAsync().Result;  // Deadlock risk!
    await next();
});

// ✅ GOOD — truly asynchronous
app.Use(async (context, next) =>
{
    var data = await GetSomethingAsync();  // Proper async
    await next();
});

4. Avoid Buffering Large Request Bodies

Middleware that reads context.Request.Body into memory forces the entire body to be buffered. For file uploads or large payloads, process the stream directly or set reasonable body size limits.

5. Go End-to-End Async

Every layer of your stack should be async—database calls, HTTP client requests, serialization. If one piece sync-blocks, it bottlenecks the whole pipeline.

.NET 9 New Features

MapStaticAssets

Replaces UseStaticFiles() with built-in compression and ETag support:

// Old approach
app.UseStaticFiles();

// .NET 9 — auto-compresses, adds ETags, better caching
app.MapStaticAssets();

Improved IExceptionHandler

Exception handlers got a StatusCodeSelector attribute:

builder.Services.AddExceptionHandler<AppExceptionHandler>();

public class AppExceptionHandler : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(
        HttpContext httpContext, Exception exception,
        CancellationToken cancellationToken)
    {
        httpContext.Response.StatusCode = exception switch
        {
            NotFoundException => StatusCodes.Status404NotFound,
            ValidationException => StatusCodes.Status422UnprocessableEntity,
            _ => StatusCodes.Status500InternalServerError
        };

        await httpContext.Response.WriteAsJsonAsync(
            new { error = exception.Message }, cancellationToken);

        return true; // handled
    }
}

Route Group Improvements

Route groups now support ProducesProblem consistently for uniform error shapes.

Real-World Usage Patterns

Enterprise Logging Pipeline

app.UseRequestLogging();          // Capture request/response details
app.UseCorrelationId();           // Add correlation IDs for tracing
app.UseSerilogRequestLogging();   // Structured logging
app.UseExceptionHandler();        // Global exception handling

Security Pipeline

app.UseHttpsRedirection();        // Force HTTPS
app.UseCors("AllowFrontend");     // CORS headers
app.UseAuthentication();          // Establish identity
app.UseAuthorization();           // Check permissions
app.UseRateLimiter();             // Rate limiting

Performance Pipeline

app.UseResponseCompression();     // Compress responses
app.UseOutputCache();             // Server-side caching
app.UseStaticFiles();             // Serve static assets
app.UseRouting();                 // Route matching

Common Pitfalls and Solutions

1. Wrong Middleware Order

Problem: Authentication before authorization causes random failures.
Solution: Always follow: Authentication → Authorization → Endpoint execution.

2. Sync-over-Async Deadlocks

Problem: Using .Result or .Wait() in middleware blocks thread pool.
Solution: Always use await for async operations.

3. Scoped Services in Singleton Middleware

Problem: Convention-based middleware is singleton; scoped services cause memory leaks.
Solution: Use IMiddleware interface for per-request activation.

4. Not Short-Circuiting

Problem: Middleware calls next() even when it shouldn't, wasting resources.
Solution: Short-circuit early when possible (auth failures, maintenance mode).

5. Reading Large Request Bodies

Problem: Middleware buffering large request bodies into memory.
Solution: Process streams directly or set body size limits.

6. Exception Handling Too Late

Problem: Exception middleware registered after other middleware misses exceptions.
Solution: Register exception handling middleware first in the pipeline.

Conclusion

The ASP.NET Core middleware pipeline is where your application does its real work. Understanding the fundamentals—execution order, branching, short-circuiting—is essential for building robust, performant applications. Follow the recommended patterns, avoid common pitfalls, and leverage .NET 9 improvements for optimal results.

Remember: middleware is the backbone of every HTTP request. Get it right, and your application runs smoothly. Get it wrong, and you'll spend hours debugging subtle issues.

LinkedIn: https://www.linkedin.com/in/vikrant-bagal

Writing Node.js Addons with .NET Native AOT: A Complete Guide

Vikrant Bagal — Tue, 28 Apr 2026 17:40:49 +0000

Ever wished you could write Node.js native addons in C# instead of C++? .NET Native AOT makes it possible—and practical.

The Problem with Traditional Node.js Addons

If you've ever built a Node.js native addon, you know the pain:

C++ required: Even for simple functionality, you need C++ knowledge
node-gyp complexity: Build system that's notoriously finicky
Python dependency: Requires specific Python versions (often outdated)
Cross-platform headaches: Different build configurations per OS

For the Microsoft C# Dev Kit team, these friction points added unnecessary complexity to their development workflow. They needed Windows Registry access from their VS Code extension—but the C++ tooling didn't align with their .NET-centric stack.

The Solution: .NET Native AOT

What if you could write Node.js addons in C#? With .NET Native AOT, you can. The C# Dev Kit team replaced their C++ addon with a C# implementation—and it worked beautifully.

Here's why this approach is groundbreaking:

No Python required - Just the .NET SDK
Modern C# features - Type safety, async/await, LINQ
Cross-platform - Works on Windows, Linux, and macOS
Smaller toolchain - One SDK for everything

How It Works: N-API + Native AOT

The Magic Ingredient: N-API

N-API (Node-API) is a stable, ABI-compatible C API for building Node.js addons. The key insight: N-API doesn't care what language you use.

As long as your shared library exports the napi_register_module_v1 function and uses the correct C calling convention, Node.js will load it. This makes Native AOT a perfect fit.

Native AOT Compilation

.NET Native AOT compiles your C# code directly to native machine code, producing:

Windows: .dll shared library
Linux: .so shared library
macOS: .dylib shared library

Node.js treats these as native addons (rename to .node extension).

Step-by-Step Implementation

1. Create the Project

Create a new console app with these properties:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <PublishAot>true</PublishAot>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>
</Project>

PublishAot enables Native AOT compilation
AllowUnsafeBlocks needed for pointer interop with N-API

2. Define the Module Entry Point

Node.js expects your shared library to export napi_register_module_v1. We use UnmanagedCallersOnly:

public static unsafe partial class RegistryAddon
{
    [UnmanagedCallersOnly(
        EntryPoint = "napi_register_module_v1",
        CallConvs = [typeof(CallConvCdecl)])]
    public static nint Init(nint env, nint exports)
    {
        Initialize();

        // Register JavaScript functions
        RegisterFunction(
            env,
            exports,
            "readStringValue"u8,
            &ReadStringValue);

        return exports;
    }
}

Key points:

UnmanagedCallersOnly tells the AOT compiler to export the method
EntryPoint specifies the function name Node.js looks for
CallConvs defines the calling convention (cdecl for most platforms)
nint is the native-sized integer equivalent to intptr_t

3. Resolve N-API Functions Dynamically

N-API functions are exported by node.exe itself. We need to resolve them at runtime:

private static void Initialize()
{
    NativeLibrary.SetDllImportResolver(
        Assembly.GetExecutingAssembly(),
        ResolveDllImport);

    static nint ResolveDllImport(
        string libraryName,
        Assembly assembly,
        DllImportSearchPath? searchPath)
    {
        if (libraryName is not "node")
            return 0;

        // Resolve from the host process (Node.js)
        return NativeLibrary.GetMainProgramHandle();
    }
}

4. Define N-API Function Imports

Use LibraryImport (source-generated P/Invoke) for better performance:

private static partial class NativeMethods
{
    [LibraryImport("node", EntryPoint = "napi_create_string_utf8")]
    internal static partial Status CreateStringUtf8(
        nint env, ReadOnlySpan<byte> str, nuint length, out nint result);

    [LibraryImport("node", EntryPoint = "napi_create_function")]
    internal static unsafe partial Status CreateFunction(
        nint env, ReadOnlySpan<byte> utf8name, nuint length,
        delegate* unmanaged[Cdecl]<nint, nint, nint> cb,
        nint data, out nint result);

    [LibraryImport("node", EntryPoint = "napi_get_cb_info")]
    internal static unsafe partial Status GetCallbackInfo(
        nint env, nint cbinfo, ref nuint argc,
        Span<nint> argv, nint* thisArg, nint* data);
}

Why LibraryImport?

Source-generated (faster than reflection-based DllImport)
Trimming-compatible out of the box
Better error messages at compile time

5. Marshal Strings Between JavaScript and C

N-API uses UTF-8 strings. Here's how to read a string argument from JavaScript:

private static unsafe string? GetStringArg(nint env, nint cbinfo, int index)
{
    nuint argc = (nuint)(index + 1);
    Span<nint> argv = stackalloc nint[index + 1];
    NativeMethods.GetCallbackInfo(env, cbinfo, ref argc, argv, null, null);

    if ((int)argc <= index)
        return null;

    // Get the UTF-8 byte length
    NativeMethods.GetValueStringUtf8(env, argv[index], null, 0, out nuint len);

    // Allocate buffer (stack for small, pool for large)
    int bufLen = (int)len + 1;
    byte[]? rented = null;
    Span<byte> buf = bufLen <= 512
        ? stackalloc byte[bufLen]
        : (rented = ArrayPool<byte>.Shared.Rent(bufLen));

    try
    {
        fixed (byte* pBuf = buf)
            NativeMethods.GetValueStringUtf8(env, argv[index], pBuf, len + 1, out _);

        return Encoding.UTF8.GetString(buf[..(int)len)]);
    }
    finally
    {
        if (rented is not null)
            ArrayPool<byte>.Shared.Return(rented);
    }
}

Performance optimizations:

stackalloc for small strings (< 512 bytes) - zero heap allocation
ArrayPool for larger strings - reusable buffers
Span<T> for memory-safe operations
No unnecessary string conversions

6. Implement Your Exported Function

With the plumbing in place, implementing actual functionality is straightforward:

[UnmanagedCallersOnly(CallConvs = [typeof(CallConvCdecl)])]
private static nint ReadStringValue(nint env, nint info)
{
    try
    {
        var keyPath = GetStringArg(env, info, 0);
        var valueName = GetStringArg(env, info, 1);

        if (keyPath is null || valueName is null)
        {
            ThrowError(env, "Expected two string arguments: keyPath, valueName");
            return 0;
        }

        // Your .NET logic here
        using var key = RegistryKey.OpenBaseKey(
            keyPath, RegistryHive.LocalMachine, RegistryView.Registry64);

        return key?.GetValue(valueName) is string value
            ? CreateString(env, value)
            : GetUndefined(env);
    }
    catch (Exception ex)
    {
        // CRITICAL: Always handle exceptions to avoid crashing Node.js
        ThrowError(env, $"Registry read failed: {ex.Message}");
        return 0;
    }
}

Important: Exception handling is critical! Unhandled exceptions in UnmanagedCallersOnly methods will crash the Node.js process.

7. Call from TypeScript

Build your project and rename the output:

dotnet publish -c Release -r win-x64
# Result: RegistryAddon.dll
# Rename to: RegistryAddon.node

Then use it in TypeScript:

// Define the interface
interface RegistryAddon {
    readStringValue(keyPath: string, valueName: string): string | undefined;
}

// Load the native module
const registry = require('./native/win32-x64/RegistryAddon.node') as RegistryAddon;

// Call your C# function!
const sdkPath = registry.readStringValue(
    'SOFTWARE\\dotnet\\Setup\\InstalledVersions\\x64\\sdk',
    'InstallLocation');

console.log('SDK Path:', sdkPath);

Performance Comparison

According to Microsoft's C# Dev Kit team, the .NET Native AOT approach:

Metric	C++ Addon	.NET Native AOT	Difference
Memory	Lower	Slightly higher	Negligible in long-running processes
Startup	Instant	Fast (AOT compiled)	Minimal
Performance	Baseline	Comparable	No meaningful difference
Binary Size	Smaller	Larger	Tradeoff for tool simplicity

Key insight: For typical addon workloads (string marshalling, registry access), performance is essentially identical. The GC overhead is negligible in long-running processes like VS Code extensions.

Real-World Benefits

Simplified Development

Before (C++ with node-gyp):

Requirements: C++, Python 2.x, node-gyp, platform-specific build tools

After (C# with Native AOT):

Requirements: .NET SDK, Node.js

Cross-Platform Support

The same C# code works on Windows, Linux, and macOS. Build once, deploy everywhere:

# Windows
dotnet publish -r win-x64

# Linux
dotnet publish -r linux-x64

# macOS
dotnet publish -r osx-x64

Modern Language Features

Get access to the full .NET ecosystem:

Async/await for I/O operations
LINQ for data processing
Records and pattern matching
Strong typing and IntelliSense
Comprehensive error handling

Common Pitfalls

1. Exception Handling

Problem: Unhandled exceptions crash Node.js
Solution: Always wrap logic in try-catch, forward errors to JavaScript

2. String Encoding

Problem: Encoding issues, buffer overruns
Solution: Use UTF-8 consistently, proper buffer sizing

3. Function Pointers

Problem: C# delegates don't work with N-API callbacks
Solution: Use delegate* unmanaged[Cdecl]<...> syntax

4. Threading

Problem: N-API functions must be called from Node.js main thread
Solution: Keep addon single-threaded, use async patterns if needed

5. Memory Leaks

Problem: Forgetting to return ArrayPool buffers
Solution: Use try-finally blocks

When to Use This Approach

✅ Great For:

Cross-platform Node.js tools
Performance-critical operations
Teams with .NET expertise
Replacing Python dependencies
Consolidating toolchains

❌ Not Ideal For:

Very simple addons (use JavaScript instead)
Addons requiring extensive Node.js API surface
Projects where C++ expertise is readily available
Extremely memory-constrained environments

Getting Started

Prerequisites

.NET 10 SDK (or .NET 11 Preview)
Node.js 18+ (LTS version)
Basic C# and Node.js knowledge

Project Template

# Create new console app
dotnet new console -n MyNodeAddon

# Edit .csproj to add:
# <PublishAot>true</PublishAot>
# <AllowUnsafeBlocks>true</AllowUnsafeBlocks>

Publishing

# Build for target platform
dotnet publish -c Release -r win-x64

# Rename output for Node.js
mv bin/Release/net10.0/win-x64/publish/MyNodeAddon.dll \
   bin/Release/net10.0/win-x64/publish/MyNodeAddon.node

Conclusion

.NET Native AOT opens an exciting new frontier for Node.js addon development. By leveraging N-API's language-agnostic design, you can write native addons in C# while enjoying:

✅ Simpler toolchain (no Python dependency)
✅ Modern language features
✅ Cross-platform compatibility
✅ Comparable performance to C++

The Microsoft C# Dev Kit team has proven this approach works in production. Whether you're building developer tools, performance-critical operations, or just want to unify your tech stack, .NET Native AOT for Node.js addons is worth serious consideration.

Resources

This post is based on the official Microsoft announcement from April 15, 2026, written by Drew Noakes, Principal Software Engineer at Microsoft.

Follow me on LinkedIn for more .NET and JavaScript content!

Introducing WebhookRelay: A Modern .NET Open Source Webhook Management Platform

Vikrant Bagal — Thu, 23 Apr 2026 20:54:09 +0000

Building a webhook relay infrastructure with ASP.NET Core 8 and React 19

Introduction

I'm excited to announce WebhookRelay — a self-hosted, open-source webhook management platform built specifically for the (beta) .NET ecosystem. After years of working with webhook integrations and seeing the limitations of existing solutions, I set out to create a modern, alternative that leverages the latest .NET technologies while providing complete control and flexibility.

The Problem with Webhooks

Webhooks are the backbone of modern integrations, but managing them at scale presents several challenges:

Signature Verification: Each provider (Stripe, GitHub, Twilio) uses different HMAC algorithms
Reliability: Network failures require intelligent retry mechanisms
Observability: Debugging failed webhooks can be time-consuming
Multi-System Coordination: Fan-out to multiple targets with routing rules
Vendor Lock-in: Commercial solutions can be expensive and inflexible

The Solution: WebhookRelay

WebhookRelay addresses these challenges with a comprehensive feature set:

Core Features

✅ Multi-Provider Ingestion

Stripe: Automatic signature verification via Stripe-Signature header
GitHub: X-Hub-Signature-256 verification out of the box
Twilio: Built-in support for Twilio webhooks
Generic: Custom HMAC-SHA256 verification for any provider

✅ Security First

Constant-time HMAC comparison to prevent timing attacks
Complete audit log of all inbound requests (including rejected events)
Per-endpoint secret management

✅ Intelligent Delivery

Fan-out: Forward one webhook to multiple target URLs simultaneously
Routing Rules: JSON path conditions (equals, contains, starts_with, exists, etc.)
Automatic Retries: Exponential backoff with configurable max attempts
Dead-letter Queue: Failed events stored for manual inspection

✅ Event Management

Duplicate Detection: Provider event IDs deduplicated per endpoint
Event Replay: Re-deliver any stored event on demand
Real-time Dashboard: Live updates via SignalR with syntax-highlighted payloads

Technology Stack

WebhookRelay leverages cutting-edge .NET and frontend technologies:

Backend

ASP.NET Core 8 Web API
Entity Framework Core 8 for data access
System.Threading.Channels for high-performance in-process queuing
Serilog for structured logging

Frontend

React 19 with Vite 8
TypeScript for type safety
shadcn/ui + Tailwind CSS for modern UI
TanStack Query v5 for server state management
React Router v7 for navigation
React Hook Form + Zod for forms

Real-time Features

ASP.NET Core SignalR for live dashboard updates
WebSocket connections for instant event notifications

Architecture Overview

Clean Architecture

WebhookRelay.sln
├── src/
│   ├── WebhookRelay.Api/          # ASP.NET Core Web API + background workers
│   ├── WebhookRelay.Core/         # Domain entities, interfaces (no external deps)
│   ├── WebhookRelay.Infrastructure/ # EF Core, HTTP delivery, verifiers
│   └── WebhookRelay.Shared/       # DTOs shared between API and frontend
├── dashboard/                      # React 19 frontend
├── tests/                          # Comprehensive test suite
└── deploy/                         # Docker Compose deployment

Data Flow

Ingest: Webhook received at /webhooks/:endpointId
Verify: HMAC signature validation per provider
Store: Event persisted to database with full payload
Route: Apply routing rules to determine target endpoints
Deliver: Fan-out to multiple targets with retry logic
Monitor: Real-time dashboard updates via SignalR

Getting Started

Prerequisites

.NET 8 SDK
Node.js 22+

Quick Start

# Clone the repository
git clone https://github.com/vrbagal/webhook-relay.git
cd webhook-relay

# Start the API (uses SQLite by default)
cd src/WebhookRelay.Api
dotnet run
# API available at https://localhost:5001

# Start the dashboard
cd dashboard
npm install
npm run dev
# Dashboard available at http://localhost:3000

Configuration

The project supports multiple databases out of the box:

SQLite (Default - Zero Config)

{
  "DatabaseProvider": "Sqlite",
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=webhookrelay.db"
  }
}

SQL Server

{
  "DatabaseProvider": "SqlServer",
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=WebhookRelay;Trusted_Connection=True;"
  }
}

PostgreSQL

{
  "DatabaseProvider": "PostgreSQL",
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=webhookrelay;Username=postgres;Password=yourpassword"
  }
}

Docker Deployment

cd deploy
docker compose up --build

Services started:

api: ASP.NET Core API on port 5000
dashboard: React app served via nginx on port 80
db: SQL Server 2022 (when using SqlServer profile)

Using WebhookRelay

Sending Webhooks

# Compute signature
SECRET="your-signing-secret"
PAYLOAD='{"event":"payment.completed","amount":100}'
SIG=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$SECRET" | awk '{print $2}')

# Send webhook
curl -X POST https://localhost:5001/webhooks/<endpoint-id> \
  -H "Content-Type: application/json" \
  -H "x-webhook-signature: sha256=$SIG" \
  -H "x-webhook-event: payment.completed" \
  -H "x-webhook-id: evt-$(date +%s)" \
  -d "$PAYLOAD"

Provider-Specific Sending

Stripe: Just send the original Stripe webhook — it's automatically verified
GitHub: Send as-is — the X-Hub-Signature-256 header is verified automatically

API Endpoints

Endpoint Management

Method	Path	Description
GET	`/api/endpoints`	List all endpoints
POST	`/api/endpoints`	Create endpoint
GET	`/api/endpoints/:id`	Get endpoint details
PUT	`/api/endpoints/:id`	Update endpoint
DELETE	`/api/endpoints/:id`	Delete endpoint

Target Management

Method	Path	Description
POST	`/api/endpoints/:id/targets`	Add delivery target
DELETE	`/api/endpoints/:id/targets/:targetId`	Remove target

Event Management

Method	Path	Description
GET	`/api/events`	List events (paginated, filterable)
GET	`/api/events/:id`	Get event with delivery attempts
POST	`/api/events/:id/replay`	Replay event

Real-World Use Cases

E-commerce Integration

// Stripe webhook handler with routing rules
{
  "endpoint": "stripe-payments",
  "targets": [
    {
      "url": "https://api.myapp.com/payments",
      "rules": [{ "path": "$.type", "operator": "equals", "value": "payment_intent.succeeded" }]
    },
    {
      "url": "https://analytics.myapp.com/events",
      "rules": [{ "path": "$.type", "operator": "contains", "value": "payment" }]
    }
  ]
}

GitHub Automation

// GitHub webhook fan-out for CI/CD
{
  "endpoint": "github-repo",
  "targets": [
    { "url": "https://ci.example.com/webhook" },
    { "url": "https://notifications.example.com/github" },
    { "url": "https://analytics.example.com/events" }
  ]
}

Multi-System Coordination

CRM Integration: Forward webhooks to Salesforce, HubSpot, and custom systems
Notification Systems: Send to Slack, email, and SMS simultaneously
Analytics: Route events to multiple analytics platforms

Dashboard Features

The React dashboard provides comprehensive webhook management:

Real-time Monitoring: Live updates via SignalR
Payload Inspection: Syntax-highlighted JSON viewing
Event Replay: One-click re-delivery of failed events
Endpoint Management: Create, update, delete endpoints and targets
Routing Rules: Visual rule builder with JSON path support
Delivery Analytics: Success/failure rates and retry statistics

Performance & Scalability

In-Process Queue

WebhookRelay uses System.Threading.Channels for high-performance, in-process queueing:

Zero external dependencies
Excellent performance characteristics
Built-in backpressure handling

Database Flexibility

SQLite: Perfect for development and small deployments
SQL Server: Enterprise-grade with full transaction support
PostgreSQL: Open-source with advanced features

Deployment Options

Self-hosted: Complete control on your infrastructure
Docker: Easy containerization and orchestration
Cloud: Deploy to Azure, AWS, or any cloud provider

Security Considerations

HMAC Verification

Each provider's signature algorithm is implemented exactly:

Stripe: Stripe-Signature header with timestamp and signature
GitHub: X-Hub-Signature-256 with HMAC-SHA256
Generic: Custom x-webhook-signature header

Constant-Time Comparison

All signature verifications use constant-time comparison to prevent timing attacks.

Secret Management

Per-endpoint secret configuration
Environment variable support
Azure Key Vault integration ready

Testing Strategy

Unit Tests

Core business logic
Signature verification algorithms
Routing rule evaluation

Integration Tests

API endpoints with WebApplicationFactory
Database operations
External HTTP delivery

End-to-End Tests

Full webhook flow from ingestion to delivery
Dashboard functionality
Docker deployment

Future Roadmap

Immediate (v1.1)

[ ] Enhanced documentation with tutorials
[ ] SDK for popular languages (Python, Node.js, Go)
[ ] Plugin system for custom providers
[ ] Advanced analytics and reporting

Medium-term (v1.2)

[ ] Multi-tenancy support
[ ] Webhook transformation (modify payload before delivery)
[ ] Advanced routing with regex support
[ ] Rate limiting per endpoint

Long-term (v2.0)

[ ] Managed cloud service option
[ ] Marketplace for pre-built integrations
[ ] Enterprise features (SSO, audit logs, SLA)
[ ] Machine learning for anomaly detection

Contributing

WebhookRelay is an open-source project and welcomes contributions:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Areas for Contribution

Documentation: Tutorials, API docs, deployment guides
Testing: Unit tests, integration tests, E2E tests
Features: New providers, advanced routing, analytics
UI/UX: Dashboard improvements, accessibility

Conclusion

WebhookRelay represents a modern approach to webhook management, built from the ground up for .NET developers who want complete control over their integration infrastructure. Whether you're building a multi-tenant SaaS application, integrating multiple payment providers, or coordinating complex business workflows, WebhookRelay provides the foundation you need.

Key Takeaways

Modern Stack: ASP.NET Core 8, React 19, latest technologies
Self-Hosted: Complete control without vendor lock-in
Open Source: MIT license, community-driven development

Next Steps

Try it out: Clone the repo and run locally
Star the project: Show support on GitHub
Contribute: Help build the future of webhook management
Share: Spread the word in .NET communities

Ready to get started? Visit the GitHub repository and start managing your webhooks like a pro!

For more .NET development content, follow me on LinkedIn.

Built with ❤️ by Vikrant Bagal

.NET 10 AI Integration: From Zero to Hero

Vikrant Bagal — Thu, 23 Apr 2026 14:03:31 +0000

Building Intelligent Applications with Microsoft's Latest AI Stack

Introduction

The release of .NET 10 marks a paradigm shift in how we build intelligent applications. With native AI integration, unified abstractions, and production-ready frameworks, .NET 10 makes AI development more accessible than ever. This comprehensive guide will take you from zero knowledge to building production-ready AI-powered .NET applications.

Why .NET 10 for AI Development?

The AI Revolution in .NET

.NET 10 isn't just another framework update—it's a fundamental reimagining of how AI integrates into the development workflow. Here's why it matters:

Native AI Support: Built-in AI capabilities without external dependencies
Performance Excellence: 3-year LTS with enterprise-grade stability
Unified Abstraction: Single API surface for multiple AI providers
C# 14 Features: Extension members and modern syntax for cleaner AI code

Key Statistics

478,000+ NuGet packages available
800+ billion package downloads
9,700+ stars on Microsoft Agent Framework
26M+ monthly downloads on AI SDK

The .NET 10 AI Stack

Core Components

1. Microsoft.Extensions.AI

The foundation of AI integration in .NET 10, providing:

// Unified AI service abstraction
public interface IChatClient
{
    Task<ChatResponse> GetResponseAsync(
        string message, 
        ChatOptions? options = null);
}

Key Features:

Multi-provider support (Azure OpenAI, OpenAI, GitHub Models)
Middleware pipeline for cross-cutting concerns
Streaming responses for real-time applications
Function calling and tool execution

2. Microsoft Agent Framework

Build sophisticated multi-agent workflows:

// Define specialized agents
var analystAgent = new ChatAgent(
    "Data Analyst", 
    "Analyze trends and generate insights");

var writerAgent = new ChatAgent(
    "Content Writer", 
    "Create engaging technical content");

// Orchestrate collaboration
var workflow = new AgentWorkflow()
    .AddAgent(analystAgent)
    .AddAgent(writerAgent)
    .Build();

Capabilities:

Agent orchestration and collaboration
State management and persistence
Tool integration and function calling
Cloud-native deployment patterns

3. Semantic Kernel Integration

Bridge between LLMs and application logic:

// Create kernel with GitHub Models
var kernel = new KernelBuilder()
    .WithGitHubModelsChatCompletion("gpt-4")
    .WithPluginsFromType<CalculatorPlugin>()
    .Build();

// Use natural language to call functions
var result = await kernel.InvokeAsync(
    "Calculate the compound interest for $10,000 at 5% for 10 years");

Step-by-Step Implementation Guide

Step 1: Setting Up Your Project

Basic Project Structure

dotnet new console -n AIIntegrationDemo
cd AIIntegrationDemo

Add Required NuGet Packages

dotnet add package Microsoft.Extensions.AI
dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Step 2: Configuring AI Services

Using GitHub Models (Free Tier)

// Program.cs
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.AI;

var builder = WebApplication.CreateBuilder(args);

// Add GitHub Models configuration
builder.Services.AddGitHubModelsChatClient(
    builder.Configuration["GitHub:Token"],
    "gpt-4"
);

// Add AI chat service
builder.Services.AddChatClient();

var app = builder.Build();

Using Azure OpenAI (Production)

// appsettings.json
{
  "AzureOpenAI": {
    "Endpoint": "https://your-resource.openai.azure.com/",
    "ApiKey": "your-api-key",
    "DeploymentName": "gpt-4"
  }
}

// Program.cs
builder.Services.AddAzureOpenAIChatClient(
    configuration["AzureOpenAI:Endpoint"],
    configuration["AzureOpenAI:ApiKey"],
    configuration["AzureOpenAI:DeploymentName"]
);

Step 3: Building Your First AI Application

Simple Chat Interface

public class ChatService
{
    private readonly IChatClient _chatClient;

    public ChatService(IChatClient chatClient)
    {
        _chatClient = chatClient;
    }

    public async Task<string> GetResponseAsync(string userMessage)
    {
        var response = await _chatClient.GetResponseAsync(userMessage);
        return response.Message.Text;
    }
}

// Usage in API controller
[ApiController]
[Route("api/[controller]")]
public class ChatController : ControllerBase
{
    private readonly ChatService _chatService;

    public ChatController(ChatService chatService)
    {
        _chatService = chatService;
    }

    [HttpPost]
    public async Task<IActionResult> Chat([FromBody] ChatRequest request)
    {
        var response = await _chatService.GetResponseAsync(request.Message);
        return Ok(new { response });
    }
}

Step 4: Advanced Features

Function Calling with AI

// Define available functions
public class WeatherPlugin
{
    [KernelFunction]
    public async Task<string> GetWeatherAsync(string location)
    {
        // Implement weather API call
        return await WeatherService.GetForecast(location);
    }
}

// Register with Semantic Kernel
var kernel = new KernelBuilder()
    .WithPluginsFromType<WeatherPlugin>()
    .Build();

// AI will automatically call the function when needed
var result = await kernel.InvokeAsync(
    "What's the weather in New York tomorrow?");

Multi-Agent Workflows

// Define agent collaboration
public class ResearchAgent
{
    public async Task<ResearchResult> AnalyzeTopicAsync(string topic)
    {
        // Research and gather information
        return await ResearchService.AnalyzeAsync(topic);
    }
}

public class WritingAgent
{
    public async Task<string> WriteArticleAsync(ResearchResult research)
    {
        // Generate content based on research
        return await ContentGenerator.CreateAsync(research);
    }
}

// Orchestrate the workflow
public class BlogGenerationWorkflow
{
    public async Task<string> GenerateBlogPostAsync(string topic)
    {
        var research = await _researchAgent.AnalyzeTopicAsync(topic);
        var article = await _writingAgent.WriteArticleAsync(research);
        return article;
    }
}

Real-World Applications

1. Intelligent Customer Support

public class CustomerSupportAgent
{
    private readonly IChatClient _chatClient;
    private readonly KnowledgeBase _knowledgeBase;

    public async Task<string> HandleQueryAsync(string query)
    {
        // Search knowledge base
        var context = await _knowledgeBase.SearchAsync(query);

        // Generate response with context
        var prompt = $@"
            Based on this knowledge: {context}
            Respond to this customer query: {query}
        ";

        return await _chatClient.GetResponseAsync(prompt);
    }
}

2. Code Generation and Review

public class CodeAssistant
{
    public async Task<string> GenerateCodeAsync(string description)
    {
        var prompt = $@"
            Write C# code for: {description}
            Follow .NET 10 best practices
            Include error handling and logging
        ";

        return await _chatClient.GetResponseAsync(prompt);
    }

    public async Task<List<CodeIssue>> ReviewCodeAsync(string code)
    {
        var prompt = $@"
            Review this C# code for:
            - Security vulnerabilities
            - Performance issues
            - Best practices violations
            - Code smells

            Code to review:
            {code}
        ";

        var response = await _chatClient.GetResponseAsync(prompt);
        return ParseIssues(response);
    }
}

3. Data Analysis and Reporting

public class DataAnalysisAgent
{
    public async Task<AnalysisResult> AnalyzeDataAsync(
        string data, 
        string analysisType)
    {
        var prompt = $@"
            Analyze this data using {analysisType}:
            {data}

            Provide:
            1. Key insights
            2. Trends and patterns
            3. Recommendations
            4. Visualizations description
        ";

        var response = await _chatClient.GetResponseAsync(prompt);
        return ParseAnalysisResult(response);
    }
}

Performance Optimization

.NET 10 Performance Features

JIT Compiler Enhancements

Better Inlining: Automatic method inlining for small functions
Method Devirtualization: Eliminates virtual call overhead
Struct Optimization: Improved argument passing for value types

Hardware Acceleration

// .NET 10 automatically uses AVX10.2 when available
public class VectorOperations
{
    public float[] ProcessVector(float[] data)
    {
        // SIMD-optimized operations
        return Vector.IsHardwareAccelerated 
            ? ProcessWithSimd(data) 
            : ProcessScalar(data);
    }
}

NativeAOT for AI Workloads

<PropertyGroup>
  <PublishAot>true</PublishAot>
  <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
</PropertyGroup>

AI Service Optimization

Streaming Responses

public async IAsyncEnumerable<string> StreamResponseAsync(
    string prompt, 
    [EnumeratorCancellation] CancellationToken cancellationToken)
{
    await foreach (var chunk in _chatClient.StreamResponseAsync(prompt, cancellationToken))
    {
        yield return chunk.Text;
    }
}

Caching Strategies

public class CachedChatService
{
    private readonly IMemoryCache _cache;
    private readonly IChatClient _chatClient;

    public async Task<string> GetCachedResponseAsync(string prompt)
    {
        var cacheKey = $"chat:{prompt.GetHashCode()}";

        return await _cache.GetOrCreateAsync(cacheKey, async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1);
            return await _chatClient.GetResponseAsync(prompt);
        });
    }
}

Security Best Practices

1. Secrets Management

// Use user secrets in development
builder.Configuration.AddUserSecrets<Program>();

// Use Azure Key Vault in production
builder.Configuration.AddAzureKeyVault(
    new Uri("https://your-keyvault.vault.azure.net/"),
    new DefaultAzureCredential());

2. Rate Limiting

public class RateLimitedChatService
{
    private readonly IChatClient _chatClient;
    private readonly SemaphoreSlim _rateLimiter = new(10, 10);

    public async Task<string> GetResponseAsync(string prompt)
    {
        await _rateLimiter.WaitAsync();
        try
        {
            return await _chatClient.GetResponseAsync(prompt);
        }
        finally
        {
            _rateLimiter.Release();
        }
    }
}

3. Content Validation

public class SafeChatService
{
    public async Task<string> GetSafeResponseAsync(string prompt)
    {
        var response = await _chatClient.GetResponseAsync(prompt);

        // Validate response
        if (ContainsSensitiveInformation(response))
        {
            throw new SecurityException("Response contains sensitive data");
        }

        return response;
    }
}

Production Deployment

Containerization

FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app

FROM base AS final
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "YourAIApp.dll"]

Azure Deployment

# Create Azure App Service
az webapp create --resource-group myResourceGroup --plan myPlan --name myAIApp

# Configure environment variables
az webapp config appsettings set \
  --resource-group myResourceGroup \
  --name myAIApp \
  --settings AzureOpenAI:Endpoint="$ENDPOINT" AzureOpenAI:ApiKey="$API_KEY"

Monitoring and Observability

Application Insights Integration

builder.Services.AddApplicationInsightsTelemetry();

public class MonitoredChatService
{
    private readonly TelemetryClient _telemetryClient;

    public async Task<string> GetResponseAsync(string prompt)
    {
        using var operation = _telemetryClient.StartOperation<RequestTelemetry>("ChatRequest");

        try
        {
            var response = await _chatClient.GetResponseAsync(prompt);
            operation.Telemetry.Success = true;
            return response;
        }
        catch (Exception ex)
        {
            _telemetryClient.TrackException(ex);
            throw;
        }
    }
}

AI-Specific Metrics

public class AIMetricsCollector
{
    public void TrackAIInteraction(
        string model, 
        int tokensUsed, 
        TimeSpan latency)
    {
        // Track AI usage metrics
        _metrics.RecordGauge("ai.tokens.used", tokensUsed);
        _metrics.RecordHistogram("ai.latency.ms", latency.TotalMilliseconds);
        _metrics.RecordCounter("ai.requests.total", 1);
    }
}

Future-Proofing Your AI Applications

1. Provider Abstraction

public interface IAIProvider
{
    Task<string> CompleteAsync(string prompt);
    IAsyncEnumerable<string> StreamCompleteAsync(string prompt);
}

public class MultiProviderChatService
{
    private readonly IEnumerable<IAIProvider> _providers;

    public async Task<string> GetResponseAsync(string prompt)
    {
        // Fallback to different providers
        foreach (var provider in _providers)
        {
            try
            {
                return await provider.CompleteAsync(prompt);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Provider {Provider} failed", provider.GetType().Name);
            }
        }

        throw new InvalidOperationException("All AI providers failed");
    }
}

2. Model Versioning

public class VersionedAIChatService
{
    public async Task<string> GetResponseAsync(
        string prompt, 
        string modelVersion = "latest")
    {
        var model = _modelRegistry.GetModel(modelVersion);
        return await model.CompleteAsync(prompt);
    }
}

Conclusion

.NET 10 represents a massive leap forward for AI development in the .NET ecosystem. With native AI integration, unified abstractions, and production-ready frameworks, developers can build sophisticated AI-powered applications with unprecedented ease and reliability.

Key Takeaways

Start Simple: Begin with basic chat completion, then add complexity
Use the Right Tools: Microsoft.Extensions.AI for abstractions, Agent Framework for workflows
Think Production: Implement security, monitoring, and optimization from day one
Stay Updated: The AI landscape evolves rapidly—keep learning

Next Steps

Experiment: Try the GitHub Models integration (free tier)
Build: Create a small AI application using the patterns above
Deploy: Containerize and deploy to Azure or your preferred cloud
Share: Contribute back to the .NET AI community

Ready to start building? Clone the sample repository and begin your AI journey with .NET 10 today!

For more .NET and AI content, follow me on LinkedIn and check out the official Microsoft .NET AI documentation.

This article was written with the assistance of AI tools running on .NET 10.

.NET ORM Options & Best Practices for 2026: EF Core vs Dapper vs Hybrid Approaches

Vikrant Bagal — Mon, 20 Apr 2026 15:05:08 +0000

Choosing the right ORM (Object-Relational Mapping) for your .NET application is one of the most critical architectural decisions you'll make. In 2026, the landscape has evolved significantly, with Entity Framework Core becoming the de facto standard while Dapper remains the performance champion for specific scenarios. This comprehensive guide will help you navigate the options and choose the right tool for your project.

The ORM Landscape in 2026

The debate between EF Core and Dapper has matured significantly. While EF Core has become the default choice for most .NET teams, Dapper continues to excel in high-performance scenarios. Let's explore when to use each, and why hybrid approaches are gaining popularity.

1. Entity Framework Core (EF Core)

Why EF Core is the Default Choice in 2026

Microsoft's EF Core has evolved into a robust, feature-rich ORM that addresses most common data access needs. Here's why it's become the default:

Key Strengths:

Full ORM Feature Set: Change tracking, migrations, LINQ queries
Developer Productivity: Rapid development with less boilerplate
Cross-Database Support: SQL Server, PostgreSQL, SQLite, MySQL, Cosmos DB
Strong Ecosystem: Extensive documentation and community support
Microsoft Backing: First-class integration with .NET ecosystem

EF Core Best Practices 2026

1. Use AsNoTracking() for Read-Only Operations

// ❌ Overkill for read-only operations
var users = await context.Users
    .Where(u => u.IsActive)
    .ToListAsync();

// ✅ Better for read-only operations
var users = await context.Users
    .Where(u => u.IsActive)
    .AsNoTracking()
    .ToListAsync();

Impact: Reduces memory usage by 30-50% and eliminates change tracking overhead.

2. Master Query Projection

Instead of loading entire entities, project only the data you need:

// ❌ Loading entire User entities
var users = await context.Users
    .Where(u => u.IsActive)
    .ToListAsync();

// ✅ Projection to DTO
var userDtos = await context.Users
    .Where(u => u.IsActive)
    .Select(u => new UserDto
    {
        Id = u.Id,
        Name = u.Name,
        Email = u.Email
    })
    .ToListAsync();

Benefit: Significantly reduces data transfer and memory usage.

3. Avoid the N+1 Query Problem

The Problem:

// ❌ N+1 queries - one query per user
var orders = await context.Orders.ToListAsync();
foreach (var order in orders)
{
    // This triggers a new query for EACH order
    var customer = order.Customer; // N+1!
}

The Solution:

// ✅ Eager loading - single query
var orders = await context.Orders
    .Include(o => o.Customer)
    .ToListAsync();

4. Leverage Bulk Operations (EF Core 7+)

// ✅ Efficient bulk updates
await context.Users
    .Where(u => u.IsActive == false)
    .ExecuteUpdateAsync(s => s
        .SetProperty(u => u.LastLogin, DateTime.UtcNow)
    );

// ✅ Efficient bulk deletes
await context.Products
    .Where(p => p.IsDiscontinued)
    .ExecuteDeleteAsync();

Performance Gain: 10-100x faster than traditional approaches for large datasets.

5. Use DbContext Pooling

// ✅ In Program.cs
builder.Services.AddDbContextPool<AppDbContext>(options =>
    options.UseSqlServer(connectionString));

Impact: Reduces connection overhead by reusing DbContext instances.

Common EF Core Pitfalls to Avoid in 2026

Over-fetching Data: Always use projection when possible
Missing Indexes: Profile queries and add appropriate indexes
Not Using Async: Always prefer async/await for scalability
Ignoring Change Tracking: Use AsNoTracking() for read-only scenarios
Lazy Loading in Loops: Eager load relationships when needed

Performance Optimization Tips

Recent benchmarks show EF Core performance has dramatically improved:

Before Optimization:

Query time: 2.3 seconds
Memory usage: High

After Optimization:

Query time: 120ms (19x improvement)
Memory usage: Optimized

Key Optimizations:

Use AsNoTracking() for reads
Implement proper query projection
Add strategic indexes
Use compiled queries for hot paths
Implement connection pooling

2. Dapper (Micro-ORM)

When Dapper Shines in 2026

Dapper remains the performance champion for specific scenarios:

Use Dapper When:

Maximum SQL control is required
Complex queries with custom SQL
Stored procedures are heavily used
Minimal overhead is critical
Performance is the top priority

Dapper Best Practices 2026

1. Proper Connection Management

// ✅ Using DI for connection management
public class UserRepository : IUserRepository
{
    private readonly IDbConnection _connection;

    public UserRepository(IDbConnection connection)
    {
        _connection = connection;
    }

    public async Task<IEnumerable<User>> GetActiveUsersAsync()
    {
        return await _connection.QueryAsync<User>(
            "SELECT * FROM Users WHERE IsActive = @IsActive",
            new { IsActive = true });
    }
}

2. Parameterization is Mandatory

// ❌ SQL Injection risk
var query = $"SELECT * FROM Users WHERE Name = '{name}'";

// ✅ Safe parameterization
var users = await connection.QueryAsync<User>(
    "SELECT * FROM Users WHERE Name = @Name",
    new { Name = name });

3. Async Everywhere

// ✅ Async operations
public async Task<User> GetUserByIdAsync(int id)
{
    return await connection.QuerySingleOrDefaultAsync<User>(
        "SELECT * FROM Users WHERE Id = @Id",
        new { Id = id });
}

4. Repository Pattern with Dapper

public class OrderRepository : IOrderRepository
{
    private readonly IDbConnection _connection;

    public async Task<OrderDetails> GetOrderDetailsAsync(int orderId)
    {
        var sql = @"
            SELECT o.*, c.Name as CustomerName, c.Email
            FROM Orders o
            JOIN Customers c ON o.CustomerId = c.Id
            WHERE o.Id = @OrderId";

        return await _connection.QuerySingleOrDefaultAsync<OrderDetails>(
            sql, new { OrderId = orderId });
    }
}

Performance Optimizations

Connection Pooling: Configure in DI container
Query Caching: Cache frequently used query results
Batch Operations: Use QueryMultipleAsync for multiple queries
Proper Indexing: Database-level optimization
Async Operations: Use async/await throughout

3. Hybrid Approach (EF Core + Dapper)

Why Hybrid in 2026?

The hybrid approach combines EF Core's productivity with Dapper's performance:

When to Use Hybrid:

Complex applications with mixed workloads
Gradual migration from legacy systems
Performance-critical reads with complex CRUD
Teams with varying expertise levels

Implementation Patterns

Pattern 1: EF Core for Writes, Dapper for Reads

public class ProductService
{
    private readonly AppDbContext _context;
    private readonly IDbConnection _connection;

    public async Task<ProductDto> GetProductAsync(int id)
    {
        // Dapper for complex, performance-critical reads
        var sql = @"
            SELECT p.*, c.Name as CategoryName
            FROM Products p
            JOIN Categories c ON p.CategoryId = c.Id
            WHERE p.Id = @Id";

        return await _connection.QuerySingleOrDefaultAsync<ProductDto>(
            sql, new { Id = id });
    }

    public async Task UpdateProductAsync(Product product)
    {
        // EF Core for change tracking and validation
        _context.Products.Update(product);
        await _context.SaveChangesAsync();
    }
}

Pattern 2: Stored Procedures with Dapper, Code-First with EF Core

public class ReportService
{
    private readonly IDbConnection _connection;

    public async Task<SalesReport> GetSalesReportAsync(DateTime startDate, DateTime endDate)
    {
        // Dapper for complex stored procedures
        return await _connection.QuerySingleOrDefaultAsync<SalesReport>(
            "sp_GetSalesReport",
            new { StartDate = startDate, EndDate = endDate },
            commandType: CommandType.StoredProcedure);
    }
}

4. Decision Framework: Which ORM to Choose in 2026?

Choose EF Core When:

✅ Team productivity is a priority
✅ You need LINQ queries
✅ Change tracking is essential
✅ Cross-database support is required
✅ Rapid development is needed

Choose Dapper When:

✅ Maximum performance is critical
✅ Complex SQL is required
✅ Stored procedures are heavily used
✅ You need minimal overhead
✅ Full SQL control is needed

Choose Hybrid When:

✅ Mixed workload patterns exist
✅ Performance-critical reads are needed
✅ Complex query requirements exist
✅ Gradual migration from legacy
✅ Team has diverse expertise

5. Performance Comparison 2026

Read Operations (10,000 records)

ORM	Query Time	Memory Usage	Development Speed
Dapper	50ms	Low	Moderate
EF Core (with AsNoTracking)	60ms	Moderate	Fast
EF Core (tracked)	80ms	Higher	Fast

Key Takeaways:

Dapper: Fastest raw performance
EF Core: Best development speed
Hybrid: Best balance for complex apps

6. ASP.NET Core Integration

EF Core Setup

// Program.cs
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

// Or with pooling for better performance
builder.Services.AddDbContextPool<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

Dapper Setup

// Program.cs
builder.Services.AddScoped<IDbConnection>(sp =>
    new SqlConnection(builder.Configuration.GetConnectionString("Default")));

Hybrid Setup

// Program.cs
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

builder.Services.AddScoped<IDbConnection>(sp =>
    new SqlConnection(builder.Configuration.GetConnectionString("Default")));

7. Testing Strategies

EF Core Testing

// In-memory provider for unit tests
services.AddDbContext<AppDbContext>(options =>
    options.UseInMemoryDatabase("TestDatabase"));

// Or SQLite in-memory for integration tests
services.AddDbContext<AppDbContext>(options =>
    options.UseSqlite("DataSource=:memory:"));

Dapper Testing

// Mock IDbConnection for unit tests
var mockConnection = new Mock<IDbConnection>();
mockConnection.Setup(c => c.QueryAsync<User>(It.IsAny<string>(), It.IsAny<object>()))
    .ReturnsAsync(new List<User> { new User { Id = 1, Name = "Test" } });

8. Real-World Scenarios

E-commerce Platform

EF Core: Product catalog, user management, order processing
Dapper: Complex reporting queries, analytics
Hybrid: Shopping cart operations (EF for writes, Dapper for reads)

SaaS Application

EF Core: User authentication, subscription management
Dapper: Dashboard analytics, usage reports
Hybrid: Billing operations

9. Migration Strategies

From Legacy to EF Core

Start with read-only operations using EF Core
Gradually add change tracking
Migrate complex queries to Dapper
Use hybrid approach during transition

From Dapper to EF Core

Identify CRUD operations suitable for EF Core
Migrate gradually, starting with simple operations
Keep complex queries in Dapper
Use hybrid approach long-term if beneficial

10. Future Trends in 2026

AI-assisted query optimization
Better compiled query performance
Source generators for EF Core
Improved async performance
Hybrid approach normalization

Conclusion

In 2026, the ORM landscape has matured significantly:

EF Core is the default choice for most .NET applications due to its productivity and feature set
Dapper remains essential for high-performance scenarios and complex SQL
Hybrid approaches offer the best of both worlds for complex applications

The performance gap between EF Core and Dapper has narrowed, making development productivity often outweigh raw performance. Choose based on your specific needs, team expertise, and performance requirements.

LinkedIn Profile: https://www.linkedin.com/in/vikrant-bagal

Tags: #dotnet #csharp #orm #efcore #dapper #database #performance #2026 #bestpractices

.NET Application Architectures: Complete Guide to Monolithic, Layered, Clean, and More

Vikrant Bagal — Fri, 17 Apr 2026 20:17:49 +0000

Choosing the right application architecture is one of the most critical decisions you'll make when building a .NET application. The architecture you choose will impact everything from development speed to long-term maintainability.

In this comprehensive guide, we'll explore the most popular .NET application architecture patterns, their pros and cons, and when to use each one.

Introduction

With .NET 10, developers have more options than ever for structuring their applications. Whether you're building a simple CRUD app or a complex enterprise system, understanding the different architecture patterns will help you make the right choice.

We'll cover:

Monolithic Architecture - The classic approach
Layered (N-Tier) Architecture - Traditional enterprise pattern
Clean/Onion Architecture - Domain-driven design approach
Vertical Slice Architecture - Feature-centric organization
Hexagonal Architecture - Ports and Adapters pattern

Let's dive in!

1. Monolithic Architecture

What Is It?

A monolithic application is entirely self-contained. All logic runs within a single process and the entire application is deployed as a single unit.

Key Characteristics

Single deployment unit (executable or single web application)
All code typically lives in one or more projects within the same solution
Horizontal scaling requires duplicating the entire application

When to Use It

Simple applications with limited complexity
Small to medium-sized projects
When deployment simplicity is prioritized
Small development teams

Pros

✅ Simple deployment and development
✅ Easy to debug and test
✅ Low operational overhead
✅ No network latency between components

Cons

❌ Tight coupling of components
❌ Difficult to scale individual components
❌ Technology lock-in
❌ Difficult to maintain as application grows

Implementation Example

MyApp/
├── Controllers/
│   └── ProductsController.cs
├── Models/
│   └── Product.cs
├── Views/
│   └── Products/
├── Services/
│   └── ProductService.cs
└── Data/
    └── ApplicationDbContext.cs

Best For

Simple CRUD applications, prototypes, and small projects where simplicity is more important than scalability.

2. Layered (N-Tier) Architecture

What Is It?

Traditional layered architecture organizes code into distinct layers, each with specific responsibilities. The most common organization is UI → Business Logic → Data Access.

Key Layers

Presentation Layer (UI) - Handles user interaction
Business Logic Layer (BLL) - Contains business rules and logic
Data Access Layer (DAL) - Handles data persistence

Key Characteristics

Top-down dependencies (UI → BLL → DAL)
Separation of concerns
Reusable components across layers

When to Use It

Enterprise applications with clear separation needs
When you need to enforce strict layer boundaries
When different teams work on different layers

Pros

✅ Clear separation of concerns
✅ Easier to understand and maintain
✅ Good for teams with different specialties
✅ Testable layers

Cons

❌ Top-down dependencies can create tight coupling
❌ Changes in lower layers affect upper layers
❌ Can lead to anemic domain model
❌ Difficult to test business logic without database

Implementation in .NET

// Data Access Layer - Repository Pattern
public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;

    public ProductRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<Product> GetByIdAsync(int id)
    {
        return await _context.Products.FindAsync(id);
    }
}

// Business Logic Layer
public class ProductService
{
    private readonly IProductRepository _repository;

    public ProductService(IProductRepository repository)
    {
        _repository = repository;
    }

    public async Task<ProductDto> GetProductAsync(int id)
    {
        var product = await _repository.GetByIdAsync(id);
        return MapToDto(product);
    }
}

// Presentation Layer
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly ProductService _service;

    public ProductsController(ProductService service)
    {
        _service = service;
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProduct(int id)
    {
        var product = await _service.GetProductAsync(id);
        return Ok(product);
    }
}

Best For

Traditional enterprise applications where clear separation between presentation, business logic, and data access is required.

3. Clean/Onion Architecture

What Is It?

Clean Architecture (also known as Onion Architecture) places business logic at the center of the application, with dependencies flowing inward toward the core.

Key Layers

Domain Layer - Entities, value objects, domain services
Application Layer - Use cases, commands, queries, services
Infrastructure Layer - External concerns (database, email, etc.)
Presentation Layer - UI or API endpoints

Key Characteristics

Dependencies flow inward (inversion of control)
Business logic has no dependencies on infrastructure
Use interfaces/abstractions at boundaries
Highly testable business logic
Framework-agnostic core

When to Use It

Complex business domains
Long-lived applications
When you need maximum testability
When you want to avoid framework lock-in

Pros

✅ Framework-agnostic business logic
✅ Highly testable (no database needed for unit tests)
✅ Easy to swap implementations
✅ Clear separation of concerns
✅ Scalable for complex domains

Cons

❌ More projects/files to manage
❌ Steeper learning curve
❌ More boilerplate code
❌ Can be overkill for simple applications

Implementation Structure

Solution/
├── Domain/
│   ├── Entities/
│   ├── Interfaces/
│   └── ValueObjects/
├── Application/
│   ├── Features/
│   │   ├── Commands/
│   │   └── Queries/
│   ├── Interfaces/
│   └── Services/
├── Infrastructure/
│   ├── Persistence/
│   └── Services/
├── Presentation/
│   └── API/
└── Tests/

Example Code

// Domain Layer - Pure Business Logic
namespace MyApp.Domain.Entities
{
    public class Product
    {
        public int Id { get; private set; }
        public string Name { get; private set; }
        public decimal Price { get; private set; }

        private Product() { } // For EF Core

        public Product(string name, decimal price)
        {
            if (string.IsNullOrWhiteSpace(name))
                throw new ArgumentException("Name is required");
            if (price < 0)
                throw new ArgumentException("Price cannot be negative");

            Name = name;
            Price = price;
        }

        public void UpdatePrice(decimal newPrice)
        {
            if (newPrice < 0)
                throw new ArgumentException("Price cannot be negative");
            Price = newPrice;
        }
    }
}

// Domain Interface
namespace MyApp.Domain.Interfaces
{
    public interface IProductRepository
    {
        Task<Product> GetByIdAsync(int id);
        Task<IEnumerable<Product>> GetAllAsync();
        Task<Product> AddAsync(Product product);
        Task UpdateAsync(Product product);
    }
}

// Application Layer - Use Cases
namespace MyApp.Application.Features.Products.Commands
{
    public class CreateProductCommand : IRequest<int>
    {
        public string Name { get; set; }
        public decimal Price { get; set; }
    }

    public class CreateProductCommandHandler : IRequestHandler<CreateProductCommand, int>
    {
        private readonly IProductRepository _repository;

        public CreateProductCommandHandler(IProductRepository repository)
        {
            _repository = repository;
        }

        public async Task<int> Handle(CreateProductCommand request, CancellationToken cancellationToken)
        {
            var product = new Product(request.Name, request.Price);
            await _repository.AddAsync(product);
            return product.Id;
        }
    }
}

// Infrastructure Layer - Implementation
namespace MyApp.Infrastructure.Persistence.Repositories
{
    public class ProductRepository : IProductRepository
    {
        private readonly ApplicationDbContext _context;

        public ProductRepository(ApplicationDbContext context)
        {
            _context = context;
        }

        public async Task<Product> GetByIdAsync(int id)
        {
            return await _context.Products.FindAsync(id);
        }

        public async Task AddAsync(Product product)
        {
            _context.Products.Add(product);
            await _context.SaveChangesAsync();
        }
    }
}

Best For

Complex business applications where maintainability, testability, and long-term evolution are critical.

4. Vertical Slice Architecture

What Is It?

Vertical Slice Architecture organizes code by features (slices) rather than by technical layers. Each slice contains all the code needed for a specific feature, from presentation to data access.

Key Characteristics

Code organized by feature, not by layer
Each feature is independent
Reduced coupling between features
Easier to understand and modify specific features
Encourages DDD patterns within slices

When to Use It

Feature-rich applications
When you need to isolate features
When features have different lifecycle requirements
When you want to avoid horizontal layer coupling

Pros

✅ Feature isolation
✅ Easier to understand specific features
✅ Reduced coupling between features
✅ Better alignment with business domains
✅ Easier to remove or modify features

Cons

❌ Code duplication between features
❌ Less reuse of infrastructure code
❌ Can be harder to see overall architecture
❌ May require more boilerplate per feature

Implementation Structure

Solution/
├── Features/
│   ├── Products/
│   │   ├── Create/
│   │   │   ├── Endpoint.cs
│   │   │   ├── Validator.cs
│   │   │   └── Request.cs
│   │   ├── Get/
│   │   │   ├── Endpoint.cs
│   │   │   └── Request.cs
│   │   └── Models/
│   │       └── ProductDto.cs
│   ├── Orders/
│   │   ├── Create/
│   │   ├── Get/
│   │   └── Models/
│   └── Customers/
├── Infrastructure/
│   ├── Persistence/
│   └── Services/
└── API/
    └── Program.cs

Example Code

// Features/Products/Create/Endpoint.cs
public static class CreateProduct
{
    public class Endpoint : IEndpoint
    {
        public void MapEndpoint(IEndpointRouteBuilder app)
        {
            app.MapPost("/api/products", HandleAsync)
               .WithName("CreateProduct")
               .WithOpenApi();
        }

        public static async Task<IResult> HandleAsync(
            CreateProductRequest request,
            IMediator mediator)
        {
            var command = new CreateProductCommand(request.Name, request.Price);
            var productId = await mediator.Send(command);
            return Results.Created($"/api/products/{productId}", new { id = productId });
        }
    }
}

// Features/Products/Create/Request.cs
public record CreateProductRequest(string Name, decimal Price);

// Features/Products/Create/Command.cs
public record CreateProductCommand(string Name, decimal Price) : IRequest<int>;

public class CreateProductCommandHandler : IRequestHandler<CreateProductCommand, int>
{
    private readonly ApplicationDbContext _context;

    public CreateProductCommandHandler(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<int> Handle(CreateProductCommand request, CancellationToken cancellationToken)
    {
        var product = new Product(request.Name, request.Price);
        _context.Products.Add(product);
        await _context.SaveChangesAsync(cancellationToken);
        return product.Id;
    }
}

// Features/Products/Get/Endpoint.cs
public static class GetProduct
{
    public class Endpoint : IEndpoint
    {
        public void MapEndpoint(IEndpointRouteBuilder app)
        {
            app.MapGet("/api/products/{id}", HandleAsync)
               .WithName("GetProduct")
               .WithOpenApi();
        }

        public static async Task<IResult> HandleAsync(
            int id,
            IMediator mediator)
        {
            var query = new GetProductQuery(id);
            var product = await mediator.Send(query);
            return product is not null ? Results.Ok(product) : Results.NotFound();
        }
    }
}

Best For

Feature-rich applications where features have different lifecycles and need to be isolated from each other.

5. Hexagonal Architecture (Ports and Adapters)

What Is It?

Hexagonal Architecture (Ports and Adapters) focuses on isolating the application core from external concerns through ports (interfaces) and adapters (implementations).

Key Concepts

Ports - Interfaces defining how the application interacts with the outside world
Adapters - Implementations of ports that connect to external systems
Application Core - Business logic that uses ports
Primary Adapters - Driving adapters (UI, API endpoints)
Secondary Adapters - Driven adapters (databases, external services)

When to Use It

When you need to support multiple external systems
When you need to isolate core logic from infrastructure
When you need to test without external dependencies
When you need to support multiple interfaces to the same core

Pros

✅ Maximum flexibility
✅ Easy to test in isolation
✅ Easy to add new external systems
✅ Clear boundary definitions

Cons

❌ Can introduce complexity
❌ Requires careful interface design
❌ May be overkill for simple applications

Example Code

// Ports (Interfaces)
public interface IPaymentProcessor
{
    Task<PaymentResult> ProcessAsync(PaymentRequest request);
}

public interface IOrderRepository
{
    Task<Order> GetByIdAsync(int id);
    Task SaveAsync(Order order);
}

// Application Core (Uses Ports)
public class OrderService
{
    private readonly IPaymentProcessor _paymentProcessor;
    private readonly IOrderRepository _orderRepository;

    public OrderService(IPaymentProcessor paymentProcessor, IOrderRepository orderRepository)
    {
        _paymentProcessor = paymentProcessor;
        _orderRepository = orderRepository;
    }

    public async Task<PaymentResult> ProcessOrderPayment(int orderId)
    {
        var order = await _orderRepository.GetByIdAsync(orderId);
        var request = new PaymentRequest(order.TotalAmount, order.CustomerId);

        var result = await _paymentProcessor.ProcessAsync(request);

        if (result.Success)
        {
            order.MarkAsPaid();
            await _orderRepository.SaveAsync(order);
        }

        return result;
    }
}

// Adapters (Implementations)
public class StripePaymentProcessor : IPaymentProcessor
{
    private readonly IStripeClient _stripeClient;

    public StripePaymentProcessor(IStripeClient stripeClient)
    {
        _stripeClient = stripeClient;
    }

    public async Task<PaymentResult> ProcessAsync(PaymentRequest request)
    {
        var charge = await _stripeClient.Charge.CreateAsync(new ChargeCreateOptions
        {
            Amount = (long)(request.Amount * 100),
            Currency = "usd",
            Customer = request.CustomerId
        });

        return new PaymentResult(charge.Status == "succeeded", charge.Id);
    }
}

Best For

Applications with multiple external integrations or when maximum flexibility and testability are required.

Architecture Comparison Table

Architecture	Complexity	Testability	Flexibility	Best For
Monolithic	Low	Medium	Low	Simple apps, small teams
Layered	Medium	Medium	Medium	Enterprise apps, clear separation
Clean/Onion	High	High	High	Complex domains, long-lived apps
Vertical Slice	Medium-High	High	High	Feature-rich apps, DDD
Hexagonal	High	High	Very High	Multiple external systems

When to Choose Which Architecture

Choose Monolithic when:

Building a simple application
Small development team
Limited complexity
Quick time to market is priority
No need for microservices

Choose Layered Architecture when:

Building traditional enterprise applications
Need clear separation of concerns
Different teams work on different layers
Application has moderate complexity

Choose Clean/Onion Architecture when:

Building complex business domains
Long-term maintainability is critical
Need maximum testability
Want to avoid framework lock-in
Application has complex business rules

Choose Vertical Slice Architecture when:

Building feature-rich applications
Features have different lifecycles
Want feature isolation
Following DDD principles

Choose Hexagonal Architecture when:

Supporting multiple external systems
Need maximum flexibility
Core logic must be isolated from infrastructure
Testing without external dependencies is critical

Migration Paths

From Monolithic to Layered:

Identify logical layers in existing code
Create separate projects for each layer
Move code to appropriate projects
Introduce interfaces between layers

From Layered to Clean Architecture:

Extract domain entities from services
Create domain project with entities and interfaces
Move application logic to Application project
Move data access to Infrastructure project
Introduce dependency injection

From Clean to Vertical Slice:

Group code by feature instead of layer
Create feature folders with all related code
Keep domain entities but organize around features
Reduce horizontal dependencies

Best Practices for .NET 10

Use Dependency Injection - Built into ASP.NET Core, essential for Clean Architecture
Follow SOLID Principles - Especially Dependency Inversion for architecture
Use CQRS Pattern - Command Query Responsibility Segregation for complex operations
Implement Mediator Pattern - For decoupling requests and handlers
Use Repository Pattern - For data access abstraction
Implement Specification Pattern - For complex queries
Use Value Objects - For immutable data structures
Implement Domain Events - For loose coupling between domain components

Conclusion

Choosing the right architecture depends on your specific needs:

For simple apps → Monolithic or Layered
For complex domains → Clean/Onion Architecture
For feature-rich apps → Vertical Slice
For maximum flexibility → Hexagonal

Remember: The best architecture is the one that serves your application's needs today and can evolve as your requirements change. Start simple and refactor as needed.

C14: The Complete Guide to Every New Feature

Vikrant Bagal — Fri, 17 Apr 2026 15:29:10 +0000

C# 14 is here, and it's packed with features that will make your code cleaner, more expressive, and more performant. Whether you're a seasoned .NET developer or just getting started, this complete guide covers every new feature in C# 14.

Introduction

C# 14 ships with .NET 10, and it's one of the most significant releases in recent years. From extension members that completely change how we extend types, to practical quality-of-life improvements that eliminate boilerplate code, C# 14 has something for everyone.

In this guide, we'll explore each new feature in detail, with code examples and practical use cases. Let's dive in!

1. Extension Members: The Headline Feature

Extension members are the most significant addition to C# 14. They extend the concept of extension methods to include properties, operators, and static members.

What Problem Does It Solve?

For over a decade, C# developers have used extension methods to add functionality to existing types. But extension methods were limited - you couldn't add properties, operators, or static members. This limitation often forced developers to create wrapper types or duplicate code.

Extension members solve this by allowing you to add instance properties, operators, and static members to any existing type.

Syntax

Extension members use a new extension keyword with a receiver syntax:

public static class EnumerableExtensions
{
    // Instance extension block - receiver 'source' is the instance
    extension<TSource>(IEnumerable<TSource> source)
    {
        // Extension property
        public bool IsEmpty => !source.Any();

        // Extension method (works like before)
        public IEnumerable<TSource> Where(Func<TSource, bool> predicate)
        {
            foreach (var item in source)
                if (predicate(item))
                    yield return item;
        }
    }

    // Static extension block - no receiver needed for static members
    extension<TSource>(IEnumerable<TSource>)
    {
        // Static extension property
        public static IEnumerable<TSource> Identity => Enumerable.Empty<TSource>();

        // Static extension operator
        public static IEnumerable<TSource> operator +(
            IEnumerable<TSource> left,
            IEnumerable<TSource> right)
            => left.Concat(right);
    }
}

Real-World Usage

var numbers = new[] { 1, 2, 3, 4, 5 };

// Use extension property
if (numbers.IsEmpty)
{
    Console.WriteLine("No numbers!");
}

// Use extension operator
var combined = numbers + new[] { 6, 7, 8 };
// [1, 2, 3, 4, 5, 6, 7, 8]

// Use static extension property
var empty = IEnumerable<int>.Identity;

Key Benefits

Add properties to framework types - No more wrapper classes for simple computed properties
Define operators on existing types - Extend types with custom operators without modifying them
Static extension members - Add static methods/properties to types you don't own
Backward compatible - Works alongside existing extension methods

2. The `field` Keyword: Auto Properties With Logic

The field keyword is a contextual keyword that provides a middle ground between auto-implemented properties and fully hand-written backing fields.

Before C# 14

If you needed to add validation logic to a property, you had to declare a backing field:

private string _name;
public string Name
{
    get => _name;
    set => _name = value ?? throw new ArgumentNullException(nameof(value));
}

With C# 14

Now you can use the field keyword, which represents a compiler-generated backing field:

public string Name
{
    get;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}

More Examples

public class Product
{
    private decimal _price;

    // Traditional approach
    public decimal Price
    {
        get => _price;
        set => _price = value >= 0 ? value : throw new ArgumentException("Price cannot be negative");
    }

    // With field keyword
    public decimal DiscountPrice
    {
        get;
        set => field = value >= 0 ? value : throw new ArgumentException("Discount price cannot be negative");
    }

    // Multiple accessors with field
    public string Description
    {
        get => field ?? "No description";
        set => field = value?.Trim();
    }
}

Important Notes

Naming conflicts: If you have an existing member named field, use @field or this.field to disambiguate
Backward compatible: Existing code continues to work unchanged
Encourages property-only access: All code within the type must use the property

3. Null-Conditional Assignment: Eliminate Boilerplate

C# 14 allows you to use null-conditional operators (?.) on the left-hand side of assignments.

Before C# 14

if (customer is not null)
{
    customer.Order = GetCurrentOrder();
    customer.Total += CalculateIncrement();
}

With C# 14

customer?.Order = GetCurrentOrder();
customer?.Total += CalculateIncrement();

Behavior

The right-hand side is evaluated only when the left side is not null
Works with ?. and ?[] operators
Supports compound assignment operators (+=, -=, *=, etc.)
Does NOT support increment/decrement operators (++, --)

Practical Example

public class ShoppingCart
{
    public Order? CurrentOrder { get; set; }
    public decimal Total { get; set; }
}

public void ProcessOrder(ShoppingCart? cart)
{
    // Before: Multiple null checks
    if (cart is not null && cart.CurrentOrder is not null)
    {
        cart.CurrentOrder.Status = OrderStatus.Processing;
        cart.Total += cart.CurrentOrder.Subtotal;
    }

    // After: Clean null-conditional assignment
    cart?.CurrentOrder?.Status = OrderStatus.Processing;
    cart?.Total += cart?.CurrentOrder?.Subtotal ?? 0;
}

4. Unbound Generic Types with `nameof`

The nameof operator now accepts unbound generic types (types without type arguments).

Before C# 14

var name = nameof(List<int>);  // Returns "List"

With C# 14

var name = nameof(List<>);  // Returns "List"

Practical Use Cases

// Logging generic type names
public void LogType<T>()
{
    _logger.LogInformation($"Processing type: {nameof(T)}");
    _logger.LogInformation($"Generic type name: {nameof(List<>)}");
}

// Exception messages
public void ValidateType(Type type)
{
    if (!type.IsGenericType)
        throw new InvalidOperationException(
            $"Expected generic type, got {nameof(type)}");
}

// Reflection scenarios
public class Repository<T>
{
    public static string GetTypeName()
    {
        return nameof(Repository<>);  // Returns "Repository"
    }
}

Benefits

No need to specify arbitrary type arguments
Cleaner code for generic type logging/throwing
Useful in reflection and code generation scenarios

5. Simple Lambda Parameters with Modifiers

Lambda expressions can now use parameter modifiers (ref, in, out, scoped) without explicit type annotations.

Before C# 14

delegate bool TryParse<T>(string text, out T result);

TryParse<int> parse = (string text, out int result) => 
    int.TryParse(text, out result);

With C# 14

TryParse<int> parse = (text, out result) => 
    int.TryParse(text, out result);

More Examples

// Ref parameters
var process = (ref int x, int y) => x += y;

// In parameters
var compare = (in int x, in int y) => x.CompareTo(y);

// Out parameters
var tryGetValue = (string key, out string value) => 
    dictionary.TryGetValue(key, out value);

// Mixed modifiers
var complexParse = (string text, out int number, out bool isValid) =>
{
    isValid = int.TryParse(text, out number);
    return isValid;
};

Limitations

params modifier still requires explicit type annotations
Parameter types are still inferred from delegate context

6. Partial Events and Constructors

C# 14 allows instance constructors and events to be declared as partial members.

Why This Matters

This is particularly useful for source generators and partial type scenarios where different files or generators contribute to a type's definition.

Partial Events

public partial class Widget
{
    public partial event EventHandler Changed;
}

public partial class Widget
{
    private EventHandler? _changed;

    public partial event EventHandler Changed
    {
        add => _changed += value;
        remove => _changed -= value;
    }
}

Partial Constructors

public partial class Widget(int size, string name)
{
    public int Size { get; } = size;
    public string Name { get; } = name;
}

public partial class Widget
{
    public Widget() : this(0, "Default") { }

    public Widget(string name) : this(10, name) { }

    // Additional constructor body logic
    public Widget
    {
        Initialize();  // Additional initialization
    }
}

Rules

Exactly one defining declaration and one implementing declaration
Implementing declaration can include constructor initializers (this() or base())
Only one partial type can include primary constructor syntax
Partial events must include add and remove accessors

7. Implicit Span Conversions

C# 14 introduces first-class language support for Span<T> and ReadOnlySpan<T> with implicit conversions.

Before C# 14

string line = ReadLine();
ReadOnlySpan<char> key = line.AsSpan(0, 5);  // Explicit call
ProcessKey(key);

int[] buffer = GetBuffer();
Span<int> head = new(buffer, 0, 8);  // Explicit constructor
Accumulate(head);

With C# 14

string line = ReadLine();
ProcessKey(line[..5]);  // Implicit conversion

int[] buffer = GetBuffer();
Accumulate(buffer[..8]);  // Implicit conversion

Conversions Supported

From	To
`T[]`	`Span<T>`
`T[]`	`ReadOnlySpan<T>`
`string`	`ReadOnlySpan<char>`
`Span<T>`	`ReadOnlySpan<T>`

Benefits

Zero-allocation conversions where possible
Enables better JIT optimizations
Reduces explicit AsSpan() and Span<T>() constructor calls
More natural string slicing syntax

8. User-defined Compound Assignment

C# 14 allows you to define custom compound assignment operators (+=, -=, etc.).

Before C# 14

public struct BigVector(float x, float y, float z)
{
    public float X { get; private set => value = field; } = x;
    public float Y { get; private set => value = field; } = y;
    public float Z { get; private set => value = field; } = z;

    public static BigVector operator +(BigVector l, BigVector r)
        => new(l.X + r.X, l.Y + r.Y, l.Z + r.Z);
}

// Usage - creates intermediate temporaries
BigVector sum = BigVector.Zero;
foreach (var v in values)
{
    sum = sum + v;  // Creates new temporary each iteration
}

With C# 14

public struct BigVector(float x, float y, float z)
{
    public float X { get; private set => value = field; } = x;
    public float Y { get; private set => value = field; } = y;
    public float Z { get; private set => value = field; } = z;

    public static BigVector operator +(BigVector l, BigVector r)
        => new(l.X + r.X, l.Y + r.Y, l.Z + r.Z);

    public void operator +=(BigVector r)
    {
        X += r.X;
        Y += r.Y;
        Z += r.Z;
    }
}

// Usage - no intermediate temporaries
BigVector sum = BigVector.Zero;
foreach (var v in values)
{
    sum += v;  // Calls user-defined operator += directly
}

Performance Benefits

Avoids creating intermediate temporaries
Enables better JIT optimizations in tight loops
Critical for high-performance numeric and SIMD types
More idiomatic API design

Summary Table

Feature	Problem Solved	Key Benefit
Extension Members	Can't add properties/operators to existing types	Add properties, operators, static members to any type
field Keyword	Manual backing fields for properties with logic	Cleaner property code, no manual fields needed
Null-conditional Assignment	Explicit null checks before assignment	Eliminates boilerplate null-checking code
Unbound Generics with nameof	Can't get generic type name without type args	Cleaner generic type logging/throwing
Lambda Parameter Modifiers	Need types for modifiers in lambdas	Keep lambdas concise with ref/out/in
Partial Events & Constructors	Can't split event/constructor logic across files	Better source generator support
Implicit Span Conversions	Explicit AsSpan() calls required	Zero-allocation conversions, better performance
Compound Assignment Operators	No custom compound operators	Avoid temporaries, better JIT optimization

Migration Guide

Upgrade to C# 14

Update your project file:

   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <LangVersion>14</LangVersion>
   </PropertyGroup>

Install .NET 10 SDK
Gradually adopt features:
- Start with field keyword for simple property validation
- Use null-conditional assignment to reduce null checks
- Adopt extension members for utility properties on framework types
- Use implicit span conversions for better performance

Breaking Changes

field keyword conflicts: If you have a member named field, use @field or rename it
Generic inference: Some scenarios may need explicit type arguments
Extension member resolution: Participates in overload resolution like regular members

Conclusion

C# 14 represents a significant step forward for the language. The extension members feature alone changes how we think about extending types, while the quality-of-life improvements like field keyword and null-conditional assignment eliminate common sources of boilerplate code.

Whether you're building high-performance applications with spans and compound operators, or just want cleaner property code with the field keyword, C# 14 has something valuable to offer.

Get started today by installing .NET 10 SDK and trying out these features in your next project!

What's New in ASP.NET Core (.NET 11): Zstandard, HTTP/3, Virtualize & More

Vikrant Bagal — Wed, 15 Apr 2026 23:52:47 +0000

Published: April 2026 | Reading time: ~8 min

.NET 11 Preview 3 dropped last week, and ASP.NET Core is shipping some of the most impactful improvements we've seen in a while. Whether you're building APIs, real-time apps, or distributed systems with Aspire, there's something here that'll make your life easier.

Let's dive into the highlights.

1. Zstandard Compression — Finally Native in ASP.NET Core

Facebook's Zstandard algorithm has been making waves in the compression world for years. Now it's finally in the ASP.NET Core box.

Why Zstandard?

20-30% better compression than Gzip at equivalent speeds
~2x faster compression than Gzip at equivalent ratios
Lower bandwidth → lower cloud bills
Already used in production at Facebook, Cloudflare, and more

Setting it up is dead simple:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add<ZstandardCompressionProvider>();
});

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

The best part? It works seamlessly with existing middleware. Your JSON APIs, static files, and SignalR responses can all benefit without touching a single line of business logic.

When to use it: API responses, JSON payloads, any content that isn't already compressed. Be careful with content that's already highly compressed (images, videos) — Zstandard can actually increase CPU usage with minimal gain.

2. HTTP/3 — Lower Latency, Starting Now

HTTP/3 has been in preview for a while, but .NET 11 ships a meaningful improvement: the server starts processing requests earlier in the connection lifecycle.

The technical win here is reduced TTFB (Time To First Byte), especially on:

Mobile networks with variable latency
Connections with packet loss (QUIC handles this better than TCP)
Situations where TLS handshake overhead matters

builder.WebHost.ConfigureKestrel(options =>
{
    options.Listen(IPAddress.Any, 443, listenOptions =>
    {
        listenOptions.Protocol(HttpProtocolType.Http3);
    });
});

What changed: Previously, the server waited for the full QUIC handshake acknowledgment before dispatching the request. Now it starts processing as soon as the client's first request bytes arrive — overlapping the handshake with request processing.

Requirements:

TLS 1.3 certificate (Let's Encrypt works great)
Client support (modern browsers all support HTTP/3)
UDP open on port 443 (check your firewall!)

3. Virtualize Adapts to Variable-Height Items

List virtualization is crucial for performance in data-heavy apps — chat threads, social feeds, admin grids. But the classic challenge? Items with variable heights.

In .NET 11, the <Virtualize> component now adapts to variable-height items at runtime:

<ListView ItemsProvider="LoadMessages">
    <ItemSizeProvider>
        @(context => context.IsLoaded 
            ? CalculateMessageHeight(context) 
            : 50) @* placeholder *@
    </ItemSizeProvider>
</ListView>

This means:

No more pre-measuring everything before rendering
O(1) virtualization overhead regardless of content variance
Smooth scrolling even when message lengths vary wildly

For apps like Teams, Slack, or any chat-like interface, this is a genuine quality-of-life improvement.

4. dotnet watch + Aspire — Dev Loop Gets Smart

If you're using Aspire for distributed cloud-native apps, dotnet watch just got significantly smarter.

dotnet watch --project MyApp.AppHost

In .NET 11, dotnet watch now:

Monitors Aspire project dependencies — changes to any service in your app graph trigger appropriate rebuilds
Crash recovery — if a service goes down during development, it restarts without killing your debug session
Selective rebuilds — only the changed project recompiles, not the whole solution

This is especially welcome for microservices developers who were manually restarting multiple services on every code change.

5. System.Text.Json — More Control, Fewer Workarounds

System.Text.Json has matured significantly. .NET 11 adds finer control over naming policies and property ignore defaults:

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    PropertyNameCaseInsensitive = true
};

The new additions in .NET 11 give you:

More flexible custom naming policies
Better control over which properties serialize in inheritance scenarios
Improved source generator support for AOT scenarios

If you've been maintaining custom JsonConverter workarounds for these scenarios, it's worth revisiting in .NET 11.

6. Entity Framework Core — Smarter Migrations & SQL Generation

EF Core continues to close the gap with raw SQL performance:

ChangeTracker.GetEntriesForState()

// New API avoids extra change detection passes
var modified = context.ChangeTracker
    .GetEntriesForState(EntityState.Modified)
    .ToList();

Migrations got more control:

Better feedback when a migration is invalid
Ability to generate idempotent scripts more easily
Improved handling of pending model changes

SQL Server JSON APIs:
EF Core now generates native JSON_VALUE and JSON_QUERY calls instead of string manipulation on the client — meaningful performance gains for JSON column queries.

Quick Comparison Table

Feature	.NET 9	.NET 11	Impact
Compression	Gzip/Brotli	+ Zstandard	-30% bandwidth
HTTP/3	Supported	Earlier processing	-30-50% TTFB
Virtualize	Fixed height	Variable height	Chat/feed UX
dotnet watch	Basic	+ Aspire, crash recovery	Dev speed
JSON	Flexible	Even more flexible	Less boilerplate

Should You Upgrade Now?

Preview 3 is stable enough to test in dev, but wait for GA (November 2026) for production workloads. The migration from .NET 9 should be smooth — these are additive features.

Test specifically:

HTTP/3 compatibility with your TLS setup
Zstandard CPU usage on high-traffic endpoints
Virtualize behavior with your actual dynamic content

What's NOT in This Release (But Worth Noting)

Blazor in .NET 11 focuses on stability and perf, not big new features
SignalR improvements are subtle — concurrent connection handling
Minimal APIs get minor ergonomic improvements

If you're hungry for the big language feature, check out C# 15 Union Types — a separate post, but a game-changer for domain modeling.

What feature are you most excited about? Drop a comment below!

Found this useful? Follow me for more .NET content. I write about ASP.NET Core, C#, and cloud-native development every week.

Lets connect on LinkedIn!

Running AI Locally in 2026: Why On-Device LLMs Are Winning

Vikrant Bagal — Wed, 15 Apr 2026 12:28:34 +0000

The era of cloud-dependent AI is ending. In 2026, running large language models on your own device isn't just possible—it's becoming the preferred choice for developers, enterprises, and privacy-conscious users.

What's Changed?

A year ago, "local AI" meant wrestling with CUDA drivers, manual model loading, and disappointing performance. Today, tools like Ollama let you pull and run a capable model with a single command. Google just dropped Gemma 4 (April 2, 2026) with four variants optimized for everything from mobile browsers to desktop workstations. The math works now: quantization techniques have matured, hardware acceleration is standard, and open-weight models are purpose-built for edge deployment.

The Privacy Case Is Simple

When you send a prompt to ChatGPT or Claude, your data travels to external servers. With on-device LLMs, your prompts and documents never leave your machine. For healthcare, legal, or any data-sensitive industry, that's not a nice-to-have—it's a requirement.

"The shift from cloud to on-device inference isn't just technical. It's a fundamental privacy-first architecture decision." — Bolder Apps, March 2026

Gemma 4: Google's Edge Push

The new Gemma 4 family demonstrates how far on-device AI has come:

Model	Memory (Q4)	Context
E2B	~3.2 GB	128K
E4B	~5.0 GB	128K
31B	~17.4 GB	256K

All models support text + images; audio comes on E2B/E4B. Apache 2.0 license means commercial use is fully allowed. The E2B/E4B pair runs on modern phones—Gemma 3n already powers iOS apps with a 4B active footprint and nested 2B submodel for quality-latency tradeoffs.

Ollama: The Easy Button

# One command to run a model locally
ollama run gemma:3n-4b

No API keys. No rate limits. No data leaving your machine. Ollama wraps model download, quantization, and a REST API into a single binary. Every major local AI tool (LM Studio, Enclave AI, Google AI Edge) supports it as a backend.

Real-World Use Cases in 2026

Offline AI assistants: Transcribe meetings, analyze documents, or code—all without internet.

Enterprise compliance: Keep sensitive data on-premises while still leveraging AI capabilities.

Mobile-first inference: Audio transcription, translation, and voice interactions now work on-device. VibeVoice (Microsoft's voice cloning) shows where this is heading.

The Tradeoffs Exist

Let's be honest: local doesn't beat cloud on raw capability for the biggest models. A 70B parameter model still needs serious hardware. The 26B MoE variant of Gemma 4 activates only 4B parameters per token, but still requires loading all 26B weights. Context length fights against available RAM.

But for most tasks? The gap has collapsed. A quantized 7B model handles coding assistance, document analysis, and general chat at a level indistinguishable from cloud for daily use.

What's Next

The trajectory is clear: better quantization, hardware improvements, and purpose-built models for edge. AI agents like deer-flow (ByteDance) can already use local LLMs as their reasoning backbone. The privacy-first movement is accelerating.

If you've been waiting for local AI to be "ready," 2026 is your answer.

Have you tried running models locally? What's your setup? Let me know in the comments.

ondevicellm #localai #privacy #gemma #ollama #ai2026