← Back to .NET Made Easy

Full Course Contents

Every lesson in the free .NET Made Easy course, in order. Each one is a complete, self-contained written lesson — open any of them directly, or use the interactive course player to track your progress as you go.

The course runs in three tiers. If you are new to C#, start at the top of Foundations and work down. If you already write C# professionally, skip to Production .NET.

315
Lessons
3
Tiers
28
Parts
Free
No signup

C# Foundations

Start here if you have never written C#. Syntax, types, control flow, and object-oriented programming, built up one concept at a time with nothing assumed.

59 lessons · 7 parts

Part I — C# and .NET

  1. What Are C# and .NET?
  2. Setting Up the Modern Environment
  3. Your First C# Application

Part II — Language Fundamentals

  1. Variables and Constants
  2. Built-in Data Types
  3. Strings and Text
  4. Type Conversion
  5. Operators
  6. Control Flow
  7. Methods

Part III — Object-Oriented C#

  1. Classes and Objects
  2. Fields and Properties
  3. Constructors
  4. Static Members
  5. Access Modifiers
  6. Encapsulation
  7. Value vs Reference Types
  8. Structs
  9. Enums
  10. Inheritance
  11. Polymorphism
  12. Overloading and Overriding
  13. Interfaces — First Look
  14. Composition vs Inheritance

Part IV — Collections and Data

  1. Arrays
  2. Multidimensional Arrays
  3. Jagged Arrays
  4. Lists
  5. Dictionaries
  6. HashSet
  7. Stack and Queue
  8. Collection Interfaces
  9. IEnumerable — First Look

Part V — Errors, Files and Dates

  1. Exception Handling
  2. Creating and Throwing
  3. File and Directory Operations
  4. Paths
  5. Streams — Introduction
  6. DateTime and DateTimeOffset
  7. Time Zones
  8. Working with JSON
  9. Serialization

Part VI — Modern C# Fundamentals

  1. Nullable Reference Types
  2. Null-Safe Programming
  3. Pattern Matching
  4. Records — Introduction
  5. Tuples & Deconstruction
  6. Modern Switch Expressions
  7. Modern Collection Expressions
  8. required Members
  9. Primary Constructors

Part VII — Practical Development

  1. Debugging C# Applications
  2. Reading Stack Traces
  3. Writing Clean C#
  4. Naming Conventions
  5. Common Beginner Mistakes
  6. Project: Expense Tracker
  7. Project: Employee System
  8. Fundamentals Challenge

C# In Practice

The idioms a working .NET developer uses every day — generics, collections, LINQ, async/await, dependency injection, data access, and testing.

90 lessons · 8 parts

Part I — Advanced OOP

  1. OOP Revisited
  2. Encapsulation in Real Applications
  3. Inheritance
  4. Composition
  5. Polymorphism
  6. Abstract Classes
  7. Sealed Classes and Members
  8. Interfaces
  9. Multiple Interface Implementation
  10. Interface Segregation
  11. Explicit Interface Implementation
  12. Dependency Inversion

Part II — Generics & Collections

  1. Generics
  2. Generic Classes
  3. Generic Methods
  4. Generic Constraints
  5. where Constraints
  6. Covariance and Contravariance
  7. Generic Collections
  8. Dictionary Internals
  9. Equality and Hashing
  10. IComparable
  11. IEquatable
  12. Custom Collections

Part III — Delegates & Functional C#

  1. Delegates
  2. Custom Delegates
  3. Action
  4. Func
  5. Predicate
  6. Lambda Expressions
  7. Closures
  8. Local Functions
  9. Higher-Order Functions
  10. Events
  11. Event Patterns
  12. Event-Driven Design

Part IV — LINQ

  1. Introduction to LINQ
  2. IEnumerable and IQueryable
  3. Filtering
  4. Projection
  5. Sorting
  6. Grouping
  7. Joining
  8. Aggregation
  9. Deferred Execution
  10. Immediate Execution
  11. LINQ Query Syntax
  12. LINQ Method Syntax
  13. Custom LINQ Extensions
  14. LINQ Performance

Part V — Modern .NET Dev

  1. Dependency Injection
  2. Service Lifetimes
  3. Configuration
  4. Options Pattern
  5. Logging
  6. Environment-Based Configuration
  7. HTTP Client
  8. JSON APIs
  9. REST Fundamentals
  10. OpenAPI

Part VI — Data Access

  1. ADO.NET Fundamentals
  2. Database Connections
  3. Commands
  4. Parameters
  5. Transactions
  6. Entity Framework Core
  7. DbContext
  8. Entities
  9. Relationships
  10. Migrations
  11. LINQ with EF Core
  12. Tracking vs No-Tracking
  13. Transactions and Concurrency
  14. Repository Pattern — When and Why

Part VII — Async Programming

  1. Synchronous vs Asynchronous
  2. Task and Task
  3. async / await
  4. CancellationToken
  5. Task.WhenAll
  6. Task.WhenAny
  7. Exception Handling in Async
  8. Async Streams
  9. IAsyncEnumerable
  10. Common Async Mistakes

Part VIII — Intermediate Projects

  1. REST API Project
  2. Employee Management API
  3. EF Core Database Project
  4. Notification Service
  5. Background Processing Service
  6. Intermediate C# Challenge

Production .NET

How .NET behaves under real load: language internals, memory and performance, architecture, distributed systems, cloud deployment, security, observability, and production debugging — closing with a full capstone build.

166 lessons · 13 parts

Part I — Advanced C# Language

  1. How Modern C# Executes
  2. CLR and Runtime Internals
  3. JIT Compilation
  4. Garbage Collection
  5. Generational GC
  6. Memory Allocation
  7. Stack vs Heap
  8. Boxing and Unboxing
  9. Value Types vs Reference Types
  10. Records and Record Structs
  11. Pattern Matching in Depth
  12. Advanced Generics
  13. Variance
  14. Reflection
  15. Attributes
  16. Source Generators — Intro

Part II — Delegates & Events

  1. Advanced Delegates
  2. Action / Func / Predicate
  3. Expression Trees
  4. Lambda Internals
  5. Closures
  6. Advanced Events
  7. Event Aggregation
  8. Extension Methods
  9. C# 14 Extension Members

Part III — LINQ Deep Dive

  1. IEnumerable Internals
  2. IQueryable
  3. Expression Trees
  4. Deferred Execution
  5. LINQ Performance
  6. Custom LINQ Operators
  7. LINQ to Objects
  8. LINQ to EF Core
  9. LINQ and SQL Translation
  10. Avoiding LINQ Performance Traps

Part IV — Async & Concurrency

  1. Task Internals
  2. Synchronization Context
  3. ThreadPool
  4. ValueTask
  5. Cancellation
  6. Parallel Programming
  7. Parallel.ForEach
  8. Channels
  9. Concurrent Collections
  10. Locking and Synchronization
  11. Race Conditions
  12. Deadlocks
  13. Thread-Safe Design
  14. Async Streams
  15. High-Throughput Async

Part V — Memory & Performance

  1. Span
  2. ReadOnlySpan
  3. Memory
  4. ArrayPool
  5. MemoryPool
  6. ref / in / out
  7. ref struct
  8. stackalloc
  9. Zero-Allocation Programming
  10. Performance Benchmarking
  11. Profiling .NET Applications

Part VI — Architecture & Design

  1. SOLID Principles
  2. Clean Code
  3. Coupling and Cohesion
  4. Dependency Injection at Scale
  5. Design Patterns
  6. Factory Pattern
  7. Strategy Pattern
  8. Decorator Pattern
  9. Adapter Pattern
  10. Observer Pattern
  11. Builder Pattern
  12. Mediator Pattern
  13. Repository Pattern
  14. Unit of Work
  15. Clean Architecture
  16. Hexagonal Architecture
  17. Domain-Driven Design

Part VII — Production ASP.NET

  1. ASP.NET Core Architecture
  2. Middleware
  3. Filters
  4. Minimal APIs
  5. Controllers
  6. Model Binding
  7. Validation
  8. Authentication
  9. Authorization
  10. JWT
  11. OAuth / OpenID Connect
  12. Rate Limiting
  13. Caching
  14. Distributed Caching
  15. Resilience & Fault Handling
  16. Health Checks
  17. Observability
  18. OpenTelemetry

Part VIII — Enterprise Data

  1. Advanced EF Core
  2. Query Optimization
  3. Compiled Queries
  4. Transactions
  5. Concurrency
  6. Database Connection Mgmt
  7. Stored Procedures
  8. Bulk Operations
  9. Caching Strategies
  10. SQL vs EF Core
  11. DB Performance Troubleshooting

Part IX — Distributed Systems

  1. REST API Architecture
  2. Microservices
  3. Message-Based Architecture
  4. Queues
  5. Kafka Fundamentals
  6. Event-Driven Architecture
  7. Idempotency
  8. Retries
  9. Circuit Breakers
  10. Distributed Transactions
  11. Outbox Pattern
  12. Eventual Consistency

Part X — Cloud and Containers

  1. Configuration for Cloud
  2. Docker and .NET
  3. Containerized ASP.NET Core
  4. Environment Variables
  5. Secrets Management
  6. Health Probes
  7. Logging and Observability
  8. Scaling .NET Applications
  9. Cloud-Native .NET
  10. .NET Aspire — Introduction

Part XI — Testing & Prod Eng

  1. Unit Testing
  2. Integration Testing
  3. Mocking
  4. Testcontainers
  5. API Testing
  6. Performance Testing
  7. Load Testing
  8. Debugging Production Issues
  9. Memory Leaks
  10. High CPU
  11. Deadlocks
  12. Thread Pool Starvation
  13. Database Bottlenecks
  14. Production Incident Analysis

Part XII — Modern C# 14

  1. What's New in C# 14
  2. Extension Members
  3. field Backed Properties
  4. Null-Conditional Assignment
  5. Enhanced Span Conversions
  6. Lambda Parameter Modifiers
  7. Partial Constructors
  8. User-Defined Compound Assignment
  9. Modern File-Based Apps

Part XIII — Capstone

  1. Designing Enterprise Apps
  2. Clean Architecture
  3. Authentication
  4. Database
  5. Caching
  6. Background Processing
  7. Messaging
  8. Logging
  9. Monitoring
  10. Testing
  11. Containerization
  12. Performance Optimization
  13. Production Deployment
  14. Final Architecture Review