This is Chapter 90. What started as “Getting started with C# fundamentals” in Chapter 1 has grown into a production-grade, Clean Architecture classified website deployed on Azure with CI/CD, monitoring, real-time notifications, Stripe payments, and a comprehensive test suite. Every pattern in the series — from async/await to CQRS, from reactive forms to SignalR — appears somewhere in the classified website. This final lesson traces the complete journey and points to what comes next.
The Complete Architecture
// ── Complete classified website architecture in one view ───────────────────
// ════════════════════════════════════════════════════════════════════════════
// DOMAIN LAYER (ClassifiedApp.Domain)
// ════════════════════════════════════════════════════════════════════════════
// Entities: Listing, ContactRequest, PremiumPromotion, Notification
// Value Objects: Money, Location, ListingPhoto
// Domain Events: ListingPublishedEvent, ContactRequestSentEvent, ...
// Specifications: ActiveListingsInCategorySpec, ExpiredListingsSpec, ...
// Interfaces: IListingRepository, IContactRequestRepository
// Exceptions: DomainException, NotFoundException, ForbiddenException
// ════════════════════════════════════════════════════════════════════════════
// APPLICATION LAYER (ClassifiedApp.Application)
// ════════════════════════════════════════════════════════════════════════════
// Commands: CreateListing, PublishListing, SendContactRequest,
// ModeratorListing, RegisterAsSeller, ActivatePremiumPromotion
// Queries: SearchListings, GetListingById, GetMyListings,
// AdminSearchListings, GetNotifications
// Behaviours: ValidationBehaviour, TransactionBehaviour, LoggingBehaviour
// Event Handlers: NotifySellerOnContactRequest, SendPublishedEmail,
// TrackListingPublished, TrackSearchQuery
// Interfaces: IEmailService, IBlobStorage, IStripeService,
// IViewCounterService, ICurrentUserService
// ════════════════════════════════════════════════════════════════════════════
// INFRASTRUCTURE LAYER (ClassifiedApp.Infrastructure)
// ════════════════════════════════════════════════════════════════════════════
// Persistence: AppDbContext, ListingRepository, EF Core configurations
// Identity: ApplicationUser, UserService (wraps ASP.NET Core Identity)
// Payments: StripeService (Stripe.net SDK)
// Storage: AzureBlobStorage (Azure.Storage.Blobs SDK)
// Email: EmailService (SendGrid)
// Caching: RedisViewCounterService (StackExchange.Redis)
// Jobs: ListingExpiryJob, OrphanedPhotoCleanupJob,
// PremiumExpiryJob, ViewCountFlushJob
// ════════════════════════════════════════════════════════════════════════════
// PRESENTATION LAYER (ClassifiedApp.Api + Angular)
// ════════════════════════════════════════════════════════════════════════════
// Controllers: ListingsController, ContactsController, AdminController,
// AuthController, WebhooksController, UploadsController
// Hubs: ClassifiedHub (SignalR, Azure SignalR Service)
// Middleware: GlobalExceptionHandler, ProblemDetails, HTTPS, CORS,
// Rate Limiting, JWT Authentication
// Angular: BrowseComponent, ListingDetailComponent,
// CreateListingWizardComponent, MyListingsComponent,
// SellerRegistrationComponent, NotificationsService,
// SearchStateService, AuthService
// ════════════════════════════════════════════════════════════════════════════
// AZURE INFRASTRUCTURE
// ════════════════════════════════════════════════════════════════════════════
// App Service: ASP.NET Core API (2-5 instances, autoscale)
// Azure SQL: Classified data (General Purpose, 2 vCores)
// Azure Redis: View counts, sessions (C1 Standard)
// Azure SignalR: Real-time hub (Standard S1)
// Blob + CDN: Listing photos (3 variants, WebP, 1-year cache)
// Static Web App: Angular frontend
// Key Vault: All secrets
// App Insights: Monitoring, distributed tracing, custom metrics
// GitHub Actions: CI/CD (build → test → staging → approve → production)Skills Mastered Across 90 Chapters
| Part | What You Can Now Build |
|---|---|
| 1 — C# (Ch 1–16) | Generic collections, async/await, LINQ, pattern matching, records |
| 2 — .NET Core (Ch 17–24) | DI containers, configuration, logging, hosted services, HTTPS |
| 3 — MVC (Ch 25–32) | Razor views, routing, validation, filters, ASP.NET Identity |
| 4 — Web API (Ch 33–46) | REST APIs, JWT auth, EF Core, caching, SignalR, file uploads |
| 5 — Angular (Ch 47–60) | Signals, RxJS, routing, forms, NgRx, Material, security |
| 6 — SQL Server (Ch 61–70) | T-SQL, stored procs, indexes, transactions, EF Core deep dive |
| 7 — Integration (Ch 71–76) | CORS, full-stack CRUD, file handling, real-time, error handling |
| 8 — Testing (Ch 77–84) | xUnit, Moq, WebApplicationFactory, Cypress, CI coverage |
| 9 — Capstone (Ch 85–90) | Clean Architecture, CQRS, MediatR, payments, deployment |
Note: You have completed one of the most comprehensive C# full-stack courses available. You have built two complete applications from scratch (the BlogApp across Parts 1-8 and the Classified Website in Part 9), implementing patterns that are used in production systems at scale. The patterns you now know — Clean Architecture, CQRS, domain events, JWT with refresh tokens, CI/CD with blue-green deployments, and distributed caching — are exactly what employers and clients look for in senior full-stack developers.
Tip: What to build next: (1) Add Azure Cognitive Search for full-text listing search — far more powerful than SQL LIKE queries. (2) Add real-time chat between buyers and sellers using SignalR rooms. (3) Build a .NET MAUI mobile app for Android/iOS using the same ASP.NET Core API — reuse all your backend knowledge. (4) Migrate the classified website to microservices — separate the listings service, auth service, and notifications service. (5) Add machine learning for listing price suggestions using ML.NET. Each of these is a complete project that deepens the skills you have built.
Final thought: The classified website in Part 9 is intentionally over-engineered compared to what a production MVP needs. Clean Architecture, CQRS, and MediatR add significant complexity for a small team or solo developer. The value of learning these patterns is not that you should always use them — it is that you understand them deeply enough to use them when the project genuinely warrants them, and to recognise when simpler patterns (a service layer, a repository, a direct controller) are the correct choice. Master the patterns, then apply judgement about when each is appropriate.
🎓 Series Complete — Congratulations!
You have completed the C# Full-Stack: ASP.NET Core Web API, SQL Server and Angular series — 90 chapters, 450 lessons, covering the complete journey from C# fundamentals to production deployment. Go build something great.