Game Development C# Programming Language Syllabus

C# Programming Language syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for C# Programming Language in Game Development, not a summary of it.

1. 1

   Introduction to C#

   3 topics

   • Overview of C#
     • History of C#
     • Features of C#
     • C# in .NET Ecosystem
   • Setting Up Environment
     • Installing Visual Studio
     • Creating a New Project
     • Understanding Solution and Project Structure
   • Basic Syntax
     • Hello World Program
     • Basic Program Structure
     • Comments in C#
2. 2

   Basic Concepts

   3 topics

   • Variables and Data Types
     • Primitive Data Types
     • Value Types vs Reference Types
     • Type Conversion
   • Operators
     • Arithmetic Operators
     • Relational Operators
     • Logical Operators
     • Bitwise Operators
     • Assignment Operators
   • Control Flow
     • Conditional Statements
     • Loops
     • Switch Statement
3. 3

   Object-Oriented Programming (OOP)

   5 topics

   • Classes and Objects
     • Defining Classes
     • Creating Objects
     • Constructors
     • Destructors
   • Inheritance
     • Base and Derived Classes
     • Method Overriding
     • Sealed Classes and Methods
   • Polymorphism
     • Method Overloading
     • Runtime Polymorphism
     • Abstract Classes and Methods
     • Interfaces
   • Encapsulation
     • Access Modifiers
     • Properties
     • Auto-Implemented Properties
   • Namespaces
     • Using Directives
     • Creating Namespaces
     • Nested Namespaces
4. 4

   Advanced Concepts

   6 topics

   • Delegates and Events
     • Defining Delegates
     • Using Delegates
     • Events and Event Handlers
   • Generics
     • Generic Classes
     • Generic Methods
     • Constraints on Generics
   • Collections
     • Arrays
     • List
     • Dictionary
     • Queue and Stack
   • Exception Handling
     • Try, Catch, Finally
     • Throwing Exceptions
     • Custom Exceptions
   • LINQ (Language Integrated Query)
     • Introduction to LINQ
     • LINQ Queries
     • LINQ with Collections
     • LINQ to SQL
   • Asynchronous Programming
     • Async and Await
     • Tasks
     • Parallel Programming
5. 5

   Data Access

   2 topics

   • ADO.NET
     • Connecting to Database
     • Executing Commands
     • Reading Data
   • Entity Framework
     • Code First Approach
     • Database First Approach
     • LINQ to Entities
6. 6

   Testing and Debugging

   2 topics

   • Unit Testing
     • Introduction to Unit Testing
     • Using MSTest
     • Using NUnit
     • Using xUnit
   • Debugging Techniques
     • Using Visual Studio Debugger
     • Breakpoints
     • Watch and Immediate Window

C# Programming Language flashcards for Game Development

25 of 59 cards from the C# Programming Language deck — real questions with worked answers.

1. What is C# and who developed it?

   C# is a modern, general-purpose, object-oriented programming language developed by Microsoft, led by Anders Hejlsberg. It runs on the .NET platform and is type-safe, component-oriented, and designed for building a wide range of applications.

2. What is the Common Language Runtime (CLR) in the context of C#?

   The CLR is the virtual machine component of .NET that manages the execution of C# programs. It provides services like memory management (garbage collection), type safety, exception handling, and Just-In-Time (JIT) compilation of Intermediate Language (IL) into native code.

3. In C#, what is Common Intermediate Language (CIL/IL) and how does C# code become executable?

   C# source code is compiled into Common Intermediate Language (CIL/IL), a CPU-independent bytecode stored in assemblies (.dll/.exe). At runtime, the CLR's Just-In-Time (JIT) compiler translates the IL into native machine code for the target platform.

4. What tools are typically needed to set up a C# development environment?

   You need the .NET SDK (which includes the compiler, runtime, and CLI) and an editor/IDE such as Visual Studio, Visual Studio Code, or JetBrains Rider. The `dotnet` CLI is used to create, build, and run projects.

5. Which `dotnet` CLI commands create, build, and run a new console application?

   `dotnet new console` creates a new console project, `dotnet build` compiles it, and `dotnet run` builds and executes it. `dotnet restore` restores NuGet package dependencies.

6. What is the entry point of a C# program?

   The `Main` method is the entry point, typically declared as `static void Main(string[] args)` or `static async Task Main(string[] args)`. Modern C# also supports top-level statements, where the compiler generates the `Main` method implicitly.

7. In C#, what is the difference between a statement and how each statement must end?

   A statement is a complete instruction that performs an action. In C#, every simple statement must terminate with a semicolon (`;`). Code blocks are enclosed in curly braces `{ }`.

8. How do you write single-line, multi-line, and documentation comments in C#?

   Single-line comments use `//`, multi-line comments are enclosed in `/* ... */`, and XML documentation comments use `///` (which support tags like `<summary>` for generating documentation).

9. Is C# case-sensitive, and what naming convention is conventionally used for methods and classes?

   Yes, C# is case-sensitive (`myVar` and `myvar` are different). By convention, classes, methods, and properties use PascalCase, while local variables and parameters use camelCase.

10. What is the difference between value types and reference types in C#?

    Value types (e.g., `int`, `double`, `bool`, `struct`, `enum`) store their data directly and are typically allocated on the stack. Reference types (e.g., `class`, `string`, arrays, `object`) store a reference (pointer) to data on the heap.

11. List the common integral and floating-point numeric data types in C# with their sizes.

    Integral: `byte` (8-bit), `short` (16-bit), `int` (32-bit), `long` (64-bit). Floating-point: `float` (32-bit, ~7 digits), `double` (64-bit, ~15-16 digits), and `decimal` (128-bit, ~28-29 digits, ideal for financial calculations).

12. What is the difference between `var` and explicit type declaration in C#?

    `var` uses implicit typing where the compiler infers the type from the initializer at compile time (still strongly typed). Explicit declaration states the type directly (e.g., `int x = 5;`). `var` requires an initializer and cannot be used for class fields.

13. What is the difference between a nullable value type and a non-nullable value type in C#?

    A non-nullable value type (e.g., `int`) cannot hold null. A nullable value type, declared with `?` (e.g., `int?` or `Nullable<int>`), can hold either a valid value or null. Access the value with `.Value` and check with `.HasValue`.

14. In C#, what is the difference between a constant (`const`) and a read-only field (`readonly`)?

    `const` values are set at compile time and are implicitly static; they must be initialized at declaration. `readonly` fields are set at runtime, either at declaration or in a constructor, and can differ per instance.

15. What are the arithmetic operators in C# and what does the modulus operator do?

    Arithmetic operators are `+`, `-`, `*`, `/`, and `%` (modulus). The modulus operator returns the remainder of integer division, e.g., $7 \% 3 = 1$.

16. What is the difference between `==` and `.Equals()` when comparing objects in C#?

    For reference types, `==` by default compares references (identity), while `.Equals()` can be overridden to compare values. For strings, `==` is overloaded to compare values. Value types compare by value with both.

17. Explain the difference between the `&&` / `||` and `&` / `|` operators in C#.

    `&&` and `||` are short-circuit logical operators: they stop evaluating as soon as the result is determined. `&` and `|` are non-short-circuiting (evaluate both operands) and also serve as bitwise operators on integers.

18. What does the null-coalescing operator `??` and the null-coalescing assignment `??=` do in C#?

    `a ?? b` returns `a` if it is not null, otherwise returns `b`. `a ??= b` assigns `b` to `a` only if `a` is currently null. Both help handle null values concisely.

19. What is the null-conditional operator `?.` in C#?

    The null-conditional operator `?.` safely accesses members: if the operand is null, the entire expression evaluates to null instead of throwing a `NullReferenceException`. Example: `obj?.Property` returns null if `obj` is null.

20. What is the ternary conditional operator in C# and what is its syntax?

    The ternary operator evaluates a boolean condition and returns one of two values: `condition ? valueIfTrue : valueIfFalse`. It is a concise alternative to an if-else statement for value selection.

21. Compare the `if-else` statement and the `switch` statement in C#.

    `if-else` evaluates boolean conditions sequentially and is flexible for ranges/complex logic. `switch` compares a single expression against multiple constant `case` labels (or patterns), is cleaner for many discrete values, and can use `switch` expressions for concise value returns.

22. What are the looping constructs available in C#?

    C# provides `for` (counter-based), `while` (pre-condition), `do-while` (post-condition, runs at least once), and `foreach` (iterates over collections implementing `IEnumerable`).

23. What is the difference between `break` and `continue` in C# loops?

    `break` immediately terminates the entire loop (or switch). `continue` skips the rest of the current iteration and proceeds to the next iteration of the loop.

24. What is a class versus an object in C#?

    A class is a blueprint/template that defines fields, properties, methods, and events. An object is a concrete instance of a class created at runtime with the `new` keyword, holding its own state in memory.

25. What is a constructor in C# and what is the difference between a default and parameterized constructor?

    A constructor is a special method with the same name as the class that initializes new objects. A default (parameterless) constructor takes no arguments; a parameterized constructor accepts arguments to set initial field values. If none is defined, C# provides an implicit default constructor.

See more C# Programming Language flashcards →

Planning C# Programming Language for Game Development

C# Programming Language (Game Development) FAQ