Programming in C# - From Beginner to Advanced

Master variables in C#, memory concepts, top level statements, syntax, data types including integers, floats, booleans, strings, dates, plus nullables and non-nullable references, expressions, operations, warnings, and errors.

Create a new console app project by selecting console app, naming it, and leaving the do not use top level statements option unchecked for now.

Simplify a console application with top level statements by removing program class and main method, acting as the entry point. Other classes still use the namespace, class, and method structure.

Discover where the course code lives in a GitHub repository and a code folder inside the project, with each video creating a class named after the video and sample code.

Explore the dot operator to access class members like console.WriteLine and invoke methods with parentheses. Learn the difference between text strings and code semicolons in C#.

Explore blocks of code in C#, using curly brackets to define blocks inside classes and methods, and learn how indentation and tools like IntelliSense and Visual Studio improve readability.

Explore using comments in C# to clarify code and explain its purpose, with single-line // and multi-line /* */ syntax, noting that comments do not execute or affect performance.

C# is case sensitive, so exact casing matters for code, such as writing Console.WriteLine versus write line. Write the correct casing for every letter to avoid errors and run successfully.

Learn how variables store data in memory in C#, define data types like int and string, declare and initialize, use meaningful names, and address unused variable warnings.

Explore integral numeric types in C#, including byte, sine byte, short, unsigned short, int, uint, long, and ulong, their ranges, and memory usage, with guidance on when to choose each.

Understand real numbers in C# by comparing float, double, and decimal, their memory usage, precision limits, and how to use f and m suffixes for literals.

Learn how booleans represent true or false, declare boolean variables with bool, and use conditional execution to run code when a condition is met.

Learn how to store text using char and string in C#; char holds a single character, while string stores many characters, demonstrated with console write line and long text.

Learn to use escape sequences in C# to include double quotes and backslashes by using backslashes to start escapes and to print a single backslash.

Explore verbatim string literals in C#, enabling multi-line strings and selective escaping with the @ prefix. Learn how to escape backslashes and double quotes, and write strings across lines.

Explore raw string literals in C# to write multi-line strings without escapes, using three or four double quotes, including internal quotes and backslashes, and controlling text start with a delimiter.

Explore the datetime type to store date and time, create new date time values with year, month, and day, add days, and extract day of year and day of week.

Name variables meaningfully in c#, ensure the first character is a letter or underscore, numbers may appear later, use camelCase or underscores, avoid hyphens, and escape reserved keywords with @.

explore how implicitly typed local variables use var to infer type from assigned values, with examples like int, string, and DateTime; learn initialization requirements and when to use explicit types.

Learn how to use default values in C# to obtain neutral values. See int default to zero, bool to false, date time to year one, and string to nothing.

Distinguish value types and reference types in C#, with value types on the stack and reference types on the heap, where only references can be null.

Explore non-nullable reference types in C# and how nullable value types like int? extend nullability, why null reference exceptions occur, and how to enable or disable this feature.

Explore binary expressions that operate on two values, using variables for clarity, and perform addition, subtraction, multiplication, division, and the remainder; learn casting to double to prevent integer division truncation.

Explain how the plus operator acts as addition for numbers and as string concatenation for strings, including casting numbers to strings in c#, and show concatenating first and last names.

Explore binary expressions with real numbers, comparing decimal and double, and their rounding effects. See why decimal suits money applications like banking due to base ten representation and fewer errors.

Explore arithmetic overflow in C# by examining the maximum and minimum integer values, and learn how checked prevents overflow in a single expression or a code block.

See string interpolation replace the plus operator for concatenation, inserting a space between first name and last name and producing outputs like Felipe Gavilan and the sum is 11.

Explore unary expressions in c# by contrasting ordinary expressions with minus, plus plus, and minus minus, and observe how evaluation order affects console output.

Differentiate binary expressions that return values from void expressions that return nothing. Use void to express non-returning functionality; see that console.writeLine is void and cannot be assigned or incremented.

Explore the assignment operator and the plus equal operator in c#, showing how x += y updates x, and demonstrate minus equal, times equal, divide equal, remainder, and string concatenation.

Explore operator precedence in C#, showing how multiplication outruns addition, how parentheses alter evaluation, and how to write clearer code by splitting complex expressions into steps.

Define and use constants in C# to prevent changes after initialization, replacing magic numbers with named constants like a conversion factor and pi, and using constant strings for stability.

Learn how to manage unused variable warnings (CS0219) in C# by suppressing and restoring warnings with preprocessor directives, and how to treat warnings as errors to affect builds and runtime.

Explore top level statements, the single entry point file, and semicolon-delimited statements for readable code. Learn variables, data types, implicit var, value types, reference types, and nullability.

Explore conditions and iterations to add logic to your code, deciding which path to run based on a boolean expression and repeating statements through iteration.

Create a new console app project in visual studio for this module, name it conditions and iterations (or loops), and begin.

Learn how the logical negation operator flips a boolean value from true to false or false to true, with practical examples showing the effect on variables.

Explore boolean logic and expressions that return true or false, using equality (==) and inequality (!=) operators, and distinguish assignment (=) from comparison (==) in C#.

Learn to compare values in C# using greater than, less than, greater than or equal to, and less than or equal to operators, with examples on numbers and dates.

Explore conditional boolean operators in C#, using and and or to form true expressions and apply short-circuit evaluation to avoid null reference exceptions.

Explore the if statement and selection statements in programming, using boolean expressions to execute blocks of code, and use else and else if for additional conditions.

Explore the ternary conditional operator, an abbreviated if used to assign a value based on a boolean expression. See how a one-line expression can replace a multi-line if statement.

Explore how the switch statement replaces repetitive conditionals by evaluating a value once. Implement cases, breaks, and a default to route code, sharing logic across multiple cases.

Leverage switch expressions in C# to assign a message based on place, replacing repetitive if-else logic with concise mapping using the lambda operator and default discard.

Explore relational patterns in switch expressions to compare variables with constants and ranges, using cases like greater than, less than, and default to handle unmatched values.

Explore how to combine patterns in C# with not, and, or; perform null checks before accessing members; and drive decisions with switch expressions that categorize values like temperature and seasons.

Learn how the while loop executes a block of code repeatedly while a condition is true, illustrated by counting from 1 to 10 and a five-year investment example.

Understand the do-while loop, which guarantees at least one execution, unlike a while loop, illustrated by counting 1 to 10 and producing 11 when the condition fails.

Learn how the for loop combines initialization, condition, and update into one construct, replacing separate while-loop steps, with examples counting 1 to 10 and stepping by 2.

Learn how the foreach loop iterates over collections, such as strings, executing code for each element, for example printing each letter of a name.

Control loops with break to exit early and continue to skip iterations in for, while, and foreach loops; see 1–4 when break hits 5, and 1,2,3,4,6 when continue.

Explore how infinite loops arise in while and for loops, how break statements and conditions stop them, and how the program prints output until exit.

Create a simple calculator in C# that uses an infinite loop to prompt for two numbers, parse inputs with int.Parse, and display their sum, repeating until the user says no.

Master boolean logic to evaluate true or false expressions and combine them with conditional operators, apply if, ternary, switch, while, and foreach loops with continue and break, noting infinite loops.

Explore data types and type conversion in C#, learn how to transform between types, and work with arrays, indexes, and ranges, plus string modifications.

Create a new C# console project targeting net seven to explore data types and get it started.

Learn to convert data types to a string with toString in C#, enabling int to string comparisons. Note that string comparisons are case sensitive and apply to booleans and dates.

Learn how to convert strings to integers, decimals, booleans, and dates using parse. Handle format exceptions and use try parse with an out parameter to safely parse input.

Explore explicit and implicit data type conversions in C#, showing how casting integers to doubles yields precise division and when to use explicit versus implicit casting between bytes and integers.

Learn how enums group related values, such as sale statuses, and replace magic numbers with named constants. Use enums with switches, namespaces, and casting between int and enum.

Learn how arrays hold multiple elements of a data type, use zero-based indexing to read and assign elements, handle length and iteration with foreach, and recognize arrays as reference types.

Learn how arrays store values and access elements by index with square brackets, including using the end-based index to retrieve the last or second-last item.

Learn to extract multiple elements from arrays with ranges in C#. Use dot dot notation for start-to-index and the heart operator for last elements.

Define a two dimensional array, a matrix of integers, and access elements with two indices. Iterate over rows and columns using rank and get length, then print the matrix.

Learn how jagged arrays work in C#: an array of arrays with varying row lengths, how to declare and access them, and iterating with for and foreach.

Explore string manipulation in C#, including case conversion with to upper and to lower, case-insensitive comparisons, trimming spaces, replacing characters, and left-padding numbers to a fixed width.

Explore converting any data type to a string and parsing strings into numbers or dates. Examine enums and arrays as collections, and manipulate strings with uppercase, lowercase, and trimming whitespace.

Learn how functions centralize functionality to create maintainable software that is easy to program in this course module.

Create a new C# project by using the console functions to enter net seven create, and begin.

Define reusable functions in C# to print matrices and other outputs, returning values or performing actions with void. Centralize logic so changes propagate across the application and enable easy reuse.

Explore how variable scope works in functions and blocks, learn why local variables cannot be accessed outside their blocks, and discover how minimal scope and global variables shape code.

Define functions that receive parameters to compute results or print messages, using input values of types like int and decimal, and emphasize parameter order and minimizing code repetition.

Create a void function to print a two dimensional array of integers, replacing repeated code and enabling one place to adjust spacing between columns for both matrices.

Explore optional parameters with default values in C#, enabling omissions and predefined behavior. Learn to use const or default for booleans and ensure optional parameters come last after required ones.

Learn to pass a variable number of parameters in C# with the params keyword, compare to using an array, and remember that non-param values must come before the params parameter.

Explore how values are passed to functions in C#, using ref to pass by reference, and compare value types and reference types with arrays and strings.

Explore out parameters in C#, pass uninitialized variables to functions, and return multiple values by using out parameters, with examples of doubling and tripling numbers.

Learn how tuples let you return multiple values from a function and store heterogeneous data in one variable. See named elements for readability and examples of accessing item names.

Discover how local functions live inside other functions to centralize narrowly used logic, avoiding repetition by defining a local function like print value and invoking it twice.

Explore how lambda expressions simplify function syntax with a lambda operator and implicit return, showing two equivalent int sum functions and the role of delegates.

Learn to store void functions in variables with actions and delegates, and pass these functions as parameters to others to centralize processing; includes invoking by reference and generic action usage.

Learn how func represents functions that return a value and how to store such non-void functions in variables, pass function references, and invoke them with or without parameters.

Define a predicate in c sharp as a func that always returns a bool, and illustrate it with an is even example using modulo two and generics for parameter types.

Action, func and predicate show how delegates are pointers to functions that let you store and invoke functions in variables, including out-parameter scenarios.

Explore anonymous functions in c#, using the lambda operator to define unnamed routines. Pass these functions as parameters, return values with func, and manage parameter typing and implicit types.

The main function acts as the entry point, converting top level statements into a void or int returning method, with args used for input and exit codes observed.

Declare your own functions to centralize and reuse code, pass input parameters and return outputs; use labeled tuples, delegates, and anonymous methods to store and pass functions.

Move from the program CSS file to multiple files, using classes, structs, records, and enum examples. Learn to create your own data types in C#, using int and decimal.

Create a new console project, name it 'classes, structs and records', and proceed to begin this module.

Define a class as a reference type with fields, then instantiate it with new. Store data like brand and year in fields, access via dot, and follow underscore naming.

Learn to replace public fields with properties using get and set to read and write safely. Centralize data behavior, enforce private fields, and format brand in uppercase.

Learn how properties centralize access to fields, use auto-implemented and read-only properties, assign default values, and implement a computed property for brand and year formatting with a lambda expression.

Implement methods inside a car class, including accelerate overloads, private set speed, and a read-only max speed, with lambda one-liners and speed limit at 120.

Explore constructors as the instantiation mechanism in C#, including parameterless and overloaded constructors, enforcement of required fields, and constructor chaining to reuse code.

Explore returning multiple values in C# by using a result class; build a calculator that outputs double and triple values via a single structured result.

Master static vs. instance members in C# by examining a car example and a calculator class, showing how to count instances and call static methods.

Learn how extension methods let you add new methods to existing classes from outside, as syntactic sugar, using static classes and the this keyword to count words in a string.

Learn property patterns in c# to match on an object's properties and properties of properties, with practical examples like car brand and year, and first name length checks.

Explore anonymous types in c#, unnamed data containers created with curly braces and read-only properties; use non-destructive mutation via with to create new anonymous types from existing ones.

Learn how namespaces organize classes and other types, preventing name conflicts. Use using directives and full type names to reference the correct calculator across namespaces.

Discover how implicit usings automatically bring in system namespaces and how global usings propagate namespaces across a C# application, managed via the csproj file and item group settings.

Use partial classes to split a class into generated and custom parts across files. Place both parts in the same namespace to access members without overwriting custom code.

Understand how structs in C# serve as value types with data and behavior similar to classes. See a struct example with properties, constructors, and a distance method for 2D space.

Explore how class instances are reference types and why two objects with identical properties remain unequal, and how structs require extra work for equality, with records offering a simple alternative.

Explore records as syntactic sugar that enable immutability and read-only data, easy copying, and structural equality, while compiling to classes or structs for safe parallel programming.

Create your first record in c#, define a nominal record with first and last name, compare instances for equality, and note records default to class but can compile as struct.

Learn how positional records enforce immutability in C# by defining a company with name and foundation year, where properties are read only after creation, with default deconstructors.

Learn how to clone immutable records using non-destructive mutation with the with operator, creating a new record with a changed foundation year while preserving the original.

Explore init-only setters in c# to create immutable properties that can be initialized in any order via object initializers, offering flexible immutability beyond records.

Instantiate a class and assign its properties; enforce required ones with the Sets Required Members attribute on the constructor and supply defaults to avoid errors.

Use the Elvis operator to safely access values that may be null and avoid null reference errors, by using the question mark to guard member access.

Use the null coalescing operator to provide a default, often zero, when an expression is null, and employ the Elvis operator to safely access the length of a nullable array.

Learn how the null-forgiving operator in c#'s suppresses null dereference warnings for non-nullable reference types, and see its use in method calls and unit tests for argument null exceptions.

Define and organize data using classes, structs, and records; use static members to belong to types rather than instances, and apply the using directive to organize namespaces and enable comparisons.

Explore the basics of object oriented programming, covering inheritance, access modifiers, and interfaces to build flexible, maintainable C# applications.

Create the project for this module by starting a new console application and naming it 'object oriented programming' to begin exploring C# development.

Explore object oriented programming in C-sharp, focusing on polymorphism, abstraction, encapsulation, and inheritance, while learning delegates, base and derived classes, and access modifiers.

Learn how inheritance creates a base vehicle class shared by derived car and truck classes, and leverage polymorphism to write flexible code that handles any vehicle type.

Demonstrate inheritance in C# by overriding a base go in reverse in the truck to add a beep, while car and bicycle use the base behavior.

Abstract the vehicle class to prevent instantiation and serve as a base for car, truck, and bicycle; abstract members like sound horn and maximum speed enforce derived implementations.

Mark a class as sealed to prevent derivation, so derived classes cannot extend it; seal an override to stop further overrides and improve compile performance, as in the car example.

Show how derived classes must invoke the base class constructor and pass brand to the base constructor. An empty base constructor lets derived classes omit constructors.

Explore how inheritance shares code and how the toString method, which almost any class has, arises from the object base class; override it and use polymorphism to accept any object.

Learn how casting enables polymorphism in C# via as and is operators, safely handling car and truck types and avoiding invalid cast exceptions.

Explore limits in inheritance in c#: a class cannot inherit multiple bases, and long inheritance chains (ideally under three levels) reduce flexibility; use composition and polymorphism for maintainable code.

Explore inheritance with records, where a record class can inherit from another record class; records cannot inherit from classes, and record structs cannot participate in inheritance.

Explore why structs cannot participate in inheritance in C# and why deriving from a point 2D struct fails. A compile-time error occurs when attempting to derive from a struct.

Learn how access modifiers control the accessibility of types and members in C-sharp, including public, private, internal, protected, protected internal, and private protected, across projects and assemblies.

Explore how the public access modifier enables cross-project access by creating a utilities class library, adding a project reference, and using a public class with a property and a method.

Explore how the private access modifier restricts member access to inside the class in C#. Learn that private is the default for members, and that private classes must be nested.

Learn how the internal access modifier restricts types and members to the same project, enabling access within the utilities project while preventing access from external projects.

Learn how protected members in C# restrict access to the declaring class and its derived classes, with practical examples showing access from derived classes but not from non-derived clients.

Grasp protected internal access: code in the same project can access it freely, while external code needs a derived class, as shown with a property in utilities and derived types.

Understand the private protected modifier, enabling access from the same class or a derived class within the same project, while blocking access from outside the project.

Explore how the file access modifier restricts a type’s accessibility to the same file, allowing usage within that file but preventing external instantiation.

Explore interfaces as a contract that enables multiple inheritance, letting classes implement required members and properties while interfaces themselves cannot be instantiated.

Define and implement interfaces in c sharp, outlining signatures for methods and properties. Demonstrate implementing these members in classes, structs, and records, including not implemented exception and multiple interfaces.

Learn how polymorphism with interfaces lets a method accept any type that implements an interface, enabling shared code and flexible processing of classes A, B, and beyond.

Share code with an interface for file storage, implement Azure and AWS providers, and inject the chosen provider into the movies controller to save posters via dependency injection.

Dependency injection decouples the movie controller from concrete file storage implementations, enabling flexible switches like AWS or Google via interfaces. Prefer constructor injection for maintainable, adaptable software.

Demonstrate implementing a delete file interface across AWS and Azure. Use constructor injection to supply a file storage to the movies controller, reducing repetition and clarifying dependencies.

Explore how an inversion of control container centralizes dependency instantiation and enables switching from Azure to AWS file storage, using dependency injection, NuGet packages, and dotnet seven configuration.

Configure an inversion of control container in a console app to centralize dependency injection for Azure and AWS file storage, then resolve the movies controller.

Explore how default implementations in interfaces prevent breaking changes when adding new members, like an edit method in a file storage interface, with AWS overriding and Azure using the default.

Learn how operator overloading enables defining custom behavior for binary operations, using a vector2d class with x and y, overloading the plus operator, and overriding toString for console output.

Explore enforcing value equality in C# structs by overloading the == and != operators, and correctly override Equals and GetHashCode to support collections.

Apply the same equality concepts from structs to classes by creating a point class, copying its structure, and compiling; override equals, get hashcode, and the equal and not equal operator.

Explore how inheritance shares code between base and derived classes, with default functionality that can be overridden. Learn about abstract classes, polymorphism, access modifiers, and interfaces as contracts.

Explore debugging and error handling in C# development, using tools to understand how code works and respond to unexpected situations in applications.

Create a new console application for this module, naming it error handling and debugging, and set the project to .NET 7 to begin.

Explore how write line and debug write line help you log messages and variable values, configure debug listeners, and toggle output between debug and release modes for safe, targeted logging.

Use trace points to log messages without modifying source code in C#. Display the function name and the C variable value in debug mode via trace points.

Use breakpoints and trace points to pause a C# program, inspect variables, and execute code line by line. Use F5, F10, F11; manage breakpoints and re-execute lines without rewinding state.

Learn how temporary breakpoints differ from normal breakpoints by halting during debugging mode and then automatically removing after the executed line.

Explore conditional breakpoints by using conditional expressions and hit counts to activate code paths. Apply conditions like a == 7 or a < b, with parallel-programming options saved for later.

Learn how to use dependent breakpoints to activate a breakpoint only after another breakpoint is hit, with a hands-on example using method A and method B.

Visualize variable values during debugging in Visual Studio by using breakpoints and stepping, see changes in a, lastName, and tuples, and export arrays to CSV.

Use the Visual Studio immediate window to perform operations and modify variables at execution time during debugging. Set breakpoints and experiment with values in real time.

Learn to use the call stack window to trace the execution sequence of methods in a C# application, identifying who called whom from A to B to C.

Understand how exceptions stop program execution and how the stack trace shows the call sequence from the program start to the error, including the throw that raises the exception.

Prevent abrupt program termination by using try-catch blocks to catch exceptions and continue execution, employing specific and general catches for different error types.

Discover how the finally block always executes after a try, regardless of exceptions. See it clean up resources even when an unexpected exception occurs.

Explore the default dotnet exceptions, starting with the base exception class, and learn how common cases like argument, null, divide by zero, and file not found are handled.

Create and throw custom exceptions by inheriting from exception, customize error messages with constructors and base(message), and store information in the exception class for detailed error handling.

Explore how to filter exceptions with multiple catch blocks using a custom exception’s error type to handle client, server, and not found errors in C#.

Explore rethrowing exceptions after performing intermediate processing inside a try-catch block, enabling the outer catch to handle errors and inspect the exception message.

Learn how breakpoints facilitate debugging by stopping execution and inspecting variables. Master exception handling in C# with a try catch finally block for robust error management.

Explore generics to generalize algorithms across data types and examine how collections store multiple values, with arrays as a basic example.

Create a new console app project and name it generics and collections, then click create and begin.

Master generics in C# to pass data types as parameters, creating a single method for any array type and building generic classes and interfaces for reusable algorithms.

Learn how to apply generic constraints in C#, including struct, class, nullable, and parameterless constructors, and combine them with inheritance, using vehicle, car, and truck as examples.

Explore lists as dynamic collections beyond arrays, adding, removing, and sorting integers with a generic list and iterating with for each.

Explore dictionaries in C# by storing key-value pairs with generics, handling contains key, add/remove operations, and keys and values; classify numbers into even and odd using a dictionary of lists.

discover how the get hash code method classifies data with hash tables, enabling fast searches by mapping keys to hashes based on properties or tuples such as brand and year.

Learn to use the IEnumerable interface to iterate arrays, lists, and dictionaries, and implement a generic print method that writes values to the console, illustrating polymorphism.

Use yield return to build an enumerable element by element and enable lazy evaluation as values are requested, and optionally convert to a list to realize all values.

Explore how yield enables finite and infinite calculations by yielding values from an algorithm that adds two to an initial value repeatedly, producing an enumerable sequence.

Implement and use IComparable and IComparer to compare and sort people by age or by name. Include null checks and explain the int return values that indicate ordering.

Explore generics to pass data types as parameters across functions, classes, and interfaces, and leverage collections like lists and dictionaries to store, iterate, and sort data and manage key-value pairs.

Explore link queue in this module and discover features that make working with collections easier.

Create a new console app project for this module, name it Intro to Link, and get started building your first C# program.

Discover how LINQ enables language integrated queries on in-memory data, and compare method syntax with query syntax for filtering even numbers from a numbers array.

Examine deferred execution in LINQ and lazy loading, building queries without immediate evaluation. Compare deferred versus non deferred execution using to list and lambdas to show evaluation on demand.

Learn how to filter collections with the where function using anonymous and lambda expressions, apply conditions to numbers and objects, and build lists with toList in linq.

Learn how to use first and first or default to retrieve the first element of a collection, handle empty sequences with defaults, and combine where with first or default.

Learn to sort collections in C# using order by and order by descending, including sorting by numeric values and by object properties like age.

Learn how the select function projects collection elements into new shapes, transforming people into names, ages, anonymous types, or a DTO class, and even double numbers or use index.

Demonstrate flattening multiple collections with selectmany to produce a single phone-number collection from a list of people, then map each person to their numbers using an anonymous type.

Learn how to query scalars like count, sum, min, max, and average from collections in C#, including using lambda expressions to sum ages and count items with a property.

Use min by and max by to return the whole element with the min or max value, such as Eduardo with the smallest age or Alejandro with the largest age.

Explore quantifiers all, any, and contains in C# and how they answer questions about collections, such as every person is 18 or older and whether a collection contains an element.

Master take, skip, take last, and skip last to select elements from a collection, illustrated with numbers 1 to 100.

Group elements in a collection by a boolean property using group by, creating multiple groups, accessing each group's key and count, and iterating to display person names.

Learn to remove repeated elements from a collection using distinct, first for numbers array and then by a property with distinct by to deduplicate a list of people by name.

Learn how to split a collection into fixed-length sub-collections with the chunk function in C#, using 1 to 10 as examples to create groups of three (and four).

Explore Link-u to filter and project collections with minimal code, perform aggregates like counting, adding, average, max, and min, and use quantifiers for all or any elements.