🎯
Course Learning Objectives
By the end of the C# Coding Apprentice course you will be able to:
- Write, compile, and debug well-structured C# console programs using correct syntax, variables, and data types.
- Control program flow with conditionals, loops, and jump statements — and validate user input safely.
- Break complex logic into reusable methods, applying DRY principles and clear scope rules.
- Design and build object-oriented programs using classes, encapsulation, inheritance, polymorphism, and abstraction.
- Apply the Singleton, Factory, and Builder design patterns to organise growing codebases.
- Use delegates, events, lambdas, and LINQ to write expressive, event-driven, data-aware C# code.
- Combine everything into a fully working HeroQuest console RPG — your portfolio-ready capstone.
⚔️ About the Course
The C# Coding Apprentice certification is a project-based introduction to professional C# programming. Instead of learning syntax in isolation, you build a single, growing project — HeroQuest, a console-based role-playing game — across six units. Each unit adds a new layer of language features and engineering skills, and each one ends with a hands-on capstone that integrates everything you’ve learned so far.
The course is designed for first-time programmers and for students transitioning from block-based languages (Scratch, MakeCode) to a real, industry-standard language. No prior C# experience is required — only basic computer literacy and a willingness to experiment.
⚡ The promise: If you finish this course, you’ll be able to read, write, and debug C# code with confidence — and you’ll have a working game to prove it. CSCA is also the foundation for the next certification, C# Coding Specialist (CSCS).
📜
The Rulebook
Master C# syntax, types, and program structure.
⚙️
The Engine
Control flow and methods that power game behaviour.
🏗️
The Architecture
Classes, inheritance, and design patterns that scale.
🏰
The Castle
A complete, event-driven HeroQuest RPG — your capstone.
👥 Who This Course Is For
Target audience
- Secondary and post-secondary students taking their first serious step into text-based programming.
- Self-learners and career-changers who want a structured path into C# and the .NET ecosystem.
- Educators looking for a ready-to-deliver, project-based introductory C# curriculum.
Prerequisites
- Comfort using a computer, files, and folders.
- Basic problem-solving skills — the kind built by puzzles, math, or block-based coding (Scratch, MakeCode, etc.).
- No prior C# or .NET experience is assumed.
Tools you’ll need
- A Windows, macOS, or Linux computer.
- Visual Studio Community or Visual Studio Code with the C# Dev Kit extension.
- The .NET 8 SDK (or newer LTS release).
📊 Course at a Glance
Every lesson runs roughly 90 minutes and includes guided instruction, code-along examples, hands-on practice, and a short reflection. Each unit closes with a capstone project that integrates every lesson in the unit, and the final unit builds the full HeroQuest game.
🗺️ Unit Roadmap
The six units are designed to be taken in order — each builds directly on the language features and HeroQuest code from the previous one.
Unit 1 · ~7.5 hours · Beginner
C# Fundamentals — Building the Foundation
Syntax · Variables · Types · Collections
Lay the foundation of HeroQuest by mastering C# syntax, variables, type conversion, arrays, and lists — the building blocks every later unit relies on.
- 1.1 — C# Syntax & Structure
- 1.2 — Data Types & Variables
- 1.3 — Arrays, Lists & Type Conversion
- 1.4 — Unit Project: HeroQuest Foundation
- 1.5 — Operators, Precedence, Overflow &
readonly Constants
Unit 2 · ~8 hours · Beginner+
Control Statements — Guiding the Flow
if/else · switch · loops · input validation
Give your hero a real adventure. Add decision-making and loops so HeroQuest reacts to player choices — culminating in a working turn-based combat system.
- 2.1 — Decision Making (if / else / else-if)
- 2.2 — Switch Statements & Loops
- 2.3 — Jump Statements & Flow Control
- 2.4 — Unit Project: Combat System
Unit 3 · ~7.5 hours · Intermediate
Methods & Modularity
Methods · parameters · return values · DRY
Refactor a sprawling Main method into focused, reusable methods. Add abilities like Fireball, HealSpell, and PowerStrike — each a clean unit of code.
- 3.1 — Introduction to Methods
- 3.2 — Refactoring Game Logic
- 3.3 — Abilities & Spells
- 3.4 — Unit Project: Ability System
Unit 4 · ~7 hours · Intermediate
Classes, Encapsulation & Inheritance
OOP · properties · inheritance · polymorphism
Turn HeroQuest into a real object-oriented game. Model heroes and monsters as classes, share behaviour through inheritance, and specialise it with polymorphism.
- 4.1 — Classes & Objects
- 4.2 — Encapsulation & Properties
- 4.3 — Inheritance & Polymorphism
- 4.4 — Unit Project: OOP Refactor
- 4.5 — Abstraction & the Immutable Object Pattern
Unit 5 · ~7 hours · Intermediate+
Design Patterns in HeroQuest
Singleton · Factory · Builder · pattern thinking
Bring HeroQuest closer to a real game engine with three foundational design patterns — and learn when reaching for a pattern actually earns its complexity.
- 5.1 — Singleton Pattern
- 5.2 — Factory & Builder
- 5.3 — Combining Patterns
- 5.4 — Unit Project: Patterns Upgrade
Unit 6 · ~7.5 hours · Advanced
LINQ & Event-Driven Programming
Delegates · events · lambdas · LINQ
The final unit. Add a game analytics dashboard with LINQ queries, and wire event-driven notifications for low HP, victories, and loot drops.
- 6.1 — Delegates & Events
- 6.2 — Lambda Expressions
- 6.3 — LINQ Queries
- 6.4 — Unit Project: Analytics & Notifications
🧭 Skills You’ll Master
The course is organised so that every concept reappears and deepens in later units. Here’s how the major skill areas map across the six units.
Language & Syntax
Statements, keywords, operators, comments, scope, and the standard C# program structure.
Types & Data
Value vs. reference types, type conversion, nullability, constants, arrays, and List<T>.
Control Flow
if/switch, loops, jump statements, and robust user-input validation.
Methods & Modularity
Parameters, return values, refactoring, and the DRY principle.
Object-Oriented Design
Classes, properties, encapsulation, inheritance, polymorphism, and abstraction.
Patterns & Architecture
Singleton, Factory, Builder — and the judgement of when to use them.
Functional & Event-Driven
Delegates, events, lambda expressions, and LINQ queries over game data.
Engineering Habits
Reading errors, debugging, refactoring, and writing readable, maintainable code.
📘 How Each Lesson Works
Every lesson follows the same predictable rhythm, so you always know what to expect.
| Section | What Happens | Why It’s There |
|---|
| Learning Objectives | A short, concrete list of what you’ll be able to do by the end of the lesson. | Sets a clear target before you start. |
| Story Hook | A HeroQuest scenario that motivates the new concept. | Anchors abstract syntax to a concrete game problem. |
| Guided Instruction | Worked examples with annotated C# code. | Shows the concept in action with real code, not just rules. |
| Code-Along | You type, run, and modify a small example with the teacher. | Builds muscle memory for syntax and tooling. |
| Practice Activities | Short, focused exercises that reinforce the concept. | Closes the gap between watching and doing. |
| Unit Project Step | Each lesson adds the next piece of HeroQuest. | Connects today’s lesson to the bigger picture. |
| Reflection & Check | Quick self-check questions and a glossary. | Surfaces gaps before they compound. |
Teacher edition: Every lesson ships with a paired Teacher HTML that mirrors the student version and adds pacing notes, common misconceptions, discussion prompts, and answer keys.
📝 Assessment & Certification
Assessment in CSCA is continuous and project-based. There are no surprise exams — what you do every lesson is what you’ll be measured on.
Within each unit
- Practice activities at the end of each lesson check that the concept landed.
- Self-check reflections let you (and your teacher) spot gaps early.
- Unit capstone projects require you to integrate every lesson in the unit into a working program.
End-of-course outcome
- A complete HeroQuest console RPG that demonstrates every major skill from the course.
- Eligibility to sit the C# Coding Apprentice (CSCA) certification exam.
- A clean handoff into the next certification, C# Coding Specialist (CSCS).
What CSCA proves: That you can read, write, and reason about idiomatic C# code; structure a small program with classes and methods; and apply common patterns to keep that program maintainable.
🚀 What Comes After CSCA
The Knowledge Pillars C# pathway continues with the C# Coding Specialist (CSCS) certification. Where CSCA focuses on language fundamentals and a single console project, CSCS broadens the lens: file I/O, exception handling, more advanced OOP, generics, collections, asynchronous programming, and richer application architectures.
If you’ve finished CSCA, you’re ready for CSCS — and from there, for real-world .NET application development.
🎤 Before You Begin
Take a few minutes and answer these in your notebook:
- What’s drawing you to C# specifically — a game you love, a job you want, a school project, or just curiosity?
- What’s the hardest thing you’ve ever learned that wasn’t a school subject? What helped you push through it?
- By the end of this course, what’s one thing you want to be able to build that you can’t build today?
