C# Tutorial - Full Course for Beginners

This section introduces C# as a powerful programming language used in millions of applications. It covers the initial setup process, including installing Visual Studio Community, selecting '.NET desktop development,' and creating the first console application project. The basic structure of a C# program (namespaces, classes, and the main method) is explained.

Learn to write your first C# program. It delves into the program's structure, emphasizing the importance of `program.cs`. The `Console.WriteLine()` method is introduced for printing text to the console, and `Console.ReadLine()` is used to pause the output window. The concept of sequential instruction execution is highlighted by demonstrating printing a simple shape.

This part explains variables as containers for storing data, making programs easier to manage and modify. It demonstrates declaring and assigning values to string and integer variables, and how to use them within `Console.WriteLine()` to dynamically output information. The ability to change variable values during program execution is also covered.

Explore various data types available in C#, including `string` for plain text, `char` for single characters, `int` for whole numbers, and `double` (or `float`, `decimal`) for decimal numbers. The `bool` data type for true/false values is also introduced. The distinction between storing data in variables and using constants is made clear.

Delve deeper into string manipulation. This section covers special characters like newline (` `) and escaped quotes (`"`), string concatenation using the `+` operator, and useful string methods like `.Length`, `.ToUpper()`, `.ToLower()`, `.Contains()`, `[]` for character access (indexing starts at 0), `.IndexOf()`, and `.Substring()`.

This segment focuses on numerical operations. It explains integer and decimal types, basic arithmetic operators (`+`, `-`, `*`, `/`, `%`), and the importance of order of operations. The tutorial also highlights differences in results when performing calculations with integers versus doubles and introduces `Math` class methods such as `Math.Abs()`, `Math.Pow()`, `Math.Sqrt()`, `Math.Max()`, `Math.Min()`, and `Math.Round()`.

Learn how to receive input from the user. It clarifies the difference between `Console.Write()` and `Console.WriteLine()` and explains how `Console.ReadLine()` captures user input as a string. A simple program is built to demonstrate asking for a user's name and age, then incorporating that input into a greeting.

A practical application of user input is presented by building a basic calculator. This includes converting string input to numerical types (integers or doubles) using `Convert.ToInt32()` or `Convert.ToDouble()` to perform mathematical operations. Caution is given regarding handling different numerical types.

This section walks through creating a Mad Libs game. It demonstrates using multiple user inputs (color, plural noun, celebrity) and dynamically inserting them into a predefined story using string concatenation, showcasing how variables can personalize program output.

Introduces arrays as collections capable of holding multiple values of the same data type. It covers declaring and initializing arrays with values, accessing individual elements using zero-based indexing, and updating array elements. Creating an empty array with a specified size for later population is also discussed.

Explains methods as reusable blocks of code for specific tasks. It demonstrates defining a simple method (`SayHi`) and calling it from the `Main` method. The concept of method parameters is introduced, showing how to pass arguments to customize method behavior, such as passing a name and age to the `SayHi` method.

This section explains how methods can return values using the `return` keyword. A `Cube` method is created that takes an integer, calculates its cube, and returns the result. It clarifies how a non-`void` return type allows the method to send data back to the part of the code that called it.

Introduces `if` statements for conditional logic, allowing programs to make decisions. It covers basic `if` statements, `if-else` structures, and complex conditions using logical operators like `&&` (AND) and `||` (OR). The negation operator `!` for inverting boolean values is also showcased.

Expands on `if` statements by focusing on comparisons. A `GetMax` method is built to compare two or three numbers and return the largest one, demonstrating comparison operators (`>`, `<`, `>=`, `<=`, `==`, `!=`). The method illustrates how conditions dynamically drive program flow based on value relationships.

Build a more advanced four-function calculator that handles addition, subtraction, multiplication, and division. It uses `if-else if-else` statements to determine which operation to perform based on user input for the operator (`+`, `-`, `*`, `/`) and includes error handling for invalid operator entries.

Introduces `switch` statements as a cleaner alternative to multiple `if-else if` statements for checking a single value against several possible cases. A method `GetDay` is created to convert a numerical day (0-6) into its corresponding day of the week, with a `default` case for invalid inputs. The use of the `break` keyword within `switch` cases is explained.

Explains `while` loops for repeatedly executing a block of code as long as a specified condition remains true. It demonstrates a simple `while` loop that increments and prints an index. The concept of an 'infinite loop' and how to avoid it by ensuring the loop condition eventually becomes false is covered. `Do-while` loops, which execute at least once before checking the condition, are also introduced.

Builds a guessing game using `while` loops, `if` statements, and variables. The game requires the user to guess a `secretWord` and includes a `guessLimit` to enhance gameplay. It illustrates how `Boolean` flags and nested `if` statements can manage game logic, such as determining win/loss conditions based on the number of guesses.

Introduces `for` loops as a specialized loop for iterating a specific number of times or through collections, often used with an iterating variable. It compares `for` loops to `while` loops, showing how `for` loops concisely integrate initialization, condition, and iteration statements. A practical example demonstrates using a `for` loop to iterate and print elements of an array.

This section guides on creating a custom exponent method using a `for` loop. The method `GetPower` takes a base number and a power, calculating the base raised to that power. It highlights how a loop can perform repeated multiplication, essential for exponentiation.

Introduces two-dimensional arrays, which are essentially arrays where each element is another array, forming a grid or matrix. It covers declaring, initializing, and accessing elements in a 2D array using double indexing (row and column). The flexibility of creating 2D arrays with specified dimensions for later population is also mentioned.

Explains the use of comments in C# code for documentation and temporary disabling of code. It covers single-line comments (`//`) and multi-line comments (`/* ... */`). The utility of comments for leaving notes for oneself or other developers and for debugging purposes is highlighted.

This section covers exception handling using `try-catch-finally` blocks. It demonstrates how to anticipate and gracefully handle errors (exceptions) that might crash a program, such as division by zero or invalid input format. Different types of exceptions and the `e.Message` property for displaying error details are discussed, along with the optional `finally` block.

Introduces fundamental concepts of Object-Oriented Programming: classes and objects. A class is explained as a blueprint for creating custom data types (e.g., `Book` class with `title`, `author`, `pages`). An object is an instance of a class, representing a concrete entity (e.g., specific `book1` and `book2` objects). The process of creating classes and objects, and assigning values to their attributes, is demonstrated.

Focuses on constructors, special methods within a class that are automatically called when an object of that class is created. It explains how constructors can be used to initialize object attributes upon creation, making object instantiation cleaner and more efficient. The flexibility of having multiple constructors with different parameters is also shown.

Explores object methods, which are functions defined within a class that objects can use to perform actions or query their own data. A `Student` class is used to demonstrate a `HasHonors` method that checks a student's GPA to determine honor roll status. This highlights how methods operate on an object's specific attributes.

This section introduces getters and setters, which are used to control access to class attributes, enforcing data validation and security. By making an attribute `private` and exposing it through public properties with `get` and `set` accessors, developers can define rules (e.g., valid movie ratings) for how data is read and written. The concept of a 'Boolean flag' for internal state tracking is also shown within the setter logic.

Covers static attributes, which belong to the class itself rather than individual objects. A `Song` class is used to demonstrate a `SongCount` static attribute that tracks the total number of song objects created. This illustrates how static members provide class-level information or functionality, accessible directly through the class name.

Explains static methods, which are callable directly on the class and do not require an object instance. The `Math` class is used as an example of a static class with static methods (e.g., `Math.Sqrt()`). A custom `UsefulTools` static class with a static `SayHi` method is created to demonstrate defining utility functions that can be used without instantiating the class.

Introduces inheritance, a core OOP concept allowing one class (subclass) to inherit properties and methods from another class (superclass). A `Chef` superclass and an `ItalianChef` subclass are used to demonstrate how `ItalianChef` inherits general chef abilities while also adding specialized methods (`MakePasta`) and overriding inherited methods (`MakeSpecialDish` using the `virtual` and `override` keywords) to tailor its functionality.