C# Course

Lesson 1 • Variables, Data Types, and Literals

Declare and initialise variables using built-in value and reference types. Correct type selection prevents runtime errors in later chapters.

Lesson 2 • Console Input and Output

Read user input and display formatted output using Console methods. These skills are used in every hands-on exercise across the course.

Lesson 3 • Installing and Configuring the Toolchain

Set up the .NET SDK, Visual Studio or VS Code, and verify installation. This foundation ensures every subsequent exercise compiles without environment errors.

Lesson 4 • C# Program Structure and Syntax

Examine namespaces, classes, and the Main entry point. Understanding program structure enables correct file organisation throughout the course.

Lesson 1 • Looping Constructs

Iterate with for, while, do-while, and foreach loops. Choosing the right loop type improves code clarity and prevents infinite-loop bugs.

Lesson 2 • Conditional Statements

Use if, else if, and else to branch execution based on boolean conditions. Mastery here is a prerequisite for all loop and exception logic ahead.

Lesson 3 • Jump Statements and Loop Control

Alter loop and method flow with break, continue, return, and goto. These statements refine algorithm behaviour built in the previous section.

Lesson 1 • Defining and Calling Methods

Declare methods with return types and parameter lists, then invoke them correctly. Method decomposition is the primary tool for managing complexity in later chapters.

Lesson 2 • Recursion and Stack Considerations

Implement recursive algorithms and recognise stack-overflow risks. Recursion patterns appear in tree traversal and algorithm chapters later.

Lesson 3 • Variable Scope and Lifetime

Identify local, method, and class-level scope and understand variable lifetime. Scope rules govern field access patterns introduced in the OOP chapter.

Lesson 4 • Parameter Passing Mechanisms

Distinguish value, reference, and output parameters using ref, out, and in. Correct parameter semantics prevents subtle data-mutation bugs in class design.

Lesson 1 • Classes, Objects, and Constructors

Define classes with fields, properties, and constructors, then instantiate objects. This section establishes the object model used throughout all remaining chapters.

Lesson 2 • Abstract Classes and SOLID Principles

Use abstract classes to share partial implementations and apply SOLID design rules. These principles guide architecture decisions in every advanced chapter.

Lesson 3 • Encapsulation and Access Modifiers

Control member visibility with public, private, protected, and internal. Proper encapsulation enforces invariants that make class APIs reliable.

Lesson 4 • Inheritance and Method Overriding

Extend base classes and override virtual methods to specialise behaviour. Inheritance hierarchies underpin the polymorphic designs in the next section.

Lesson 1 • LINQ Query Syntax and Method Syntax

Filter, project, and sort sequences using LINQ query and fluent method syntax. Both syntaxes are used interchangeably in professional codebases.

Lesson 2 • Deferred Execution and Performance

Understand lazy evaluation, materialisation, and query reuse in LINQ pipelines. Deferred execution awareness prevents hidden performance bugs in production code.

Lesson 3 • Generics and Type Constraints

Create generic classes and methods with type parameters and constraints. Generics eliminate casting and enable the reusable algorithms used in LINQ.

Lesson 4 • Aggregation and Set Operations

Compute sums, counts, and distinct sets using LINQ aggregation and set operators. These operators power reporting and data-transformation tasks in later projects.

Lesson 1 • Try, Catch, Finally, and Filters

Structure try-catch-finally blocks and apply exception filters with when. Proper block structure ensures resources are released even when errors occur.

Lesson 2 • Exception Hierarchy and Types

Navigate the System.Exception hierarchy and distinguish checked from unchecked exceptions. Knowing exception types guides correct catch-block targeting in the next section.

Lesson 3 • Debugging Tools and Techniques

Use breakpoints, watch windows, and the call stack in the IDE debugger. These skills accelerate defect resolution in all subsequent project work.

Lesson 4 • Throwing and Re-Throwing Exceptions

Throw exceptions with meaningful messages and preserve stack traces when re-throwing. Correct re-throw patterns maintain diagnostic information for production debugging.

Lesson 1 • File and Directory Operations

Read, write, and manage files and directories using System.IO classes. File operations underpin configuration loading and report generation in real projects.

Lesson 2 • Database Access with ADO.NET and Dapper

Execute SQL commands and map results using ADO.NET and the Dapper micro-ORM. These patterns form the foundation for Entity Framework work in advanced projects.

Lesson 3 • Streams and Binary Data

Process binary data with FileStream, MemoryStream, and BinaryReader/Writer. Stream composition enables efficient large-file handling and network data transfer.

Lesson 4 • JSON Serialisation with System.Text.Json

Serialise and deserialise objects to JSON using the built-in library. JSON is the dominant interchange format for APIs and configuration files.

Lesson 1 • Parallel Programming with PLINQ and Parallel

Parallelise CPU-bound work using Parallel.For, Parallel.ForEach, and PLINQ. Parallel constructs maximise multi-core utilisation for data-processing workloads.

Lesson 2 • Task-Based Asynchronous Pattern

Create and await Task and Task<T> to perform non-blocking operations. The TAP model is the standard async pattern across all modern .NET APIs.

Lesson 3 • Thread Safety and Synchronisation

Protect shared state with locks, Monitor, Interlocked, and concurrent collections. Synchronisation prevents race conditions in multi-threaded service code.

Lesson 4 • Async and Await in Depth

Understand state machine generation, context capture, and ConfigureAwait. Deep async knowledge prevents deadlocks and context-switching overhead in production.