C# Tutorial - Full Course for Beginners

Overview

Beginner-friendly, full C# course (Draft Academy, instructor: Mike). Step-by-step tutorials cover IDE setup, core language features, common APIs and small sample projects — progressing from “Hello World” to simple games, then to OOP and error handling.

The course uses Visual Studio Community (select the .NET Desktop Development workload). The walkthrough shows how to create a new C# Console App (Program.cs) and demonstrates running and debugging from the Start button. A Mac installer is also available.

---

Key concepts, language features and how-to items

1. Project setup and first program

• Install Visual Studio Community and select the “.NET Desktop Development” workload.
• Create a new Console App and open Program.cs.
• Typical C# program structure: using directives, namespace, class, static void Main() entry point.
• Run/debug with Start; use Console.WriteLine and Console.ReadLine to display and pause output.

2. Basic I/O and simple programs

• Console.WriteLine / Console.Write for line vs inline output.
• Console.ReadLine() returns a string; store input in variables.
• Concatenate strings with +; use escape sequences like \n and \".

3. Variables and data types

• Declare and assign variables; follow naming conventions (e.g., camelCase for variables).
• Common primitive types:
  • string, char (single character)
  • int (integers)
  • double, float, decimal (floating-point; double is the default for most use)
  • bool (true/false)
• Note the difference between integer division and floating-point math.

4. Strings (operations and methods)

• Properties and methods: Length, indexing (0-based), Substring(start[, length]), IndexOf, Contains.
• Case conversion: ToUpper(), ToLower(), and other built-in string methods.

5. Numbers and Math

• Arithmetic operators: +, -, *, /, % (modulus); use parentheses to enforce precedence.
• Increment/decrement: i++, i--.
• Math class methods: Math.Abs, Math.Pow, Math.Sqrt, Math.Min, Math.Max, Math.Round, etc.

6. Parsing and user input

• Convert strings from Console.ReadLine() to numeric types using Convert.ToInt32, Convert.ToDouble, etc.
• Input must match the expected format; invalid formats throw exceptions (e.g., FormatException).

7. Small guided projects / examples

• Hello World and ASCII-art shape printing.
• Number printer and simple calculators (two-number add, four-function operator parsing).
• Mad Libs: prompt for multiple strings and inject into a story.
• Exponent function implemented with loops (repeated multiplication).
• Guessing game using while loops, later improved with guess limits and flags.

8. Arrays and collections

• One-dimensional arrays: declaration, initializer { ... }, zero-based indexing, Length property.
• Create empty arrays with new Type[size] and fill elements individually.
• Iterate arrays with for loops.
• Two-dimensional arrays: int[,] or nested initializers ({{...},{...}}) and indexing [row,col].

9. Control flow and decision logic

• if, else if, else; boolean logic operators: && (and), || (or), ! (not).
• Comparison operators: >, <, >=, <=, ==, !=.
• switch statements with case, break, and default — useful for discrete mappings (e.g., weekday numbers).

10. Loops

• while and do-while (do-while executes the body before checking the condition).
• for loop structure (initializer; condition; iterator) — ideal for counted iterations and array traversal.
• Beware of infinite loops when the loop condition never becomes false.

11. Methods / Functions

• Declare methods (use static if alongside Main), choose void or a return type.
• Use parameters/arguments and return to provide values back.
• Encapsulate reusable logic to call with different arguments.

12. Comments and code organization

• Single-line comments: //
• Block comments: /* ... */
• Use comments for explanations or temporarily disabling code.

13. Exception handling

• Pattern: try { } catch (ExceptionType e) { } finally { }.
• Catch specific exceptions like DivideByZeroException or FormatException; inspect e.Message.
• Use try/catch to prevent crashes, provide validation/error messages, and perform cleanup in finally.

14. Object‑oriented programming (OOP)

• Classes define blueprints; create objects with new ClassName(...).
• Use fields and constructors (public ClassName(...)) to initialize state.
• Methods operate on instance data (e.g., student.HasHonors() returns a bool based on GPA).
• Properties (getters/setters):
  • Private backing field with a public property that enforces validation in set.
  • Example: limit movie ratings to G/PG/PG-13/R/NR via property setter logic.
• Static members:
  • static fields are shared across instances (e.g., increment a static songCount in the constructor).
  • static methods belong to the class and can be called without instantiation (e.g., Math.Sqrt(...)).
  • static class cannot be instantiated.
• Inheritance:
  • Derive with colon syntax: class ItalianChef : Chef.
  • Subclasses extend or override base behavior.
  • Use virtual in base class and override in subclass to change behavior.

15. Practical notes and tips

• End statements with semicolons; Visual Studio IntelliSense will help.
• Select appropriate workloads during install to keep download size reasonable.
• Convert.* methods require correctly formatted input — catch FormatException.
• Prefer double for most decimal math; use decimal for money/precision-critical work.
• Use arrays and loops instead of many individual variables for collections.
• Encapsulate logic in methods for reusability and easier testing.
• Use try/catch to handle runtime errors and invalid user input.
• Encapsulate state with private fields and public properties to enforce invariants.

---

Sample projects and exercises included in the course

• Hello World and console shape printing
• Basic I/O examples
• Variable and string exercises
• Calculator: simple add, then a four-function calculator with operator parsing
• Mad Libs generator and string concatenation practice
• Guessing game (basic and with guess limit)
• Exponent function (loop-based power implementation)
• Array iteration and two-dimensional array examples
• Student class with HasHonors() method
• Movie class with validated rating property
• Song class demonstrating a static song count
• Inheritance example: Chef base class and ItalianChef subclass (overriding virtual methods)

---

Sources / main speaker

• Instructor: Mike, Draft Academy (Video outro: “Thanks for watching… leave a like and subscribe”.)

---

Available extras

• Compact cheat sheet listing common syntax examples (if/else, switch, for/while, methods, classes, properties, try/catch).
• Sample console app code for the four-function calculator.
• Sample code for the Movie class with validated rating property.