Publish-Subscribe Pattern — Complete Guide

Introduction

Publish-Subscribe Pattern — Complete Guide is essential for .NET architects building ShopNest Enterprise Architecture Platform — Toolliyo's 69-article design patterns master path covering GoF creational, structural, and behavioral patterns; enterprise patterns (Repository, CQRS, Saga, Outbox); microservices; ASP.NET Core architecture; and senior interview prep. Every article includes minimum two mandatory real-world examples.

In Indian delivery projects (TCS, Infosys, Wipro), interviewers expect publish-subscribe with real banking, e-commerce, or SaaS examples — not toy animal demos. This article delivers production depth on Notifications.

After this article you will

• Explain Publish-Subscribe in plain English and in enterprise architecture terms
• Implement Publish-Subscribe in ShopNest Enterprise Architecture (Notifications)
• Compare anti-pattern vs production-ready pattern implementation
• Answer fresher and senior design pattern interview questions confidently
• Connect this lesson to Article 45 and the 69-article Design Patterns roadmap

Prerequisites

• Software: .NET 10 SDK, VS 2022 or VS Code, xUnit + Moq
• Knowledge: C# basics, SOLID principles
• Previous: Article 43 — Domain Events Pattern — Complete Guide
• Time: 24 min reading + 30–45 min hands-on

Concept deep-dive

Level 1 — Analogy

Publish-Subscribe on ShopNest Enterprise Architecture is a proven blueprint for the Publish-Subscribe problem in growing platforms.

Level 2 — Technical

Publish-Subscribe structures enterprise ShopNest Notifications — persistence abstraction, command/query split, reliable messaging, and resilience with Polly.

Level 3 — Architecture placement

[Client / API Gateway]
       ▼
[Application Layer — Handlers, Strategies, Commands]
       ▼
[Domain Layer — Entities, Domain Events, Specifications]
       ▼
[Infrastructure — EF Core, Message Bus, Polly, Cache]
       ▼
[Pattern Registration — Program.cs DI lifetimes]
       ▼
[xUnit + Moq — pattern behavior isolated]

Project structure

ShopNest.EnterpriseArchitecture/
├── ShopNest.Domain/           ← Entities, domain events, interfaces
├── ShopNest.Application/      ← Commands, queries, handlers (MediatR)
├── ShopNest.Infrastructure/   ← EF Core, Redis, RabbitMQ, Polly
├── ShopNest.Api/              ← ASP.NET Core Web API + Minimal APIs
├── ShopNest.Workers/          ← Hosted services, outbox processors
└── ShopNest.Gateway/          ← YARP API Gateway

Hands-on implementation — Notifications

Implement Publish-Subscribe in C# for Notifications: write a class or method, compile, and verify with a console or unit test.

1. Open a console or class library project.
2. Implement the concept in a focused class or method.
3. Add null checks and meaningful exception messages.
4. Run dotnet build and dotnet test.
5. Review naming and SOLID boundaries.

Anti-pattern (god class, swallowed exceptions, magic strings)

// ❌ BAD — no pattern, tight coupling, untestable
public class OrderController : ControllerBase {
    public IActionResult Place(OrderDto dto) {
        var conn = new SqlConnection("Server=.;...");
        // direct SQL, no repository, no UoW, no error handling
        return Ok();
    }
}

Production-style C# code

// ✅ CORRECT — Publish-Subscribe on ShopNest (Notifications)
public sealed class PlaceOrderHandler(
    IOrderRepository repo,
    IUnitOfWork uow,
    IPublisher events) : IRequestHandler<PlaceOrderCommand, Result<int>>
{
    public async Task<Result<int>> Handle(PlaceOrderCommand cmd, CancellationToken ct) {
        var order = Order.Create(cmd.CustomerId, cmd.Lines);
        await repo.AddAsync(order, ct);
        await events.Publish(new OrderPlacedEvent(order.Id), ct);
        await uow.SaveChangesAsync(ct);
        return Result.Success(order.Id);
    }
}

Complete example

public interface IPublish-SubscribeService { Task ExecuteAsync(CancellationToken ct); }
public sealed class Publish-SubscribeService : IPublish-SubscribeService { /* ShopNest Notifications */ }

Real-World Example 1 — Payment Gateway Integration

MANDATORY: Enterprise-grade Publish-Subscribe Pattern implementation in a production payment gateway integration.

Business requirement

External payment APIs fail intermittently; the system must handle timeouts, retries, and circuit breaks without double-charging customers.

Why Publish-Subscribe Pattern is needed

Without Publish-Subscribe Pattern, the Payment Gateway Integration team at ShopNest faces tight coupling, untestable code, and painful refactors every sprint. Publish-Subscribe Pattern decouples responsibilities so the Notifications module can evolve independently while meeting scalability and compliance requirements.

Architecture

[Client/API] → [Publish-Subscribe Pattern Abstraction]
  → [ShopNest.Notifications Service] → [EF Core / Redis / Message Bus]
  → [Downstream: Audit, Notifications, Reporting]

Tech stack: ASP.NET Core, HttpClientFactory, Polly retry/circuit breaker, structured logging with Serilog

Full working code

// REAL-WORLD EXAMPLE 1: Payment Gateway Integration
// ShopNest Enterprise Architecture — Notifications module
// Pattern: Publish-Subscribe

namespace ShopNest.Architecture.Notifications;

public interface IPublish-SubscribeService
{
    Task ExecuteAsync(Publish-SubscribeRequest request, CancellationToken ct = default);
}

public sealed class PaymentGatewayIntegrationPublish-SubscribeService : IPublish-SubscribeService
{
    private readonly ILogger _logger;

    public PaymentGatewayIntegrationPublish-SubscribeService(ILogger logger)
        => _logger = logger;

    public async Task ExecuteAsync(Publish-SubscribeRequest request, CancellationToken ct)
    {
        _logger.LogInformation("[Publish-Subscribe] Processing {Domain} request {Id}",
            "Payment Gateway Integration", request.Id);

        // Production implementation — see Program.cs for DI registration
        await Task.Delay(10, ct);
        return Result.Success(request.Id);
    }
}

// Register in Program.cs:
// builder.Services.AddScoped();

Benefits achieved

• Loose coupling — swap implementations without changing controllers
• Unit testable — mock IPublish-SubscribeService in xUnit tests
• Scalable — horizontal scaling of Notifications workers under load
• Maintainable — new business rules added via new classes, not if-else chains

Real-World Example 2 — Hospital Management System

MANDATORY: Second complete example in a different domain — Hospital Management System.

Business problem

Patient records, appointments, billing, and lab results involve multiple departments with different access policies and HIPAA-style audit requirements.

Why Publish-Subscribe Pattern solves it

In Hospital Management System, Indian IT delivery teams (TCS, Infosys, Wipro lateral rounds) frequently ask how Publish-Subscribe Pattern applies to distributed systems. This example shows production-level implementation with ASP.NET Core integration, not toy animal/car demos.

Production implementation

// REAL-WORLD EXAMPLE 2: Hospital Management System
// ShopNest Enterprise Architecture — Notifications module
// Pattern: Publish-Subscribe

namespace ShopNest.Architecture.Notifications;

public interface IPublish-SubscribeService
{
    Task ExecuteAsync(Publish-SubscribeRequest request, CancellationToken ct = default);
}

public sealed class HospitalManagementSystemPublish-SubscribeService : IPublish-SubscribeService
{
    private readonly ILogger _logger;

    public HospitalManagementSystemPublish-SubscribeService(ILogger logger)
        => _logger = logger;

    public async Task ExecuteAsync(Publish-SubscribeRequest request, CancellationToken ct)
    {
        _logger.LogInformation("[Publish-Subscribe] Processing {Domain} request {Id}",
            "Hospital Management System", request.Id);

        // Production implementation — see Program.cs for DI registration
        await Task.Delay(10, ct);
        return Result.Success(request.Id);
    }
}

// Register in Program.cs:
// builder.Services.AddScoped();

Scalability benefits

• Supports multi-region deployment on Azure with independent scaling
• Integrates with ShopNest distributed events (RabbitMQ) for async workflows
• Redis caching reduces database load for read-heavy Hospital operations
• Polly resilience policies handle transient failures in cloud-native environments

Pattern variations & ASP.NET Core integration

Modern C# 14 uses primary constructors, records, and DI. Register Publish-Subscribe abstractions in Program.cs with appropriate lifetimes — Singleton for stateless, Scoped for request-bound, Transient for lightweight factories.

Microservices: Apply Publish-Subscribe within bounded contexts — each ShopNest service (Notifications) owns its implementation.

Pattern comparison & when NOT to use

Compare Publish-Subscribe with similar patterns. Avoid overengineering — if a simple function or DI registration suffices, do not force a pattern. Senior architects value judgment over pattern count.

Unit testing the pattern

public class Publish-SubscribePatternTests
{
    [Fact]
    public async Task ExecuteAsync_ReturnsSuccess()
    {
        var mock = new Mock<IPublish-SubscribeService>();
        mock.Setup(s => s.ExecuteAsync(default)).ReturnsAsync(Result.Success());
        var result = await mock.Object.ExecuteAsync(default);
        Assert.True(result.IsSuccess);
    }
}

Pattern recognition

Object creation pain → Creational. Composing subsystems → Structural. Algorithm/communication variation → Behavioral. Persistence/messaging → Enterprise. Multi-service → Cloud patterns. ASP.NET pipeline → Middleware/Options/Hosted Service.

Common errors & fixes

• Singleton with mutable state shared across requests — Use Singleton only for stateless services; keep request state Scoped.
• Factory explosion — new class per trivial variation — Use Strategy or simple DI when behavior differs slightly, not Abstract Factory.
• Repository wrapping every EF call without domain logic — Repository adds value for testability and query composition — not as a pass-through.
• Saga/CQRS on a CRUD app with 3 tables — Start with simple layered architecture; add patterns when complexity demands.

Best practices

• 🟢 Name patterns by problem solved, not GoF catalog page number
• 🟢 Register abstractions in DI — depend on interfaces, not concretions
• 🟡 Match DI lifetime to pattern (Singleton vs Scoped)
• 🟡 Write one xUnit test proving the pattern's core behavior
• 🔴 Do not apply Saga/CQRS/Event Sourcing on simple CRUD
• 🔴 Document when you chose NOT to use a pattern — interviews love this

Interview questions

Fresher level

Q1: What is the Publish-Subscribe pattern and when would you use it?
A: Publish-Subscribe solves a specific recurring problem on ShopNest Notifications. Explain intent, structure (participants), and one real example — then state when NOT to use it.

Q2: Publish-Subscribe vs similar patterns — how do you choose?
A: Compare intent and consequences; e.g. Strategy vs State, Repository vs DAO, Mediator vs Observer — pick by change axis.

Q3: How do design patterns relate to SOLID?
A: Patterns implement SOLID — Strategy/OCP, Repository/DIP, SRP via focused classes. SOLID is why; patterns are how.

Mid / senior level

Q4: Repository pattern — benefits and pitfalls?
A: Benefits: testability, query composition. Pitfalls: leaky abstraction, generic repo anti-pattern, duplicating EF features.

Q5: When would you NOT use a design pattern?
A: Simple CRUD, prototypes, or single-developer utilities — YAGNI until complexity appears.

Q6: How are patterns asked in TCS/Infosys lateral interviews?
A: Scenario-based: "Design payment retry" → Retry + Circuit Breaker; "Split monolith" → Strangler + API Gateway.

Coding round

Implement Publish-Subscribe for ShopNest Notifications: interface, concrete class, DI registration, and xUnit test with Moq.

builder.Services.AddScoped<IPublish-SubscribeService, Publish-SubscribeService>();

public sealed class Publish-SubscribeService : IPublish-SubscribeService
{
    public Task<Result> ExecuteAsync(CancellationToken ct) => Task.FromResult(Result.Success());
}

Summary & next steps

• Article 44: Publish-Subscribe Pattern — Complete Guide
• Module: Module 5: Modern Enterprise Patterns · Level: INTERMEDIATE · Type: ENTERPRISE
• Applied to ShopNest Enterprise Architecture — Notifications

Previous: Domain Events Pattern — Complete Guide
Next: API Gateway Pattern — Complete Guide

Practice: Apply today's pattern in one module — commit with feat(patterns): article-44.

FAQ