Variables & Data Types

var message = "Hello World"; // Compiler knows this is a string
var count = 10;            // Compiler knows this is an int

int myInt = 9;
double myDouble = myInt; // Automatic: int becomes double

double myDouble = 9.78;
int myInt = (int)myDouble; // Manual: 9.78 becomes 9 (decimals are dropped)

const double Pi = 3.14159;
const string CompanyName = "TechCorp Inc";

// Pi = 3.15; // ❌ This will cause a compile-time error

Operators & Expressions

int score = 100;

score += 10; // Same as: score = score + 10; (110)
score -= 5;   // Same as: score = score - 5;   (105)
score *= 2;   // Same as: score = score * 2;   (210)
score /= 10;  // Same as: score = score / 10;  (21)

int age = 20;
string status = (age >= 18) ? "Adult" : "Minor";
// If age >= 18 is true, result is "Adult". Otherwise, "Minor".

string input = null;
string displayName = input ?? "Guest User";
// If input is null, displayName becomes "Guest User".

Control Flow: Decision Making

int userAge = 20;

if (userAge >= 21) 
{
    Console.WriteLine("Access Granted: Full Access.");
} 
else if (userAge >= 18) 
{
    Console.WriteLine("Access Granted: Limited Access.");
} 
else 
{
    Console.WriteLine("Access Denied: Underage.");
}

string role = "Admin";

switch (role)
{
    case "Admin":
        Console.WriteLine("Full System Access.");
        break; 
    case "Editor":
        Console.WriteLine("Content Management Access.");
        break;
    case "Guest":
        Console.WriteLine("Read-Only Access.");
        break;
    default:
        Console.WriteLine("Unknown Role: Access Denied.");
        break;
}

int dayNumber = 3;

string dayName = dayNumber switch
{
    1 => "Monday",
    2 => "Tuesday",
    3 => "Wednesday",
    4 => "Thursday",
    5 => "Friday",
    _ => "Weekend" // The underscore (_) is the default case
};

Console.WriteLine($"Today is {dayName}");

if (user != null) {
    if (user.IsActive) {
        if (user.HasPermission) {
            // Do the actual work here...
        }
    }
}

if (user == null) return; 
if (!user.IsActive) return;
if (!user.HasPermission) return;

// Do the actual work here... (The code stays flat!)

Loops: Mastering Iteration

// Structure: (Initialization; Condition; Iterator)
for (int i = 0; i < 5; i++) 
{
    Console.WriteLine($"Processing item number: {i}");
}

bool isRunning = true;
while (isRunning) 
{
    Console.WriteLine("System is scanning...");
    // Logic to eventually set isRunning = false;
}

string input;
do 
{
    Console.WriteLine("Please enter 'exit' to stop:");
    input = Console.ReadLine();
} while (input != "exit");

string[] employees = { "Alice", "Bob", "Charlie" };

foreach (var name in employees) 
{
    Console.WriteLine($"Sending email to: {name}");
}

for (int i = 1; i <= 10; i++) 
{
    if (i == 3) continue; // Skip 3
    if (i == 7) break;    // Stop entirely at 7
    
    Console.WriteLine(i); // Output: 1, 2, 4, 5, 6
}

Methods & Parameters

What Are Methods?

Methods are reusable blocks of code that perform a specific task. Instead of writing the same logic multiple times, we place that logic inside a method and call it whenever needed.

Methods help make programs:

• Cleaner and easier to read
• Reusable and modular
• Easier to debug and maintain
• More organized in large applications

void SayHello() {
    Console.WriteLine("Hello World");
}

Once defined, the method can be called anywhere in the program:

SayHello();
SayHello();
SayHello();

Defining Methods

A method definition usually contains:

• Access modifier (optional)
• Return type
• Method name
• Parameters
• Method body

static int Add(int x, int y) => x + y;

void Greet(string name, string title = "Dr.") {
    Console.WriteLine($"Hello {title} {name}");
}

Understanding Return Types

The return type tells C# what kind of value the method sends back.

• int → returns a whole number
• double → returns decimal values
• string → returns text
• bool → returns true or false
• void → returns nothing

int Square(int number) {
    return number * number;
}

Calling the method:

int result = Square(5);

Console.WriteLine(result);

Method Parameters

Parameters allow methods to receive data from outside. They act like variables that belong to the method.

void DisplayUser(string username, int age) {
    Console.WriteLine(username);
    Console.WriteLine(age);
}

Passing arguments into the method:

DisplayUser("Alex", 22);

Default Parameters

Default parameters provide fallback values when an argument is not supplied. This makes methods more flexible.

void Welcome(string name = "Guest") {
    Console.WriteLine($"Welcome {name}");
}

Welcome();
Welcome("Emma");

Expression-Bodied Methods

Small methods can be shortened using the lambda-style arrow syntax. This creates cleaner and shorter code.

int Multiply(int a, int b) => a * b;

Method Overloading

C# allows multiple methods with the same name as long as their parameters are different.

int Add(int a, int b) {
    return a + b;
}

double Add(double a, double b) {
    return a + b;
}

The compiler automatically selects the correct version.

Pass By Value

By default, C# passes arguments by value. This means the method receives a copy of the data.

void ChangeNumber(int num) {
    num = 100;
}

int value = 10;

ChangeNumber(value);

Console.WriteLine(value);

Output:

10

The original variable remains unchanged because only a copy was modified.

Using ref Parameters

The ref keyword passes variables by reference, allowing the method to directly modify the original variable.

void Increase(ref int number) {
    number++;
}

int score = 5;

Increase(ref score);

Console.WriteLine(score);

Using out Parameters

The out keyword is used when a method needs to return multiple values.

void GetValues(out int x, out int y) {
    x = 10;
    y = 20;
}

GetValues(out int a, out int b);

Console.WriteLine(a);
Console.WriteLine(b);

Local Methods

Methods can also exist inside another method. These are called local methods.

void MainMethod() {

    void PrintMessage() {
        Console.WriteLine("Inside Local Method");
    }

    PrintMessage();
}

Best Practices

• Keep methods short and focused
• Use meaningful method names
• Avoid methods that do too many tasks
• Reuse methods whenever possible
• Use parameters instead of hardcoded values

Common Mistakes

• Forgetting the return statement
• Using the wrong return type
• Passing incorrect argument types
• Creating methods with too many parameters
• Not understanding value vs reference passing

Mini Practice

Try creating the following methods yourself:

• A method that calculates area of a rectangle
• A method that checks if a number is even
• A method that prints a full name
• A method with a default parameter
• A method using ref or out

Collections & LINQ

What Are Collections?

Collections are data structures used to store and manage groups of objects. Instead of creating multiple individual variables, collections allow us to organize related data efficiently.

C# provides several built-in collection types that are powerful, flexible, and easy to use.

• Arrays
• Lists
• Dictionaries
• Queues
• Stacks
• HashSets

Why Use Collections?

Collections help developers work with large amounts of data dynamically. They make programs cleaner and more scalable.

• Store multiple values together
• Add or remove data dynamically
• Search and sort efficiently
• Loop through items easily
• Organize related information

Working with Lists

A List<T> is one of the most commonly used collections in C#. Unlike arrays, lists can grow and shrink dynamically.

var numbers = new List<int> { 10, 20, 30, 40 };

numbers.Add(50);

numbers.RemoveAt(0);

After removing the first element, the list becomes:

20, 30, 40, 50

Adding Items to a List

Use the Add() method to insert new items into a list.

var fruits = new List<string>();

fruits.Add("Apple");
fruits.Add("Banana");
fruits.Add("Orange");

Accessing List Elements

List items are accessed using indexes. Indexes start from 0.

Console.WriteLine(fruits[0]);

Console.WriteLine(fruits[1]);

Looping Through Lists

Lists are commonly used with loops to process every item.

foreach (var item in fruits) {
    Console.WriteLine(item);
}

Useful List Methods

Using Dictionaries

Dictionaries store data as key-value pairs. They are useful when each item has a unique identifier.

var students = new Dictionary<int, string>();

students.Add(1, "John");
students.Add(2, "Emma");

Console.WriteLine(students[1]);

Understanding LINQ

LINQ stands for Language Integrated Query. It allows developers to query collections using simple and readable syntax.

LINQ works with:

• Lists
• Arrays
• Dictionaries
• Databases
• XML data

Introduction to LINQ

LINQ (Language Integrated Query) allows you to query collections like SQL.

var highScores = numbers
    .Where(n => n > 25)
    .OrderByDescending(n => n);

This query:

• Filters numbers greater than 25
• Sorts them in descending order

The Where() Method

Where() filters data based on a condition.

var evenNumbers = numbers.Where(n => n % 2 == 0);

Only even numbers will be selected.

The Select() Method

Select() transforms data into another form.

var squared = numbers.Select(n => n * n);

This creates a new collection with squared values.

Sorting Data with LINQ

LINQ provides easy methods for sorting collections.

var ascending = numbers.OrderBy(n => n);

var descending = numbers.OrderByDescending(n => n);

Finding Data

LINQ can quickly search for matching values.

var firstLargeNumber = numbers.First(n => n > 25);

The first number greater than 25 will be returned.

Counting Items

The Count() method returns the total number of matching items.

int total = numbers.Count();

int evenCount = numbers.Count(n => n % 2 == 0);

Combining LINQ Methods

Multiple LINQ methods can be chained together for powerful queries.

var result = numbers
    .Where(n => n > 10)
    .OrderBy(n => n)
    .Select(n => n * 2);

Deferred Execution

Most LINQ queries use deferred execution. This means the query runs only when the data is actually used.

var query = numbers.Where(n => n > 20);

Console.WriteLine(query.Count());

Common LINQ Methods

Best Practices

• Use collections instead of many separate variables
• Choose the correct collection type for the task
• Keep LINQ queries readable
• Avoid overly complex chained queries
• Use meaningful variable names

Common Mistakes

• Using the wrong collection type
• Forgetting indexes start at 0
• Modifying collections during iteration
• Writing unreadable LINQ chains
• Ignoring null values in queries

Mini Practice

Try creating the following:

• A list of student names
• A dictionary of product prices
• A LINQ query that finds even numbers
• A query that sorts numbers descending
• A query using both Where() and Select()

Strings & Formatting

What Are Strings?

A string is a sequence of characters used to store text. Strings are one of the most commonly used data types in C#.

Examples of strings:

• Names
• Email addresses
• Messages
• User input
• File paths

string name = "John";

string message = "Welcome to C#";

Creating Strings

Strings are written inside double quotation marks.

string city = "London";

string language = "C#";

String Manipulation

C# provides many built-in methods for modifying and working with strings.

string text = "  C# Programming  ";

Console.WriteLine(text.Trim().ToUpper());

Console.WriteLine(text.Contains("C#"));

This example:

• Removes extra spaces using Trim()
• Converts text to uppercase using ToUpper()
• Checks if text contains a value using Contains()

Common String Methods

Converting Case

Strings can easily be converted between uppercase and lowercase.

string word = "Programming";

Console.WriteLine(word.ToUpper());

Console.WriteLine(word.ToLower());

Replacing Text

The Replace() method changes parts of a string.

string sentence = "I like Java";

sentence = sentence.Replace("Java", "C#");

Console.WriteLine(sentence);

Extracting Text

The Substring() method extracts a portion of a string.

string value = "Programming";

Console.WriteLine(value.Substring(0, 4));

Output:

Prog

Escaping Characters

Escape characters allow special characters inside strings.

Console.WriteLine("She said \"Hello\"");

Console.WriteLine("C:\\Projects\\App");

Verbatim Strings

Verbatim strings use the @ symbol to preserve formatting.

string path = @"
C:\Projects\MyApp\data.txt";

Console.WriteLine(path);

String Concatenation

Concatenation means joining strings together.

string firstName = "John";

string lastName = "Doe";

string fullName = firstName + " " + lastName;

Console.WriteLine(fullName);

String Interpolation

String interpolation is a cleaner way to insert variables into strings.

Console.WriteLine($"Date: {DateTime.Now:d}");

Console.WriteLine($"Price: {19.99:C}"); // Currency

The $ symbol allows variables and expressions inside curly braces.

Formatting Values

C# supports formatting numbers, dates, and currency values.

double price = 99.95;

Console.WriteLine($"{price:C}");

Console.WriteLine($"{price:N2}");

Console.WriteLine($"{price:P}");

Working with String Length

The Length property returns the number of characters.

string username = "Admin";

Console.WriteLine(username.Length);

Splitting Strings

The Split() method separates text into multiple parts.

string data = "HTML,CSS,JavaScript";

var skills = data.Split(',');

foreach (var skill in skills) {
    Console.WriteLine(skill);
}

Comparing Strings

Strings can be compared using comparison operators or helper methods.

string a = "C#";

string b = "c#";

Console.WriteLine(a == b);

Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));

String Immutability

Strings in C# are immutable. This means their contents cannot be changed after creation.

Methods like Replace() or ToUpper() create new strings instead of modifying the original one.

string textValue = "hello";

string upper = textValue.ToUpper();

Console.WriteLine(textValue);

Console.WriteLine(upper);

Best Practices

• Use meaningful variable names
• Prefer string interpolation over concatenation
• Trim user input when necessary
• Use formatting for readable output
• Keep string operations simple and readable

Common Mistakes

• Forgetting escape characters
• Using invalid indexes in Substring()
• Ignoring whitespace in user input
• Comparing strings with incorrect casing
• Confusing immutable behavior

Mini Practice

Try creating programs that:

• Convert text to uppercase
• Replace words in a sentence
• Display formatted prices
• Split a CSV string into values
• Create a formatted welcome message using interpolation

Object-Oriented Programming

Welcome, class. Today we deep-dive into the foundational architecture of scalable software design: Object-Oriented Programming (OOP). As software systems grow in complexity, linear, procedural code inevitably collapses under its own weight. OOP provides us with a framework to manage this complexity by partitioning our programs into self-contained, reusable modules modeled after real-world entities.

The Conceptual Paradigm: Blueprints vs. Artifacts

Before looking at the syntax, you must master the fundamental distinction between a Class and an Object:

• The Class (The Blueprint): This is an abstract data type. It defines the structure, capabilities, and rules of engagement, but it consumes no operational memory for data storage. It is merely a design.
• The Object (The Instance): This is the concrete artifact generated from that blueprint. It lives dynamically within your system's RAM, maintaining its own unique state.

Consider the architectural example below written in C#. Here, we define a baseline archetype (Person) and a specialized extension of that archetype (Developer).

public class Person {
    public string Name { get; set; }
    public virtual void Work() => Console.WriteLine("Working...");
}

public class Developer : Person {
    public override void Work() => Console.WriteLine("Coding...");
}

Anatomy of the Mechanics: Inheritance & Polymorphism

Let us break down the underlying mechanics of this code slice. Notice the use of the : operator in Developer : Person. This establishes an IS-A relationship (Inheritance). A Developer is a Person, meaning it automatically inherits the Name property without explicit redeclaration.

However, the real magic happens within the execution behavior, driven by two critical keywords:

1. virtual: Declared in the base class, this signals to the compiler that this method's behavior is fluid and can be intercepted by derived child classes.
2. override: Declared in the subclass, this actively intercepts the runtime execution path, substituting the base behavior with a specialized implementation.

Advanced Execution: Dynamic Binding in Action

To fully appreciate why this matters to a software architect, look at how the runtime engine processes these objects when grouped together. Because of polymorphism, a collection typed to the base class can hold any derived class instance seamlessly.

List<Person> team = new List<Person>() {
    new Person { Name = "Professor Smith" },
    new Developer { Name = "Grace Hopper" }
};

foreach (var member in team) {
    Console.Write(member.Name + " execution path: ");
    member.Work(); 
}

When this loop runs, the output demonstrates Dynamic Binding (or late binding). The system determines which method to call at runtime based on the actual object type, not the variable type:

Professor Smith execution path: Working...
Grace Hopper execution path: Coding...

Professor's Lab Task: Expanding the Ecosystem

To reinforce today's lecture, you must complete a practical coding task. Your goal is to introduce a third tier to our organizational hierarchy that introduces unique tracking and alters behavior appropriately.

Your Instructions:

• Create a new class named Manager that inherits directly from Person.
• Add an exclusive property to the Manager class: TeamSize (an integer type).
• Override the Work() method so that it outputs: "Managing a team of [TeamSize] people..." instead of the generic response.

public class Manager : Person {
    // 1. Task: Define your TeamSize property here
    
    // 2. Task: Override the Work() method using string interpolation
}

Verify your solution by creating an instance of your Manager, assigning it a TeamSize of 5, adding it to the team list created above, and confirming that the output shifts dynamically at runtime.

Exceptions & File I/O

Handling Errors

try {
    int x = int.Parse(Console.ReadLine());
} catch (FormatException ex) {
    Console.WriteLine("Invalid number format.");
} finally {
    Console.WriteLine("Done.");
}

Reading/Writing Files

File.WriteAllText("log.txt", "Hello C#");
string content = File.ReadAllText("log.txt");

The .NET Ecosystem

NuGet & Libraries

Use dotnet add package to install community libraries like Newtonsoft.Json.

Asynchronous Programming

public async Task<string> GetDataAsync() {
    var client = new HttpClient();
    return await client.GetStringAsync("https://api.example.com");
}

Capstone Project: Task Manager

Build a console-based Task Manager that uses everything we've learned: Lists, LINQ, OOP, and File I/O.

// Project requirements:
// 1. Add/Remove tasks
// 2. Mark tasks as complete
// 3. Save tasks to tasks.json
// 4. Filter tasks using LINQ

Asynchronous Programming with async & await

Asynchronous programming is fundamental to scalable .NET backends and responsive UI applications. By leveraging the Task-based Asynchronous Pattern (TAP), async, and await, your threads remain unblocked during I/O-bound database queries, HTTP network calls, and file operations.

1. The Task-based Asynchronous Pattern (TAP)

In synchronous execution, a thread waits idle while network packets travel across the wire or a disk head seeks sectors. In asynchronous C#, the thread is yielded back to the thread pool to process other web requests while the I/O completion port awaits completion:

using System.Net.Http.Json;

public class WeatherService
{
    private readonly HttpClient _http = new();

    // Task<T> represents an ongoing operation that will yield a T in the future
    public async Task<WeatherForecast?> FetchForecastAsync(string city, CancellationToken ct = default)
    {
        string url = $"https://api.weather.com/v1/{Uri.EscapeDataString(city)}";
        
        // Thread is NOT blocked during GetFromJsonAsync!
        return await _http.GetFromJsonAsync<WeatherForecast>(url, ct);
    }
}

public record WeatherForecast(string City, double TemperatureC, string Summary);

2. CancellationTokens & Resource Management

Every asynchronous API in production .NET should accept a CancellationToken. When a user navigates away from a page or closes an HTTP connection, the token triggers cancellation to immediately stop wasteful backend work.

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5)); // Timeout after 5s

try
{
    var service = new WeatherService();
    var forecast = await service.FetchForecastAsync("London", cts.Token);
    Console.WriteLine($"Forecast: {forecast?.Summary} at {forecast?.TemperatureC}°C");
}
catch (OperationCanceledException)
{
    Console.WriteLine("Request timed out or was aborted by the client.");
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"Network error: {ex.Message}");
}

3. Concurrency with Task.WhenAll & ValueTask

When you have multiple independent I/O tasks, run them concurrently instead of sequentially with Task.WhenAll:

public async Task<DashboardData> LoadDashboardAsync(int userId, CancellationToken ct)
{
    // Initiate both queries concurrently without awaiting yet
    Task<User> userTask = _userRepo.GetByIdAsync(userId, ct);
    Task<List<Order>> ordersTask = _orderRepo.GetRecentOrdersAsync(userId, ct);

    // Wait for both to complete simultaneously
    await Task.WhenAll(userTask, ordersTask);

    return new DashboardData(userTask.Result, ordersTask.Result);
}

Delegates, Lambdas & Events

Delegates are type-safe function pointers that form the bedrock of event-driven architectures, LINQ expressions, and callback pipelines in .NET. Master custom delegates, standard library delegates (Action, Func, Predicate), and thread-safe event publishing.

1. What is a Delegate?

A delegate is a reference type that defines a strict method signature (return type and parameters). Any method matching that signature can be assigned to the delegate:

// Custom delegate declaration
public delegate int MathOperation(int a, int b);

public class Calculator
{
    public static int Add(int x, int y) => x + y;
    public static int Multiply(int x, int y) => x * y;
}

public class Program
{
    public static void Main()
    {
        MathOperation op = Calculator.Add;
        Console.WriteLine(op(4, 5)); // 9

        op = Calculator.Multiply;
        Console.WriteLine(op(4, 5)); // 20
    }
}

2. Built-in Delegates: Action, Func, and Predicate

In modern C#, you rarely need to declare custom delegate types. The .NET BCL provides generic delegates that cover virtually every scenario:

• Action<T1, T2...>: Represents a method returning void with up to 16 parameters.
• Func<T1, T2..., TResult>: Represents a method returning TResult with up to 16 parameters.
• Predicate<T>: Equivalent to Func<T, bool>, used for filtering criteria.

// Action: returns void
Action<string> logger = message => Console.WriteLine($"[LOG {DateTime.UtcNow:s}] {message}");
logger("Application booted");

// Func: last generic type argument is always the return type
Func<string, int, bool> isLongerThan = (text, threshold) => text.Length > threshold;
bool check = isLongerThan("Enterprise .NET", 10); // true

// Predicate: filtering lists
Predicate<int> isEven = n => n % 2 == 0;
List<int> numbers = [1, 2, 3, 4, 5, 6];
List<int> evens = numbers.FindAll(isEven); // [2, 4, 6]

3. The Event Pattern & Memory Leaks

Events encapsulate delegates using the publish-subscribe pattern, ensuring that external classes can only subscribe (+=) or unsubscribe (-=), preventing external callers from clearing or triggering the delegate directly.

// Custom event arguments inheriting from EventArgs
public class OrderEventArgs : EventArgs
{
    public required string OrderId { get; init; }
    public decimal TotalAmount { get; init; }
}

public class OrderProcessor
{
    // Standard .NET event declaration
    public event EventHandler<OrderEventArgs>? OrderCompleted;

    public void ProcessOrder(string id, decimal amount)
    {
        Console.WriteLine($"Processing order {id} for ${amount:F2}...");
        
        // Thread-safe invocation using null-conditional operator
        OrderCompleted?.Invoke(this, new OrderEventArgs 
        { 
            OrderId = id, 
            TotalAmount = amount 
        });
    }
}

// Subscriber
public class InvoiceService
{
    public void OnOrderCompleted(object? sender, OrderEventArgs e)
    {
        Console.WriteLine($"Generating invoice for order {e.OrderId}: ${e.TotalAmount:F2}");
    }
}

Generics, Constraints & Interface Design

Generics provide type safety, code reusability, and high runtime performance by eliminating boxing/unboxing overhead. Paired with robust interface design and generic constraints, they form the cornerstone of enterprise software architecture and Dependency Injection.

1. Generic Classes & Methods

Generics decouple algorithms and data structures from specific concrete data types. In C#, generics are reified at runtime by the CLR, generating specialized native code for value types without boxing overhead:

// Generic Result container pattern
public class Result<T>
{
    public bool IsSuccess { get; }
    public T? Value { get; }
    public string? Error { get; }

    private Result(T value) { IsSuccess = true; Value = value; }
    private Result(string error) { IsSuccess = false; Error = error; }

    public static Result<T> Ok(T value) => new(value);
    public static Result<T> Fail(string error) => new(error);
}

// Generic Utility Method
public static class EnumerableExtensions
{
    public static IEnumerable<T> TakeRandom<T>(this IEnumerable<T> source, int count)
    {
        var rng = new Random();
        return source.OrderBy(_ => rng.Next()).Take(count);
    }
}

2. Generic Constraints (where T : ...)

Generic constraints inform the compiler what capabilities the type argument must possess. Without constraints, you can only invoke methods defined on object:

public interface IEntity
{
    Guid Id { get; }
    DateTime CreatedAtUtc { get; }
}

// Repository constrained to reference types implementing IEntity with a parameterless constructor
public class Repository<T> where T : class, IEntity, new()
{
    private readonly Dictionary<Guid, T> _storage = new();

    public void Add(T entity)
    {
        _storage[entity.Id] = entity;
    }

    public T? GetById(Guid id) => _storage.GetValueOrDefault(id);

    public T CreateDefault()
    {
        // Allowed because of 'new()' constraint!
        return new T();
    }
}

3. Interface Segregation & DI Contracts

Follow the Interface Segregation Principle (ISP): prefer small, focused interfaces over monolithic ones. This simplifies unit test mocking and dependency injection registration:

public interface IReadOnlyRepository<T> where T : class
{
    Task<T?> GetByIdAsync(Guid id, CancellationToken ct = default);
    Task<IReadOnlyList<T>> ListAllAsync(CancellationToken ct = default);
}

public interface IWriteRepository<T> where T : class
{
    Task AddAsync(T entity, CancellationToken ct = default);
    Task DeleteAsync(Guid id, CancellationToken ct = default);
}

// Combined interface when both capabilities are required
public interface IRepository<T> : IReadOnlyRepository<T>, IWriteRepository<T> where T : class
{
}

Entity Framework Core & Relational Databases

Entity Framework Core (EF Core) is the modern object-database mapper for .NET. It lets you query and persist domain models to relational databases (PostgreSQL, SQL Server, SQLite) using strongly-typed LINQ queries, automatic change tracking, and code-first database migrations.

1. Modeling Entities & DbContext

An entity is a domain model mapped to a database table. The DbContext coordinates querying, relationship configuration, and saving changes:

using Microsoft.EntityFrameworkCore;

// Domain Entities
public class Customer
{
    public int Id { get; set; }
    public required string FullName { get; set; }
    public required string Email { get; set; }
    
    // Navigation property: One-to-Many
    public List<Order> Orders { get; set; } = new();
}

public class Order
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; } = DateTime.UtcNow;
    public decimal TotalAmount { get; set; }
    
    // Foreign key and navigation back to Customer
    public int CustomerId { get; set; }
    public Customer Customer { get; set; } = null!;
}

// Application DbContext
public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) {}

    public DbSet<Customer> Customers => Set<Customer>();
    public DbSet<Order> Orders => Set<Order>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Customer>(entity =>
        {
            entity.HasKey(c => c.Id);
            entity.HasIndex(c => c.Email).IsUnique();
            entity.Property(c => c.FullName).HasMaxLength(150).IsRequired();
        });
    }
}

2. Efficient LINQ Queries & AsNoTracking

EF Core translates LINQ expressions directly into optimized SQL queries executed by the database server:

public async Task<List<CustomerDto>> GetTopSpendersAsync(AppDbContext db, CancellationToken ct)
{
    // AsNoTracking(): Skips change-tracking snapshots; 2-3x faster for read-only queries!
    return await db.Customers
        .AsNoTracking()
        .Where(c => c.Orders.Any())
        .Select(c => new CustomerDto(
            c.Id,
            c.FullName,
            c.Email,
            c.Orders.Sum(o => o.TotalAmount)
        ))
        .OrderByDescending(dto => dto.TotalSpent)
        .Take(10)
        .ToListAsync(ct);
}

public record CustomerDto(int Id, string FullName, string Email, decimal TotalSpent);

3. Transactions & Unit of Work (SaveChangesAsync)

SaveChangesAsync collects all dirty, added, and deleted entities and executes them inside an implicit database transaction:

public async Task<Order> CreateOrderAsync(AppDbContext db, int customerId, decimal amount, CancellationToken ct)
{
    var customer = await db.Customers.FindAsync([customerId], ct)
        ?? throw new KeyNotFoundException($"Customer {customerId} not found");

    var order = new Order
    {
        CustomerId = customerId,
        TotalAmount = amount,
        OrderDate = DateTime.UtcNow
    };

    db.Orders.Add(order);
    
    // Executes inside an atomic transaction
    await db.SaveChangesAsync(ct);
    return order;
}

Unit Testing & Mocking with xUnit & Moq

High-quality software demands automated tests that verify correctness, protect against regressions, and document design behavior. Learn test-driven development (TDD) using xUnit (the de facto standard in .NET), parameterized testing with [Theory], and test doubles with Moq.

1. Test Anatomy: Arrange, Act, Assert

xUnit identifies test methods using attributes. Every clean unit test follows the AAA pattern:

using Xunit;

public class BankAccountTests
{
    [Fact] // [Fact] denotes a test that is always true under invariant conditions
    public void Deposit_ValidAmount_IncreasesBalance()
    {
        // 1. Arrange: setup initial state and dependencies
        var account = new BankAccount(initialBalance: 100m);

        // 2. Act: invoke the method under test
        account.Deposit(50m);

        // 3. Assert: verify expected outcome
        Assert.Equal(150m, account.Balance);
    }

    [Fact]
    public void Withdraw_AmountGreaterThanBalance_ThrowsInvalidOperationException()
    {
        // Arrange
        var account = new BankAccount(initialBalance: 50m);

        // Act & Assert
        var ex = Assert.Throws<InvalidOperationException>(() => account.Withdraw(100m));
        Assert.Contains("Insufficient funds", ex.Message);
    }
}

2. Parameterized Tests with [Theory] & [InlineData]

Instead of duplicating test methods for different test cases, use [Theory] to run the same test logic against a matrix of inputs:

public class EmailValidatorTests
{
    [Theory]
    [InlineData("[email protected]", true)]
    [InlineData("[email protected]", true)]
    [InlineData("missing-at-sign.com", false)]
    [InlineData("@missing-local.com", false)]
    [InlineData("", false)]
    [InlineData(null, false)]
    public void IsValidEmail_EvaluatesCorrectly(string? input, bool expected)
    {
        var validator = new EmailValidator();
        bool result = validator.IsValid(input);
        Assert.Equal(expected, result);
    }
}

3. Mocking Dependencies with Moq

Unit tests must test logic in isolation without talking to real databases or sending real emails. We substitute interfaces with mock objects:

using Moq;
using Xunit;

public class OrderServiceTests
{
    [Fact]
    public async Task PlaceOrderAsync_ValidOrder_SendsNotificationAndSaves()
    {
        // Arrange: Mock dependencies
        var mockRepo = new Mock<IOrderRepository>();
        var mockNotifier = new Mock<INotificationService>();

        var service = new OrderService(mockRepo.Object, mockNotifier.Object);
        var order = new Order { Id = 101, CustomerId = 1, TotalAmount = 99.99m };

        // Act
        await service.PlaceOrderAsync(order);

        // Assert: Verify mock interactions
        mockRepo.Verify(r => r.SaveAsync(order, It.IsAny<CancellationToken>()), Times.Once);
        mockNotifier.Verify(n => n.NotifyCustomerAsync(order.CustomerId, It.IsAny<string>()), Times.Once);
    }
}

Final Project — Production ASP.NET Core Web API

In this capstone project, you will build a production-grade RESTful Web API using ASP.NET Core Minimal APIs, Entity Framework Core, structured validation, dependency injection, and OpenAPI documentation.

1. Project Architecture & Minimal API Endpoints

Modern ASP.NET Core uses Minimal APIs to achieve industry-leading throughput with concise, readable syntax:

using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Register Services in Dependency Injection Container
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddDbContext<AppDbContext>(opts => 
    opts.UseSqlite(builder.Configuration.GetConnectionString("Default") ?? "Data Source=store.db"));

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

// Route Group: /api/products
var products = app.MapGroup("/api/products").WithTags("Products");

products.MapGet("/", async (AppDbContext db, CancellationToken ct) =>
    Results.Ok(await db.Products.AsNoTracking().ToListAsync(ct)));

products.MapGet("/{id:int}", async (int id, AppDbContext db, CancellationToken ct) =>
    await db.Products.FindAsync([id], ct) is Product p 
        ? Results.Ok(p) 
        : Results.NotFound(new { Message = $"Product {id} not found" }));

products.MapPost("/", async (CreateProductDto dto, AppDbContext db, CancellationToken ct) =>
{
    if (string.IsNullOrWhiteSpace(dto.Name) || dto.Price <= 0)
        return Results.BadRequest(new { Error = "Invalid name or price." });

    var product = new Product { Name = dto.Name, Price = dto.Price, Stock = dto.Stock };
    db.Products.Add(product);
    await db.SaveChangesAsync(ct);

    return Results.Created($"/api/products/{product.Id}", product);
});

products.MapDelete("/{id:int}", async (int id, AppDbContext db, CancellationToken ct) =>
{
    var product = await db.Products.FindAsync([id], ct);
    if (product is null) return Results.NotFound();

    db.Products.Remove(product);
    await db.SaveChangesAsync(ct);
    return Results.NoContent();
});

app.Run();

public record CreateProductDto(string Name, decimal Price, int Stock);
public class Product
{
    public int Id { get; set; }
    public required string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
}

2. Global Error Handling Middleware

Never let unhandled exceptions leak stack traces to public API consumers. Use custom exception handling or app.UseExceptionHandler() with ProblemDetails:

app.UseExceptionHandler(exceptionHandlerApp =>
{
    exceptionHandlerApp.Run(async context =>
    {
        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
        context.Response.ContentType = "application/problem+json";

        var problem = new
        {
            Status = 500,
            Title = "An unexpected server error occurred.",
            TraceId = context.TraceIdentifier
        };

        await context.Response.WriteAsJsonAsync(problem);
    });
});