• Use enums to represent fixed sets of named values
• Write and use generic classes and methods with type constraints
• Choose and use the correct collection type for a given problem
• Write extension methods, delegates, and lambda expressions
• Understand async/await and why every Web API method uses it

Pattern matching with switch expressions keeps enum-to-string mappings exhaustive and readable.

string label = status switch
{
    TaskStatus.Pending    => "Not started",
    TaskStatus.InProgress => "In progress",
    TaskStatus.Completed  => "Done",
    TaskStatus.Cancelled  => "Cancelled",
    _                     => "Unknown"
};

Add [Flags] to combine multiple values with bitwise OR. Each member must be a distinct power of 2.

[Flags]
public enum Permissions
{
    None   = 0,
    Read   = 1,
    Write  = 2,
    Delete = 4,
    Admin  = Read | Write | Delete
}

Permissions userPerms = Permissions.Read | Permissions.Write;
bool canWrite = userPerms.HasFlag(Permissions.Write);   // true

Constraints tell the compiler what capabilities T must have, so you can call methods on it safely.

// T must implement IComparable<T>
static T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

static T CreateInstance<T>() where T : class, new()
{
    return new T();
}

A delegate is a type that holds a reference to a method — it lets you pass behaviour as a parameter.

delegate int MathOperation(int a, int b);

static int Add(int a, int b)      => a + b;
static int Multiply(int a, int b) => a * b;

MathOperation op = Add;
Console.WriteLine(op(3, 4));   // 7

op = Multiply;
Console.WriteLine(op(3, 4));   // 12

Use these instead of declaring your own delegates for common signatures.

Anonymous methods written inline — the most common way to use delegates in practice.

Func<int, int> square =
    x => x * x;

Action<string> print =
    msg => Console.WriteLine(msg);

Predicate<int> isEven =
    n => n % 2 == 0;

Console.WriteLine(square(5));  // 25
print("Hello");
Console.WriteLine(isEven(4));  // true

var numbers = new List<int>
    { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evens   = numbers.Where(n => n % 2 == 0);
var squares = numbers.Select(n => n * n);
int? first  = numbers.FirstOrDefault(n => n > 5);

var words = new List<string>
    { "banana", "apple", "kiwi" };
words.Sort((a, b) =>
    a.Length.CompareTo(b.Length));

• Almost every Web API operation involves I/O — reading from a database, calling an external service, reading a file
• With synchronous code the thread blocks and sits idle while waiting for I/O to complete
• With async code the thread is released back to the thread pool during the wait — it can serve other requests
• Result: the same server handles more concurrent requests with fewer threads

This is the pattern every controller in the course will follow starting in Session 08.

[HttpGet("{id}")]
public async Task<IActionResult> GetTask(int id)
{
    var task = await _taskService.GetByIdAsync(id);
    if (task == null) return NotFound();
    return Ok(task);
}

Using the course's Task Management domain:

1. Define a TaskStatus enum with values: Pending, InProgress, Completed, Cancelled.
2. Create a generic class Repository<T> with a private List<T>, methods Add(T item), GetAll() returning IEnumerable<T>, and a Count property.
3. Add an extension method FilterByPredicate<T> on IEnumerable<T> that returns all items matching a Predicate<T>.
4. Write a Func<TaskItem, string> that formats a task as a one-line summary. Apply it with Select to a list and print all results.

• Enums replace magic numbers and strings with named, type-safe constants — use [Flags] for bitmask values
• Generics let you write one implementation that works for any type; constraints narrow what T can be
• Use List<T> for ordered data, Dictionary for key lookup, HashSet for membership, IEnumerable<T> as method parameters
• Extension methods add behaviour to existing types without modifying them — they power LINQ
• Delegates and lambdas let you pass behaviour as data; built-in types Func, Action, Predicate cover most needs
• Every Web API method should be async and return Task<T> — never block with .Result or .Wait()

• Session 08 — First .NET Web API & Project Architecture
• We will create a real ASP.NET Core Web API project from scratch
• Controllers, routing, and the project structure you'll use for the rest of the course
• Every action method will be async Task<IActionResult> — exactly what you learned today

Build a small in-memory task tracker that applies the features from this session:

• Define a Priority enum: Low, Medium, High, Critical
• Create a generic Repository<T> that stores items in a List<T> and exposes Add, GetAll, and FindAll(Predicate<T>)
• Add at least two extension methods on IEnumerable<TaskItem> — for example, filtering by status or sorting by priority
• Use a Func<TaskItem, string> with Select to produce a formatted summary line for each task and print the results
• Wrap at least one operation in an async method that simulates a delay with Task.Delay and is called with await