C# Complete Master Course

Learn How To Code in C#. Dive into The Language In and Outs and Best Practices. For Windows, Mac and Linux.

What you'll learn
Use the .NET CLI to create, build and run C# based applications
Classify and create C# built-in types, custom types and data structures
Implement the error handling logic of C# based applications
Learn delegates, lambdas and event basing programming
Explain and leverage LINQ and LINQ operators
Understand immutability and equality in C#
Use Visual Studio Code to edit C# code, build and run C# console applications
Requirements
The activities must be reproduces on a compatible version of Windows, Mac or Linux operating system. You must know how to use your operating system
You should have a prior experience in software development
Description
This course is the perfect course to dive into the C# language conceptsC# is one of the most popular programming languages. It is a powerful cross-platform language.After learning and mastering the language, you will be able to go further and learn ASP Net Core to develop web apps, or you can work as a mobile or Desktop developer after learning .NET MAUI. In this course, we will walk through the language internals and you will be able to proceed to the next step. You will learn C# basics and more on Visual Studio Code. The most important aspects of the language are included in this course. This is the course for you to become a productive and skilled C# developer.A course for all platformsThis course is made for Windows, Mac and Linux developers. Since the first versions of .NET Core, C# became a real cross platform programming language. We will work on Visual Studio Code, one of the most popular code editors.This course is a deep dive in the C# language. We will focus on the language and its best practices.In the first sections, we will have an overview of the fundamentals of the language, including:C# basicsThe flow of execution of programsThe language structure and syntaxData typesThen we will learn more intermediate concepts like:Classes, structures and enumerationsMembers: fields, properties and methodsType conversionsInheritance and interfacesGenericsNullable value typesThat will lead us to the most advanced topics:CollectionsError handlingDelegatesImmutability and equalityCoding along the wayEvery section of this course comes with slides that contain all the key concepts, practical examples, quizzes and some challenges. You can follow along and learn C# by codingWho is this course for ?This course is suited C# newbies, students or even developers who want to learn the language or consolidate their knowledge about the languageBy the end of the course you will have all the knowledge and practice to be a productive C# developer in your studies or in your professional environment.This course is about C# 9. I regularly update the content of the course, new sections about C# 10 will be released.So join me and start off your C# learning journey !

Overview

Section 1: Introduction

Lecture 1 Course introduction

Lecture 2 What you will learn in this course

Lecture 3 Who is this course for ?

Lecture 4 Prerequisites

Lecture 5 Course overview

Section 2: Set-up your environment

Lecture 6 Introduction

Lecture 7 Install the SDK

Lecture 8 The .NET CLI

Lecture 9 Visual Studio Code installation

Lecture 10 Visual Studio Code : first look

Lecture 11 Visual Studio Code extensions

Lecture 12 Visual Studio Code customization

Section 3: C# fundamentals

Lecture 13 Introduction

Lecture 14 What is C# ?

Lecture 15 Compilation and execution of C# code

Lecture 16 Demo : Compile-time and run-time error

Lecture 17 C# keywords

Lecture 18 Demo : C# keywords

Lecture 19 Demo : Create a console application

Lecture 20 What are statements ?

Lecture 21 Demo : statements

Lecture 22 C# code blocks

Lecture 23 Demo : blocks

Lecture 24 Variables

Lecture 25 Demo : variables

Lecture 26 Implicitly typed variables

Lecture 27 Demo : implicitly typed variables

Lecture 28 C# operators

Lecture 29 Demo : operators

Lecture 30 Expressions

Lecture 31 Demo : Intellisense

Lecture 32 Demo : Classes and members

Lecture 33 Section summary

Section 4: Program flow

Lecture 34 Introduction

Lecture 35 C# program execution flow

Lecture 36 Demo : execution flow

Lecture 37 The If statement

Lecture 38 Demo : If statement

Lecture 39 The switch statement

Lecture 40 Demo : switch statement

Lecture 41 The do while statement

Lecture 42 Demo : Do while

Lecture 43 The while statement

Lecture 44 Demo : While

Lecture 45 The for statement

Lecture 46 Demo : for

Lecture 47 Jump statements

Lecture 48 Demo : jump statements

Lecture 49 Debug C# code

Lecture 50 Section summary

Section 5: Reference and value types

Lecture 51 Introduction

Lecture 52 C# a strongly typed language

Lecture 53 Types overview

Lecture 54 Value types

Lecture 55 Demo : value types

Lecture 56 What is the stack ?

Lecture 57 Reference types

Lecture 58 Demo : reference types

Lecture 59 What is the heap ?

Lecture 60 Built-in types

Lecture 61 Custom types

Lecture 62 Section summary

Section 6: Built-in types and namespaces

Lecture 63 Introduction

Lecture 64 The boolean type

Lecture 65 Demo : booleans

Lecture 66 Integer types

Lecture 67 Demo : integers

Lecture 68 Floating point types

Lecture 69 Demo : floating point types

Lecture 70 Binary floating point types

Lecture 71 Demo : binary floating point types

Lecture 72 The decimal floating point type

Lecture 73 Demo : decimal

Lecture 74 The char type

Lecture 75 Demo : The char type

Lecture 76 The string type

Lecture 77 Demo : string

Lecture 78 The default operator and literal

Lecture 79 Namespaces

Lecture 80 Demo : namespaces

Lecture 81 Section summary

Section 7: Classes, structures and enumerations

Lecture 82 Introduction

Lecture 83 Classes

Lecture 84 Demo : classes

Lecture 85 Constants, fields and properties

Lecture 86 Demo : constants, fields and properties

Lecture 87 Structures

Lecture 88 Demo : structures

Lecture 89 Enumerations

Lecture 90 Demo : enumerations

Lecture 91 Assemblies

Lecture 92 Add references to a project

Lecture 93 Access modifiers

Lecture 94 Demo : access modifiers

Lecture 95 Comments

Lecture 96 Demo : comments

Lecture 97 Section summary

Section 8: Methods, constructors and the static keyword

Lecture 98 Introduction

Lecture 99 Methods

Lecture 100 Demo : methods

Lecture 101 Method overloading

Lecture 102 Demo : method overloading

Lecture 103 Optional parameters and named arguments

Lecture 104 Demo : optional parameters and named arguments

Lecture 105 Pass a value type parameter to a method

Lecture 106 Demo : Pass a value type parameter to a method

Lecture 107 Pass a reference type parameter to a method

Lecture 108 Demo : Pass a reference type parameter to a method

Lecture 109 Constructors

Lecture 110 Demo : constructors

Lecture 111 The static keyword

Lecture 112 Demo : static classes and members

Lecture 113 Demo : The this keyword

Lecture 114 Challenge presentation : Launch a rocket

Lecture 115 Challenge solution : Launch a rocket

Lecture 116 Section summary

Section 9: Type conversion and type testing

Lecture 117 Introduction

Lecture 118 Boxing/unboxing

Lecture 119 Type conversion, implicit conversions

Lecture 120 Demo : implicit conversions

Lecture 121 Type conversion, explicit conversions

Lecture 122 Demo : explicit conversions

Lecture 123 Convert with helper methods

Lecture 124 Demo : Convert with helper methods

Lecture 125 Anonymous types

Lecture 126 Demo : Anonymous types

Lecture 127 Test types with the GetType method

Lecture 128 Demo : GetType

Lecture 129 Test types with the typeof operator

Lecture 130 Demo : typeof

Lecture 131 Test types with the is operator

Lecture 132 Demo : is

Lecture 133 Section summary

Section 10: Inheritance

Lecture 134 Introduction

Lecture 135 What is inheritance ?

Lecture 136 Demo : Inheritance

Lecture 137 Virtual and override

Lecture 138 Demo : Virtual and override

Lecture 139 The abstract keyword

Lecture 140 Demo : abstract classes and methods

Lecture 141 Sealed classes and members

Lecture 142 Demo : Sealed classes and members

Lecture 143 Section summary

Section 11: Interfaces

Lecture 144 Introduction

Lecture 145 What is an interface ?

Lecture 146 Demo : create an interface

Lecture 147 Interface implementation

Lecture 148 Demo : Interface implementation

Lecture 149 Demo : implement IComparable

Lecture 150 Explicit implementation

Lecture 151 Demo : Explicit implementation

Lecture 152 Challenge presentation : logging with abstractions

Lecture 153 Challenge solution : logging with abstractions

Lecture 154 Interfaces in software development

Lecture 155 Demo : Interfaces in software development

Lecture 156 Section summary

Section 12: Generics

Lecture 157 Introduction

Lecture 158 Generic classes

Lecture 159 Demo : generic classes

Lecture 160 Generic constraints

Lecture 161 Demo : generic constraints

Lecture 162 Generic methods

Lecture 163 Demo : generic methods

Lecture 164 Generic interfaces

Lecture 165 Demo : generic interfaces

Lecture 166 Challenge presentation : Observer/observable pattern

Lecture 167 Challenge solution without generics : Observer/observable pattern

Lecture 168 Challenge solution with generics : Observer/observable pattern

Lecture 169 Section summary

Section 13: Nullable value types and null checking

Lecture 170 Introduction

Lecture 171 Nullables

Lecture 172 Demo : nullable value types

Lecture 173 Null checking

Lecture 174 Demo : null checking

Lecture 175 Section summary

Section 14: Arrays and collections

Lecture 176 Introduction

Lecture 177 Working with collections of objects

Lecture 178 Arrays

Lecture 179 Demo : arrays

Lecture 180 Challenge presentation : the ring buffer

Lecture 181 Challenge solution : the ring buffer

Lecture 182 Section summary

Section 15: Collections, collection interfaces and yield return

Lecture 183 Introduction

Lecture 184 Collections and the IEnumerable interface

Lecture 185 Demo : Collection and IEnumerable

Lecture 186 Yield return and IEnumerable

Lecture 187 Demo : Yield return and IEnumerable

Lecture 188 Demo : implement the IEnumerable interface

Lecture 189 ICollection interface

Lecture 190 Demo : ICollection interface

Lecture 191 Collection performance

Lecture 192 Section summary

Section 16: List and dictionaries

Lecture 193 Introduction

Lecture 194 Lists

Lecture 195 Demo : lists

Lecture 196 Dictionaries

Lecture 197 Demo : dictionaries

Lecture 198 Dictionaries under the hood

Lecture 199 Demo : Dictionaries and IEqualityComparer

Lecture 200 Section summary

Section 17: Other collections

Lecture 201 Introduction

Lecture 202 Stacks

Lecture 203 Demo : stacks

Lecture 204 Queues

Lecture 205 Demo : queues

Lecture 206 Hashsets

Lecture 207 Demo : hashsets

Lecture 208 LinkedList collection

Lecture 209 Demo : LinkedList

Lecture 210 SortedDictionary collection

Lecture 211 Demo : SortedDictionary

Lecture 212 Section summary

Section 18: Read-only and immutable collections

Lecture 213 Introduction

Lecture 214 ReadOnlyCollection

Lecture 215 Demo : ReadOnlyCollection

Lecture 216 ReadOnlyDictionary

Lecture 217 Demo : ReadOnlyDictionary

Lecture 218 Immutable collections

Lecture 219 Demo : Immutable collections

Lecture 220 Section summary

Section 19: Why error handling ?

Lecture 221 Introduction

Lecture 222 .NET solutions

Lecture 223 Demo : create .NET solutions

Lecture 224 The astronomical calculation library

Lecture 225 Mass conversion class errors

Lecture 226 Gravity calculation class errors

Lecture 227 Call the library from a .NET API

Lecture 228 Why error handling ?

Lecture 229 Section summary

Section 20: Exceptions

Lecture 230 Introduction

Lecture 231 Exceptions

Lecture 232 Exception handling : try/catch/finally

Lecture 233 Demo : handle exceptions in the console application

Lecture 234 Demo : handle exceptions in the API

Lecture 235 Exception handling : throw exceptions

Lecture 236 Demo : throw exceptions in the library

Lecture 237 Demo : throwing exceptions in the library changed the behavior of the API

Lecture 238 Demo : exception handling depends on requirements

Lecture 239 Demo : multiple catch

Lecture 240 Demo : the finally statement

Lecture 241 Section summary

Section 21: Custom exceptions, exception wrapping and some best practices

Lecture 242 Introduction

Lecture 243 Custom exceptions and exception wrapping

Lecture 244 Demo : create custom exceptions

Lecture 245 Demo : use custom exceptions in the library

Lecture 246 Demo : use cutom exceptions in the API

Lecture 247 Exception handling best practices

Lecture 248 Section summary

Section 22: Delegates, events and lambdas

Lecture 249 Introduction

Lecture 250 Delegates

Lecture 251 Demo : delegates

Lecture 252 Multicast delegates

Lecture 253 Demo : Multicast delegates

Lecture 254 Anonymous methods

Lecture 255 Demo : anonymous methods

Lecture 256 Demo : create a subscription calculator

Lecture 257 Events

Lecture 258 Demo : events

Lecture 259 Handling events

Lecture 260 Demo : handling events

Lecture 261 Action, Func and lambdas

Lecture 262 Demo : Action, Func and lambdas

Lecture 263 Demo : modify the subscription calculator

Lecture 264 Demo : Expression body definitions

Lecture 265 Section summary

Section 23: LINQ Fundamentals

Lecture 266 Introduction

Lecture 267 What is LINQ ?

Lecture 268 Demo : introducing the LINQ playground project

Lecture 269 Extension methods

Lecture 270 Demo : extension methods

Lecture 271 Query and method syntax

Lecture 272 Demo : Query and method syntax

Lecture 273 Deferred execution

Lecture 274 Demo : deferred execution

Lecture 275 Demo : without using LINQ

Lecture 276 Section summary

Section 24: LINQ operators : Part1

Lecture 277 Introduction

Lecture 278 Projecting and filtering

Lecture 279 Demo : Projecting and filtering

Lecture 280 Ordering

Lecture 281 Demo : ordering

Lecture 282 Distinct

Lecture 283 Demo : distinct

Lecture 284 Get a single element

Lecture 285 Demo : get a single element

Lecture 286 Paging

Lecture 287 Demo : paging

Lecture 288 Quantifying

Lecture 289 Demo : quantifying

Lecture 290 Aggregating

Lecture 291 Demo : aggregating

Lecture 292 Section summary

Section 25: LINQ operators : Part 2

Lecture 293 Introduction

Lecture 294 Looping and assigning

Lecture 295 Demo : Looping and assigning

Lecture 296 Comparing sequences

Lecture 297 Demo : comparing sequences

Lecture 298 Flattening sequences

Lecture 299 Demo : flattening sequences

Lecture 300 Grouping

Lecture 301 Demo : grouping

Lecture 302 Set operators

Lecture 303 Demo : set operators

Lecture 304 Joining

Lecture 305 Demo : Joining

Lecture 306 Section summary

Section 26: Immutability and equality

Lecture 307 Introduction

Lecture 308 Demo : Immutability, the old way

Lecture 309 Demo : init properties ( in a top level statement Program file)

Lecture 310 Equality in C#

Lecture 311 Demo : equality in C#

Lecture 312 Section summary

Section 27: Records

Lecture 313 Introduction

Lecture 314 Introduction to records

Lecture 315 Demo : records

Lecture 316 Demo : records equality

Lecture 317 Record immutability and with expressions

Lecture 318 Demo : record immutability and with expressions

Lecture 319 Deconstructing

Lecture 320 Demo : deconstructing

Lecture 321 Demo : more on records

Lecture 322 Records and inheritance

Lecture 323 Demo : records and inheritance

Lecture 324 Section summary

Students who are new to C#,Developers who want to learn or learn more about C#,People that are passionate about C#