C# 13 - Ultimate Guide - Beginner to Advanced | Master class

Install Visual Studio 2022 from the official site, select the Community edition with .NET desktop development, sign in, customize the theme, and create a console app targeting .NET Framework 4.8.

Create your first C sharp application by defining a class with a static void main method in Visual Studio, and display output using System.console.writeline.

Explore the System.Console class in dotnet, using write, writeline, read key, read line, and clear to perform I/O in console apps; learn static usage, interactivity, and Pascal case naming.

Explore how variables store values in memory and live on the stack during method calls. Learn to declare, initialize, and use variables in C# with I/O and naming rules.

Explore the full set of C# operators, including arithmetic, assignment, increment/decrement, comparison, logical, concatenation, and the ternary operator, with explanations of pre and post forms and operator precedence.

Explore all forms of if statements in C# 12, including simple if, if-else, else-if, and nested if, and learn how control statements manage program flow.

Learn to implement switch case logic in C#, using break and default to handle multiple values, ensuring one case executes, with examples like month names, weekday names, and grade descriptions.

Explore while and do-while loops in c# 12, including initialization, condition checks, incrementation, and the for and foreach loops, and learn when to use do-while to guarantee one execution.

Understand how the for loop consolidates initialization, condition, and incrementation on one line. Compare it with while and do-while loops, and learn when to choose for versus while.

Master the break statement in C# 12 by terminating loops for, while, do-while, and switches, stopping iterations when a condition is met.

Learn how the continue statement in C# skips the current loop iteration and proceeds to the next value, contrasting it with break and showing practical use in loops.

Master nested for loops in C# 12 by combining an outer and inner loop to process branches and accounts, print sequences, and vary i and j, including reverse order.

Learn how the go to statement jumps within a single method using labels, with forward and backward jumps, and why it is discouraged in favor of for or while loops.

Create a login page for the banking project using a console app, reading username and password, validating against system and manager, then navigating to the main menu.

Validate the login, display the main menu with options like customers and funds transfer, read input via console.readline, parse to int, and loop with do-while and switch until exit.

Builds a banking project menu system by creating a customers menu and an accounts menu, using do while loops, switch cases, and methods to organize user input and navigation.

Explore object oriented programming fundamentals, including objects, classes, fields, and methods, and how the heap stores objects and enables current object method calls for scalable applications.

Learn the syntax for creating classes and objects in C#, including fields, methods, and constructors, and understand how objects are stored in the heap with reference variables.

Master the basics of classes and objects, including heap storage, reference variables, stacks for local variables, and core concepts like methods, fields, and access modifiers internal and public.

Explore fields in C# object oriented programming: syntax, modifiers (static, constant, read only), and how to declare and access fields inside a class across objects.

Explore how private, protected, private protected, internal, protected internal, and public modifiers control field visibility across classes and assemblies, including inheritance and cross-assembly access.

Create three product objects from the product class and access their fields with reference variables; compute total quantity in stock and practice finding the highest cost with an if statement.

Explore how static fields belong to the class memory rather than individual objects, can be accessed through the class name, and differ from instance fields in C# 12.

Explore constant fields in C# 12, shared by all objects and initialized at declaration. Access via the class name and learn how compile time replaces constants with literals.

Explore read only fields in C# 12, showing how they behave like instance fields yet cannot be modified after initialization, with inline or constructor initialization and real-world examples.

Define local constants with const in C# 12, using primitive types or strings initialized by a literal; values cannot change and can be accessed anytime. Reference types cannot be constants.

Explore fields in C# 12: distinguish instance versus static fields, learn access modifiers and field types, and understand initialization rules for const and readonly fields, plus memory allocation behavior.

Explore encapsulation in C# by grouping fields and methods into a class and hiding details with public getters and setters, illustrated by a product example with validation and tax calculation.

Explore encapsulation in C# by using private fields and public get and set methods; external code accesses only public members while private state remains hidden and used internally.

Learn how local variables and parameters work in instance, static, and method contexts, including stack allocation and argument passing. See examples in the set and calculate tax methods.

Explain how the this keyword refers to the current object in non-static methods, and why it is not available in static methods for accessing fields and methods.

Learn the difference between static and instance methods, how to manipulate static fields with static methods, and why static members belong to the class rather than objects.

Learn how to pass reference variables as arguments to a static method to manipulate multiple objects, compute total quantity, and understand encapsulation and abstraction in object-oriented programming.

Master default arguments and optional parameters in methods by assigning default values, enabling calls without input; see tax and interest rate examples using 10.5% and 4.5%.

Named arguments in C# 4.0 let you pass values by parameter name to improve readability when methods have many parameters; after a named argument, all following must be named.

Master method overloading in object-oriented programming by defining multiple methods with the same name but different parameters. See how varying argument types and counts select appropriate method for a call.

Explore how C# parameter modifiers determine how values are received by methods, especially the default modifier, where changes to the parameter do not affect the argument.

Learn how the ref parameter modifier enables two-way communication between a method and its caller, requiring a pre-initialized argument and the ref keyword on both sides.

Understand how the out parameter modifier in C# lets you return multiple values by using out, with the argument uninitialized at call and updated after method execution.

Explore out variable declaration in C# 7.0, declaring the argument inline with the out parameter and its type, without initialization, producing the value, e.g., 10.45.

Explore in parameter modifier in C# 7.2, which passes the argument value into the parameter while making it read-only to prevent accidental changes; use in for both argument and parameter.

Explore ref returns in C# 7.3, learning how a method can return a reference to a field and propagate updates to the original variable through a ref return.

Learn how the C# 12 params modifier lets a method receive multiple values as an array, accessible by index, and used only on the last parameter.

Explore local functions, a C# 7.0 feature that embeds small, reusable logic inside a method. Understand their scope, parameters, and return types, with an in-method average calculation example.

Explore static local functions in C# 8.0, learn they cannot access containing method variables, and see how to enable the feature by setting language version in the csproj.

Learn how recursion in C# uses a method calling itself to compute factorials, creating stack frames until a base case of zero returns one, guided by input handling.

Master C# methods by examining access modifiers, static vs instance methods, and the this keyword. Learn how named arguments, method overloading, and ref and out parameters return values.

Explore what type conversion is and when to use it, covering implicit casting, explicit casting, parsing, tryparse, and conversion methods with examples like int to long and string to boolean.

Explore implicit casting in C# 12, demonstrating automatic conversion from lower types like s byte to higher types such as int or double, without explicit syntax.

Learn explicit casting as manual type conversion, its lossy outcomes when destination types are too small, and when to use explicit vs implicit casting (int to float, int to byte).

Explain parsing as a type conversion in C#, converting digit-only strings to numeric types via the parse method, and raise a format exception for invalid input.

Learn how TryParse validates and converts a string to a numeric type using an out parameter, returning true on success and false on invalid input, avoiding exceptions.

Master converting values between primitive types with the System.Convert class, using static methods like ToString and ToByte, and handle the FormatException when needed, including int and string.

Master explicit casting or use conversion methods for all type conversions, and prefer TryParse over parse when converting strings to numbers to avoid format exceptions.

Explore C# constructors, including instance and static forms, parameterless and parameterized variants, implicit vs explicit constructors, constructor overloading, and the this keyword for field initialization and object initializers.

Explore static constructors that initialize static fields once, on first class access, unlike instance constructors that run per object; static constructors are public by default and cannot have parameters.

Understand parameterless and parameterized constructors in C#, including implicit default and explicit constructors, and learn how fields are initialized and how overloading works.

Learn constructor overloading in C#, creating parameterless and parameterized constructors with different parameter combinations: employee id, employee name, and job, to initialize fields and enable flexible object creation.

Discover how to use object initializers in C# to set fields and properties after a constructor runs, providing a flexible alternative when no matching constructor exists.

Master the nuances of constructors in C#, including instance and static constructors, default compiler-provided constructors, and constructor overloading, with guidance on parameterless constructors and object initializers.

Learn how properties guard fields in C sharp, using set and get accessors, validation logic, and auto implemented properties, including instance and static properties.

Discover read-only properties with get accessors for reading fields like salary, and write-only properties with set accessors that perform validations on tax.

Learn how automatic properties in C# 3.0 simplify code by using get and set without backing fields; the compiler creates an underscore field and supports access modifiers, including read-only properties.

Explores auto-implemented property initializers in C# 6.0, showing how to set default values for automatic properties, override per object, and rely on an automatically generated backing field.

Use properties to access private fields via public properties, with automatic properties for no validation. Properties validate or calculate values, protect fields, and offer read-only or write-only access.

Learn how C# indexers provide a shortcut to access an array stored inside a class via a public this indexer, with get and set accessors using index and value.

Learn to implement indexer overloading in C# by adding multiple indexers with int and string parameters, map names to indices with Array.IndexOf, and access values by index or name.

Explore inheritance in C#, including single, multiple, multi-level, hierarchical, and hybrid forms; access base class members with base, invoke base constructors, and override or hide methods.

Explore the five types of inheritance in C#, including single, multi-level, hierarchical, multiple inheritance via interfaces, and hybrid inheritance.

Learn how the base keyword enables a child class to access parent class members, resolving name conflicts and accessing parent fields, properties, methods, and constructors in C#.

Learn how to call the parent class constructor from the child class constructor using the base keyword in C# 12 to initialize parent and child fields.

Explain method hiding in C#, where a child class redefines a method with the same name and parameters to hide the parent method, using the new keyword to signal intent.

Override a parent method with the same name, parameters, and return type. Use virtual in the parent and override in the child to enable dynamic dispatch.

Understand how sealed classes prevent inheritance in C# 12 while allowing instantiation and member access. Use sealed to secure your design and avoid deriving from the class.

Apply the sealed modifier to overriding methods to prevent overrides in derived classes, and understand how sealed contrasts with virtual in C sharp.