CQRS Integration — Complete Guide

Introduction

CQRS Integration — Complete Guide is essential for .NET developers building ShopNest.Live Enterprise Real-Time Communication Platform — Toolliyo's 100-article SignalR & SSE master path covering SignalR hubs, SSE streaming, WebSockets, Redis backplane, Azure SignalR, Kubernetes, and enterprise real-time apps. Every article includes architecture diagrams, scaling discussion, security guidance, Kubernetes deployment, and minimum 2 ultra-detailed real-world examples (banking, e-commerce, ERP, SaaS, healthcare).

In Indian delivery projects (TCS, Infosys, Wipro), interviewers expect cqrs integration with real Swiggy live tracking, Zerodha tickers, HDFC fraud alerts, Flipkart flash sales, and Azure SignalR at scale — not toy animal demos. This article delivers two mandatory enterprise examples on SCALING.

After this article you will

• Explain CQRS Integration in plain English and in real-time architecture and distributed systems terms
• Implement cqrs integration in ShopNest.Live Enterprise Real-Time Communication Platform (SCALING)
• Compare the wrong approach vs the production-ready enterprise approach
• Answer fresher, mid-level, and senior SignalR, SSE, and real-time system design interview questions confidently
• Connect this lesson to Article 60 and the 100-article SignalR & SSE roadmap

Prerequisites

• Software: .NET 8 SDK, VS 2022 or VS Code, SQL Server Express / LocalDB
• Knowledge: C# basics
• Previous: Article 58 — Kafka Integration — Complete Guide
• Time: 28 min reading + 30–45 min hands-on

Concept deep-dive

Level 1 — Analogy

Clean Architecture is onion layers — domain at the center, infrastructure on the outside; dependencies point inward only.

Level 2 — Technical

CQRS Integration powers live features in ASP.NET Core 9: hubs, SSE endpoints, Redis backplane, and React clients. ShopNest.Live implements SCALING with production auth, scaling, and observability.

Level 3 — Distributed systems view

[React Client] ──WebSocket/SSE──► [Load Balancer]
       ▼                              ▼
 [SignalR Hub] ◄──Redis Backplane──► [API Pod 2..N]
       ▼
 [RabbitMQ/Kafka] → [Notification Worker]

Project structure

ShopNest.Live/
├── ShopNest.Live.Console/     ← Practice programs (Main)
├── ShopNest.Live.Core/        ← Algorithms & helpers
├── ShopNest.Live.Tests/       ← xUnit edge cases
└── ShopNest.Live.Interview/   ← Pattern catalog

Step-by-Step Implementation — ShopNest.Live (SCALING)

Follow: create project → configure SignalR/SSE → hub/endpoint → React client → auth → Redis scale-out → deploy to AKS.

Step 1 — Anti-pattern (polling only)

// ❌ BAD — polling every 2s, no scale-out, no auth
setInterval(async () => {
  const res = await fetch('/api/orders/status');
  updateUI(await res.json());
}, 2000);
// 10k users = 5k requests/sec — database meltdown

Step 2 — Production SignalR/SSE

// ✅ PRODUCTION — CQRS Integration on ShopNest.Live (SCALING)
builder.Services.AddSignalR().AddStackExchangeRedis(configuration["Redis"]);
builder.Services.AddAzureSignalR(configuration["Azure:SignalR"]);
app.MapHub("/hubs/orders");
// Client: connection.on('LocationUpdated', updateMap);

Step 3 — Full program

// CQRS Integration — ShopNest layered architecture
// ShopNest.Application → ShopNest.Infrastructure → ShopNest.Live

dotnet run --project ShopNest.Live.Api
# Verify /hubs/orders/negotiate returns connection token

Real-time communication fundamentals

CQRS Integration — technology focus: SIGNALR, module category: SCALING.

SignalR negotiates WebSockets, SSE, or long-polling automatically — bidirectional hub methods and groups.

SignalR vs SSE vs WebSockets

• Raw WebSockets — maximum control; you own protocol, reconnection, and scaling.
• SSE — use when only server pushes (stock tickers, live logs, notification streams).
• SignalR — default for ASP.NET Core apps needing hubs, groups, JWT auth, and Redis backplane.

Browser ──negotiate──► SignalR Hub
         ◄── WebSocket / SSE / Long Poll ──►
Redis Backplane ◄──► Multiple API instances (ShopNest.Live)

Connection lifecycle

1. Client calls /negotiate (SignalR) or opens EventSource (SSE)
2. Server assigns connection ID / stream ID
3. Messages flow — hub methods, groups, or SSE events
4. Disconnect → automatic reconnect with exponential backoff
5. Scale-out: Redis publishes to all server instances

SignalR internal pipeline

Hub → IHubContext for server-initiated messages. Connection ID maps to user via Context.UserIdentifier. Groups like order-{id} isolate Swiggy-style tracking channels.

public class OrderTrackingHub : Hub
{
    public async Task JoinOrder(string orderId) =>
        await Groups.AddToGroupAsync(Context.ConnectionId, $"order-{orderId}");
    public async Task UpdateLocation(string orderId, double lat, double lng) =>
        await Clients.Group($"order-{orderId}").SendAsync("LocationUpdated", lat, lng);
}

SSE streaming (when applicable)

app.MapGet("/sse/prices", async (HttpResponse res) => {
    res.Headers.ContentType = "text/event-stream";
    await foreach (var tick in _priceStream.ReadAsync())
        await res.WriteAsync($"data: {tick}

");
});

Browser: const es = new EventSource('/sse/prices'); es.onmessage = e => updateChart(JSON.parse(e.data));

Scaling and distributed systems

• Redis backplane — synchronizes messages across SignalR server instances
• Azure SignalR Service — managed connection layer for 100k+ concurrent users
• Sticky sessions — only needed without backplane; avoid in Kubernetes
• Kafka/RabbitMQ — domain events fan-out to notification workers

Performance and security

• Enable message compression for large payloads
• JWT in query string or accessTokenFactory for WebSocket auth
• Rate limit hub invocations per connection ID
• CORS: allow credentials only for trusted origins
• Monitor connection count, message throughput, reconnect rate in Grafana

Real-world use case 1 — Azure SignalR Service at Scale

Domain: Cloud. Offload connection management to Azure; ASP.NET Core hubs focus on business logic only.

Real-world use case 2 — Microsoft Teams Presence

Domain: SaaS. Persistent connections with transport fallback — WebSocket primary, SSE/long-polling fallback on corporate proxies.

Kubernetes and cloud deployment

# ShopNest.Live SignalR on AKS
apiVersion: apps/v1
kind: Deployment
metadata:
  name: shopnest-live-api
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: api
        env:
        - name: Azure__SignalR__ConnectionString
          valueFrom:
            secretKeyRef:
              name: signalr-secret
              key: connectionString

Observability

Instrument with OpenTelemetry: trace hub method duration, connection churn, Redis publish latency. Serilog + Prometheus + Grafana dashboards for production ShopNest.Live.

Integration testing SignalR

[Fact]
public async Task JoinOrder_AddsConnectionToGroup()
{
    // Use WebApplicationFactory + TestServer for hub integration tests
    await hub.JoinOrder("ORD-123");
}

Pattern recognition

One-way feeds → SSE. Chat, tracking, collaboration → SignalR. Custom binary protocol at massive scale → raw WebSockets. Multi-instance → Redis or Azure SignalR Service.

Common errors & fixes

🔴 Mistake 1: Broadcasting to All clients for order-specific updates
✅ Fix: Use Groups: await Groups.AddToGroupAsync(connectionId, $"order-{id}");

🔴 Mistake 2: Missing JWT token on WebSocket negotiate
✅ Fix: Pass accessTokenFactory in JS client or ?access_token= query with OnMessageReceived.

🔴 Mistake 3: No reconnection handler on client disconnect
✅ Fix: connection.onclose + start() with exponential backoff; show "Reconnecting…" UI.

🔴 Mistake 4: Deploying multiple instances without backplane
✅ Fix: Messages sent on server A never reach clients on server B — add Redis or Azure SignalR.

Best practices

• 🟢 Use Groups instead of Clients.All for targeted broadcasts
• 🟢 Enable Redis backplane or Azure SignalR before second API instance
• 🟡 Prefer SSE for one-way dashboards; SignalR for bidirectional features
• 🟡 Implement client reconnection with exponential backoff
• 🔴 Never expose hub methods without [Authorize] in production
• 🔴 Monitor connection count and message throughput in Grafana

Interview questions

Fresher level

Q1: Explain CQRS Integration in a system design interview.
A: Compare polling vs WebSocket vs SSE vs SignalR; state when you pick each; mention scale-out.

Q2: How does SignalR scale horizontally?
A: Redis backplane or Azure SignalR Service publishes messages to all server instances.

Q3: SignalR vs raw WebSockets?
A: SignalR gives hubs, groups, auth integration, transport fallback — WebSockets give full protocol control.

Mid / senior level

Q4: When would you choose SSE over SignalR?
A: One-way streams: stock tickers, live logs, notification feeds — simpler HTTP, auto-reconnect in EventSource.

Q5: How do you authenticate SignalR connections?
A: JWT via accessTokenFactory; [Authorize] on hub; Context.UserIdentifier for user-targeted messages.

Q6: What metrics do you monitor in production?
A: Active connections, messages/sec, reconnect rate, hub method latency, Redis publish lag.

Coding round

Implement CQRS Integration for ShopNest SCALING: show interface, concrete class, DI registration, and xUnit test with mock.

public class CQRSIntegrationPatternTests
{
    [Fact]
    public async Task ExecuteAsync_ReturnsSuccess()
    {
        var mock = new Mock();
        mock.Setup(s => s.ExecuteAsync(It.IsAny(), default))
            .ReturnsAsync(Result.Success("test-id"));
        var result = await mock.Object.ExecuteAsync(new Request("test-id"));
        Assert.True(result.IsSuccess);
    }
}

Summary & next steps

• Article 59: CQRS Integration — Complete Guide
• Module: Module 6: Scaling and Distributed Systems · Level: ADVANCED
• Applied to ShopNest.Live — SCALING

Previous: Kafka Integration — Complete Guide
Next: Event-Driven Architecture — Complete Guide

Practice: Add one small feature using today's pattern — commit with feat(signalr-sse): article-59.

FAQ