.NET Development Course

Lesson 1 • Collections and Iteration

Explores arrays, lists, and dictionaries alongside iteration patterns. Prepares students to manage data sets in real application logic.

Lesson 2 • Error Handling and Debugging

Covers exception types, try-catch-finally blocks, and Visual Studio debugger usage. Equips students to diagnose and recover from runtime failures.

Lesson 3 • The .NET Ecosystem Overview

Covers the runtime, SDK, and CLI toolchain that power .NET applications. Establishes the platform mental model needed for every subsequent chapter.

Lesson 4 • C# Language Syntax Basics

Introduces variables, data types, operators, and control flow. Provides the syntactic foundation required before tackling object-oriented design.

Lesson 1 • Inheritance and Polymorphism

Teaches base and derived class relationships, method overriding, and virtual dispatch. Enables students to model hierarchical domain concepts cleanly.

Lesson 2 • Classes, Objects, and Constructors

Defines class anatomy, object instantiation, and constructor overloading. Grounds OOP concepts in concrete C# syntax before advancing to inheritance.

Lesson 3 • Interfaces and Contracts

Explains interface declaration, implementation, and default interface members. Bridges OOP design to the dependency-inversion principle used in later chapters.

Lesson 4 • SOLID Principles in Practice

Applies all five SOLID principles to refactor poorly designed classes. Prepares students for the architectural patterns introduced in later chapters.

Lesson 1 • Pattern Matching and Records

Explores switch expressions, positional patterns, and record types for immutable data. Modernizes code style and reduces boilerplate in domain models.

Lesson 2 • Generics and Type Constraints

Teaches generic classes, methods, and constraint syntax for type safety. Enables reusable algorithms without sacrificing compile-time correctness.

Lesson 3 • Delegates, Events, and Lambdas

Covers delegate types, multicast delegates, event patterns, and lambda expressions. Establishes the functional building blocks used throughout LINQ and async code.

Lesson 4 • LINQ Queries and Operators

Introduces query syntax and method syntax for filtering, projecting, and aggregating data. Directly enables data-access patterns covered in the Entity Framework chapter.

Lesson 1 • Asynchronous Programming with async/await

Explains the Task-based asynchronous pattern and state machine compilation. Enables students to write I/O-bound code without blocking threads.

Lesson 2 • Task Parallel Library Patterns

Covers Parallel.For, Parallel.ForEach, and Task.WhenAll for CPU-bound work. Connects parallel decomposition to real data-processing scenarios.

Lesson 3 • Channels and Dataflow Pipelines

Introduces System.Threading.Channels and TPL Dataflow for producer-consumer pipelines. Prepares students for high-throughput streaming architectures.

Lesson 1 • Relationships and Navigation Properties

Models one-to-many, many-to-many, and one-to-one relationships in EF Core. Ensures correct foreign key and cascade behavior in complex domain models.

Lesson 2 • Migrations and Schema Management

Teaches creating, applying, and reverting migrations to manage database schema. Connects code-first modeling to real deployment workflows.

Lesson 3 • DbContext and Entity Configuration

Covers DbContext setup, entity classes, and Fluent API configuration. Establishes the data model foundation for all subsequent EF Core operations.

Lesson 4 • Performance and Advanced EF Patterns

Addresses query splitting, compiled queries, and the repository pattern. Optimizes data-layer throughput and decouples persistence from business logic.

Lesson 1 • Configuration and Options Pattern

Teaches appsettings.json, environment variables, and the IOptions<T> pattern. Enables environment-specific configuration without code changes.

Lesson 2 • Built-In Dependency Injection Container

Covers service registration, lifetimes, and constructor injection in .NET. Establishes the IoC foundation that underpins every ASP.NET Core application.

Lesson 3 • Layered and Clean Architecture

Structures projects into domain, application, infrastructure, and presentation layers. Enforces dependency rules that keep business logic free of framework concerns.

Lesson 4 • MediatR and CQRS Pattern

Implements command-query responsibility segregation using MediatR handlers. Decouples request handling from controllers and simplifies cross-cutting concerns.

Lesson 1 • API Documentation and Versioning

Integrates OpenAPI/Swagger documentation and URL-based API versioning. Improves developer experience and supports backward-compatible API evolution.

Lesson 2 • ASP.NET Core Request Pipeline

Explains middleware, the host builder, and the HTTP request lifecycle. Provides the architectural context needed to configure any ASP.NET Core application.

Lesson 3 • Controller-Based and Minimal APIs

Compares ApiController attribute routing with minimal API endpoint mapping. Enables students to choose the right API style for each project context.

Lesson 4 • Authentication and Authorization

Implements JWT bearer authentication and policy-based authorization in APIs. Secures endpoints against unauthorized access using industry-standard patterns.

Lesson 1 • Test-Driven Development Workflow

Applies red-green-refactor cycles to drive feature implementation from tests. Builds disciplined habits that reduce defect rates in production code.

Lesson 2 • Unit Testing with xUnit and Moq

Covers xUnit test anatomy, assertions, and mocking dependencies with Moq. Validates individual units of logic in isolation from infrastructure.

Lesson 3 • Integration Testing ASP.NET Core APIs

Uses WebApplicationFactory to spin up in-process test servers for API testing. Validates full request pipelines including middleware and database interactions.

Lesson 4 • Observability and Health Monitoring

Integrates structured logging, distributed tracing, and health-check endpoints. Provides the operational visibility needed to diagnose issues in production.