Ultimate C# Masterclass For 2023

In-depth .NET programming course from basics to advanced. Focus on clean code, performance and practice.

What you'll learn

You will gain an in-depth understanding of C#.

You will understand how to write high-performance C# code.

You will understand the principles of object-oriented programming

You will learn the most useful design patterns.

You will learn to write code of excellent quality.

You will gain the knowledge necessary for C# job interviews.

You will practice your skills by solving exercises in the browser, as well as by creating advanced projects.

You will learn how to use Visual Studio like a pro.

Requirements

No programming experience is needed. I'll teach you everything you need to know.

A computer with an access to the Internet.

No paid software is needed; all tools used in this course are free.

Description

Welcome to the "Ultimate C# Masterclass" course! Are you ready to take your knowledge and career to the next level?36 hours of on-demand videos, 58 coding exercises, 51 quizzes, and 12 assignments. All this is to help you start coding in C# like a pro.I'm a .NET Technical Lead with over 10 years of professional experience. I will help you on this journey every step of the way, no matter if you are a complete beginner who has never coded before or a developer who wants to advance to the next level. We will start from the basics, but we will not stop there.I will not only teach you how to code but also how to code well. Clean code and good design will be our priorities, and design patterns will be shown in practice, not as abstract concepts that seem impossible to be used in real-life challenges. Refactoring will be something we practice all the time.Programs written in C# are fast, but we can make them faster. The performance will be discussed in detail.You will learn more than C# syntax. It is not only a course about the language but a course about programming in general. You will understand why all the things we learn are needed and how to use them right. Moreover, I will show you how they work under the hood, and thanks to that, you will gain an in-depth understanding of C#.Practice makes perfect. You will solve dozens of coding exercises right in the browser. You will also implement coding assignments, such as a program processing the data read from an external API or an app for analyzing PDF files. You will also solidify your knowledge by solving short quizzes as well as doing final knowledge checks after each section.This course comes with a 30-day money-back guarantee. If you are not satisfied, you can return it and get all your money back, no questions asked. In other words, you don't risk anything by purchasing this course. You have nothing to lose, and the knowledge you will gain may take your career to the next level.So, why hesitate? Join me in this course and start coding like a professional.

Overview

Section 1: Introduction

Lecture 1 Welcome! Basic information & how to get help

Lecture 2 46 seconds about your instructor

Lecture 3 72 seconds about what this course is

Lecture 4 105 seconds about what this course isn’t

Lecture 5 97 seconds about practicing what you learn

Lecture 6 112 seconds about time optimization

Lecture 7 Installing Visual Studio Community

Lecture 8 Accessing the code

Lecture 9 Resources you can download

Section 2: C# Fundamentals

Lecture 10 Section introduction

Lecture 11 Our first C# program

Lecture 12 From a text file to an executable program

Lecture 13 Programmer's most important skill

Lecture 14 The goal for this section

Lecture 15 Variables

Lecture 16 Naming variables & introduction to clean code

Lecture 17 Operators

Lecture 18 Implicitly typed variables

Lecture 19 User input

Lecture 20 Debugging with breakpoints

Lecture 21 Coding exercises introduction

Lecture 22 Comments

Lecture 23 Boolean type. Logical negation, equality, comparison, and modulo operators

Lecture 24 AND and OR logical operators

Lecture 25 if/else conditional statement

Lecture 26 The scope of local variables

Lecture 27 Methods - part 1 - void methods

Lecture 28 Methods - part 2 - non-void methods

Lecture 29 Methods - part 3 - parameters types and the return type. Static typing in C#

Lecture 30 Parsing a string to an int (int.Parse method)

Lecture 31 The first exception

Lecture 32 Adding a new project to a solution

Lecture 33 Assignments - Introduction

Lecture 34 Assignment - Simple Calculator - Description and requirements

Lecture 35 Assignment - Simple Calculator - It's time for you to implement it

Lecture 36 Assignment - Simple Calculator - Solution

Lecture 37 String interpolation

Lecture 38 Switch statement

Lecture 39 Char

Lecture 40 A need for loops

Lecture 41 While loop - part 1

Lecture 42 += and ++ operators. Infinite loops

Lecture 43 While loop - part 2

Lecture 44 Do…while loop

Lecture 45 For loop

Lecture 46 Break

Lecture 47 Continue

Lecture 48 Nested loops

Lecture 49 Loops performance

Lecture 50 Arrays

Lecture 51 Multi-dimensional arrays

Lecture 52 Foreach loop

Lecture 53 Lists

Lecture 54 "out" keyword

Lecture 55 TryParse method

Lecture 56 Assignment - TODO List - Description and requirements

Lecture 57 Assignment - TODO List - It's time for you to try to solve it

Lecture 58 Assignment - TODO List - Implementation - User options & adding a TODO

Lecture 59 Assignment - TODO List - Implementation - Listing and Removing TODOs

Lecture 60 Assignment - TODO List - Refactoring

Section 3: Basics of Object-Oriented Programming

Lecture 61 Section introduction

Lecture 62 The issues in our code. A need for Object-Oriented Programming

Lecture 63 Introduction to object-oriented programming

Lecture 64 Understanding OOP with the DateTime type

Lecture 65 Abstraction

Lecture 66 Our first class

Lecture 67 Data hiding

Lecture 68 Custom constructor

Lecture 69 C# restrictions on code outside classes. Top-level statements

Lecture 70 Adding methods to classes

Lecture 71 Encapsulation

Lecture 72 Methods overloading

Lecture 73 Constructors overloading. Calling one constructor from another

Lecture 74 "this" keyword (current instance reference)

Lecture 75 Optional parameters

Lecture 76 Expression-bodied methods

Lecture 77 Validation of constructor parameters

Lecture 78 Readonly and const

Lecture 79 Limitations of fields. A need for properties

Lecture 80 Properties

Lecture 81 Object initializers

Lecture 82 Computed properties

Lecture 83 Static methods and classes

Lecture 84 Static fields, properties and constructors

Lecture 85 Single Responsibility Principle - Introduction

Lecture 86 Single Responsibility Principle - Refactoring (part 1)

Lecture 87 Single Responsibility Principle - Refactoring (part 2)

Lecture 88 Single Responsibility Principle - Refactoring (part 3)

Lecture 89 Files, namespaces and the using directive

Lecture 90 Global using directives

Lecture 91 Assignment - Dice Roll Game - Description and requirements

Lecture 92 Assignment - Dice Roll Game - It's time for you to try to solve it

Lecture 93 Assignment - Dice Roll Game - Random

Lecture 94 Assignment - Dice Roll Game - Magic Number Antipattern

Lecture 95 Assignment - Dice Roll Game - Designing classes

Lecture 96 Assignment - Dice Roll Game - Enums

Lecture 97 Assignment - Dice Roll Game - Ternary conditional operator

Section 4: Object-Oriented Programming: Polymorphism, Inheritance, Interfaces

Lecture 98 Section introduction

Lecture 99 A need for polymorphism

Lecture 100 Inheritance

Lecture 101 Inheriting members from the base class. Protected access modifier

Lecture 102 Overriding members from the base class. Virtual methods and properties

Lecture 103 Virtual methods - practice

Lecture 104 A deeper inheritance hierarchy

Lecture 105 Multiple inheritance

Lecture 106 System.Object and the ToString method

Lecture 107 Inheriting constructors and the "base" keyword

Lecture 108 Implicit conversion

Lecture 109 Explicit conversion

Lecture 110 Upcasting and downcasting

Lecture 111 "is" operator

Lecture 112 Null

Lecture 113 "as" operator

Lecture 114 Abstract classes

Lecture 115 Abstract methods

Lecture 116 A need for abstract methods

Lecture 117 Sealed classes and methods

Lecture 118 Static classes are always sealed

Lecture 119 Extension methods

Lecture 120 A need for interfaces

Lecture 121 Interfaces

Lecture 122 Interfaces vs abstract classes

Lecture 123 JSON

Lecture 124 Assignment - Cookies Cookbook - Description and requirements

Lecture 125 Assignment - Cookies Cookbook - It's time for you to try to solve it

Lecture 126 Assignment - Cookies Cookbook - High-level design

Lecture 127 Assignment - Cookies Cookbook - Dependency Inversion and Dependency Injection

Lecture 128 Assignment - Cookies Cookbook - Designing data types

Lecture 129 Assignment - Cookies Cookbook - Printing data object. LINQ.

Lecture 130 Assignment - Cookies Cookbook - Printing the ingredients

Lecture 131 Assignment - Cookies Cookbook - Composing the recipe by the user

Lecture 132 Assignment - Cookies Cookbook - Reading and writing from and to a *.txt file

Lecture 133 Assignment - Cookies Cookbook - Reading and writing from and to a *.json file

Lecture 134 Assignment - Cookies Cookbook - Template Method Design Pattern

Lecture 135 Assignment - Cookies Cookbook - Cleanup and project organizing

Section 5: Exceptions and error handling

Lecture 136 Section introduction

Lecture 137 Exception object

Lecture 138 Stack trace

Lecture 139 Handling exceptions. Try-catch-finally

Lecture 140 Multiple catch blocks

Lecture 141 Throwing exceptions explicitly

Lecture 142 Built-in exception types

Lecture 143 StackOverflowException. Recursive methods

Lecture 144 Precise exceptions

Lecture 145 Rethrowing exceptions. "throw" vs "throw ex"

Lecture 146 Rethrowing a System.Exception object

Lecture 147 Global try-catch block

Lecture 148 Code inside the catch block

Lecture 149 Exception filters

Lecture 150 Custom exceptions

Lecture 151 When to define custom exceptions

Lecture 152 Exceptions as a hidden part of a method signature

Lecture 153 Two extreme schools of using exceptions

Lecture 154 Smart usage of exceptions - throw

Lecture 155 Smart usage of exceptions - catch

Lecture 156 Assignment - Game Data Parser - Description and requirements

Lecture 157 Assignment - Game Data Parser - It's time for you to try to solve it

Lecture 158 Assignment - Game Data Parser - Sunny day scenario

Lecture 159 Assignment - Game Data Parser - Flow controlled by exceptions

Lecture 160 Assignment - Game Data Parser - Adding details to JsonException

Lecture 161 Assignment - Game Data Parser - Custom logger

Lecture 162 Assignment - Game Data Parser - Reducing usage of exception

Lecture 163 Assignment - Game Data Parser - Refactoring - Extracting methods

Lecture 164 Assignment - Game Data Parser - Refactoring - SRP, DI and classes decoupling

Section 6: Generic types & advanced use of methods

Lecture 165 Section introduction

Lecture 166 Introduction to generic types

Lecture 167 Understanding how List works under the hood

Lecture 168 Simplified List (adding a new item)

Lecture 169 Simplified List (deleting an item at given index)

Lecture 170 A need for generic types. Implementing a generic type

Lecture 171 A need for tuples

Lecture 172 Tuples

Lecture 173 C# without generics. ArrayList

Lecture 174 Generic methods

Lecture 175 Generic methods with multiple type parameters

Lecture 176 Convert.ChangeType method. "typeof" keyword and the Type object

Lecture 177 A need for type constraints

Lecture 178 Improving the performance of the List. Measuring the time of the code execution

Lecture 179 Type constraints - the constraint on the base type

Lecture 180 IComparable interface. Ordering objects

Lecture 181 Type constraints - the constraint on the implemented interface

Lecture 182 Type constraints - numeric types. Generic math

Lecture 183 Type constraints - summary. Multiple type constraints

Lecture 184 Advanced use of methods - introduction

Lecture 185 Funcs and Actions

Lecture 186 Lambda expressions

Lecture 187 Delegates

Lecture 188 Dictionary - introduction

Lecture 189 Dictionary - practice

Lecture 190 A need for the Strategy design pattern

Lecture 191 Refactoring the code using Funcs and lambda expressions

Lecture 192 Open-Closed Principle. Strategy design pattern

Lecture 193 Generic filtering of collections

Lecture 194 Caching

Lecture 195 Assignment - Custom Cache - Description and requirements

Lecture 196 Assignment - Custom Cache - It's time for you to try to solve it

Lecture 197 Assignment - Custom Cache - Implementation

Lecture 198 Assignment - Custom Cache - The Decorator design pattern

Lecture 199 Assignment - Custom Cache - Composing many Decorators together

Section 7: LINQ

Lecture 200 Section introduction

Lecture 201 What is LINQ?

Lecture 202 LINQ and extension methods

Lecture 203 LINQ, IEnumerable and method chaining

Lecture 204 Deferred execution

Lecture 205 Any

Lecture 206 All

Lecture 207 Count

Lecture 208 Contains

Lecture 209 OrderBy

Lecture 210 First and Last

Lecture 211 Where

Lecture 212 Distinct

Lecture 213 Select

Lecture 214 Average. Anonymous types

Lecture 215 Assignment - Refactoring to LINQ - Description and requirements

Lecture 216 Assignment - LINQ Refactoring - It's time for you to try to solve it

Lecture 217 Assignment - Refactoring to LINQ - Nested loop and code readability

Lecture 218 Assignment - Refactoring to LINQ - Find and Replace window

Lecture 219 Assignment - Refactoring to LINQ - Fewer loops & multiline strings formatting

Lecture 220 Assignment - Refactoring to LINQ - Checking if collection has duplicates

Lecture 221 If you want to learn more about LINQ…

Section 8: .NET under the hood

Lecture 222 Section introduction

Lecture 223 .NET and C#

Lecture 224 Common Intermediate Language (CIL)

Lecture 225 Common Language Runtime (CLR)

Lecture 226 Memory of a program. The stack and the heap

Lecture 227 Value semantics vs reference semantics

Lecture 228 Value types vs reference types

Lecture 229 Value types vs reference types - practical tips

Lecture 230 "ref" keyword

Lecture 231 Using "ref" with reference types

Lecture 232 Unified type system. A need for boxing and unboxing

Lecture 233 Boxing and unboxing

Lecture 234 Boxing and unboxing - performance cost

Lecture 235 Garbage Collector - introduction

Lecture 236 Garbage Collector - memory fragmentation and defragmentation

Lecture 237 Garbage Collector - the Mark-and-Sweep algorithm

Lecture 238 Garbage Collector - generations of objects

Lecture 239 Memory leaks

Lecture 240 Finalizers

Lecture 241 Dispose method - introduction

Lecture 242 Dispose method - writing to a file using StreamWriter

Lecture 243 Dispose method - reading from a file using StreamReader

Lecture 244 Dispose method - implementation

Lecture 245 CSV files

Lecture 246 Reading CSV files

Lecture 247 Assignment - CSV Processing Improvements - Description and requirements

Lecture 248 Assignment - CSV Processing Improvements - It's time for you to try to solve it

Lecture 249 Assignment - CSV Processing Improvements - Code analysis & tips

Lecture 250 Assignment - CSV Processing Improvements - Reducing the size of Dictionaries

Lecture 251 Assignment - CSV Processing Improvements - Reducing the number of boxings

Lecture 252 Assignment - CSV Processing Improvements - Analysis

Section 9: Advanced C# types

Lecture 253 Section introduction

Lecture 254 Reflection

Lecture 255 Attributes

Lecture 256 Structs

Lecture 257 Structs vs Classes - crucial differences

Lecture 258 Structs vs Classes - low-level differences

Lecture 259 Choosing between structs and classes

Lecture 260 Why should we make structs immutable?

Lecture 261 Non-destructive mutation

Lecture 262 "with" expression

Lecture 263 Readonly structs

Lecture 264 A close look at the System.Object type. The ReferenceEquals method

Lecture 265 Equals method

Lecture 266 Overriding the Equals method in classes

Lecture 267 Overriding the Equals method in structs

Lecture 268 IEquatable interface

Lecture 269 == operator

Lecture 270 Operators overloading

Lecture 271 Overloading of implicit and explicit conversion operators

Lecture 272 Hash functions

Lecture 273 Default implementation of the GetHashCode method

Lecture 274 When to override the GetHashCode method

Lecture 275 Overriding the GetHashCode method

Lecture 276 ValueTuples

Lecture 277 Benefits of immutable types

Lecture 278 Records

Lecture 279 Record structs

Lecture 280 Nullable value types

Lecture 281 Nullable reference types

Lecture 282 Null-forgiving operator

Lecture 283 Using nullable reference types. Generic type constraints related to nullability

Lecture 284 APIs

Lecture 285 Querying an API using C#

Lecture 286 A class for querying APIs

Lecture 287 Assignment - Star Wars Planets Stats - Description and requirements

Lecture 288 Assignment - Star Wars Planets Stats - It's time for you to try to solve it

Lecture 289 Assignment - Star Wars Planets Stats - JsonPropertyNameAttribute and DTOs

Lecture 290 Assignment - Star Wars Planets Stats - Exceptions handling

Lecture 291 Assignment - Star Wars Planets Stats - Type design

Lecture 292 Assignment - Star Wars Planets Stats - Converting DTO to a custom type

Lecture 293 Assignment - Star Wars Planets Stats - Finishing the app and the MaxBy method

Lecture 294 Assignment - Star Wars Planets Stats - Refactoring

Lecture 295 Assignment - Star Wars Planets Stats - Splitting the class

Lecture 296 Assignment - Star Wars Planets Stats - Universal table printer

Section 10: Collections

Lecture 297 Section introduction

Lecture 298 The role of the IEnumerable interface

Lecture 299 A close look at the IEnumerable interface

Lecture 300 Implementing IEnumerable

Lecture 301 Implicit and explicit interface implementation

Lecture 302 Implementing IEnumerable

Lecture 303 Indexers

Lecture 304 Collection initializers

Lecture 305 ICollection and IList interfaces

Lecture 306 Breaking the Interface Segregation Principle

Lecture 307 Interface Segregation Principle

Lecture 308 The benefits of readonly collections

Lecture 309 Readonly collections. ReadOnlyCollection and ReadOnlyDictionary

Lecture 310 Big O Notation

Lecture 311 Binary search algorithm

Lecture 312 Binary search algorithm - implementation

Lecture 313 Binary search algorithm - complexity

Lecture 314 Improving performance when using Lists

Lecture 315 Linked list

Lecture 316 Linked list vs List

Lecture 317 Dictionaries under the hood

Lecture 318 Performance of Dictionaries

Lecture 319 HashSet

Lecture 320 Queue

Lecture 321 Stack

Lecture 322 "params" keyword

Lecture 323 A need for yield statement

Lecture 324 yield statement - behavior analysis

Lecture 325 yield statement and iterators

Lecture 326 yield statement - practice. yield break statement

Lecture 327 Implementing IEnumerable interface using iterators

Lecture 328 Assignment - Custom Linked List - Description and requirements

Lecture 329 Assignment - Custom Linked List - It's time for you to try to solve it

Lecture 330 Assignment - Custom Linked List - Data structures

Lecture 331 Assignment - Custom Linked List - The AddToFront method

Lecture 332 Assignment - Custom Linked List - Implementing IEnumerable

Lecture 333 Assignment - Custom Linked List - Adding new items at the end of the list

Lecture 334 Assignment - Custom Linked List - The Clear method

Lecture 335 Assignment - Custom Linked List - Removing items and the Contains method

Lecture 336 Assignment - Custom Linked List - The CopyTo method

Lecture 337 Assignment - Custom Linked List - Summary and performance. Private classes

Section 11: Projects, assemblies, solutions

Lecture 338 Section introduction

Lecture 339 Projects and solutions

Lecture 340 Project properties

Lecture 341 Debug build vs Release build

Lecture 342 Assemblies

Lecture 343 Referencing types from another assembly

Lecture 344 Referencing types from another project

Lecture 345 Internal access modifier. Principles of using access modifiers

Lecture 346 Protected internal access modifier

Lecture 347 Private protected access modifier

Lecture 348 Access modifiers - summary

Lecture 349 How to structure the code in a solution

Lecture 350 NuGet

Lecture 351 *.csproj files

Lecture 352 *.sln files

Lecture 353 Updating the .NET version

Section 12: Strings

Lecture 354 Section introduction

Lecture 355 Char

Lecture 356 Char representation in memory. Character encoding

Lecture 357 Managing various encodings

Lecture 358 Immutability of strings

Lecture 359 Strings - value or reference types?

Lecture 360 Strings as members in structs

Lecture 361 A need for StringBuilder

Lecture 362 StringBuilder

Lecture 363 String interning

Lecture 364 Flyweight design pattern

Lecture 365 Advanced string formatting

Lecture 366 Culture-specific string formatting

Lecture 367 Specific culture vs Invariant culture

Lecture 368 Assignment - Tickets Data Aggregator - Description and requirements

Lecture 369 Assignment - Tickets Data Aggregator - It's time for you to try to solve it

Lecture 370 Assignment - Tickets Data Aggregator - Reading text from PDF

Lecture 371 Assignment - Tickets Data Aggregator - List all PDFs from a folder

Lecture 372 Assignment - Tickets Data Aggegator - Splitting a string by multiple separatos

Lecture 373 Assignment - Tickets Data Aggegator - Parsing culture-specific strings

Lecture 374 Assignment - Tickets Data Aggegator - Saving result in a text file

Lecture 375 Assignment - Tickets Data Aggegator - Refactoring

Lecture 376 Assignment - Tickets Data Aggegator - Compliance with the SRP

Section 13: Numeric types

Lecture 377 Section introduction

Lecture 378 Decimal number system

Lecture 379 Binary number system

Lecture 380 Maximal numbers on a given number of digits

Lecture 381 Numbers in memory. Integer

Lecture 382 Adding binary numbers

Lecture 383 Numeric overflow & silent failures

Lecture 384 "checked" keyword

Lecture 385 Checked context - when to use it?

Lecture 386 Scope of the checked context. "unechecked" keyword

Lecture 387 Integral numeric types overview

Lecture 388 Floating-point numbers

Lecture 389 double and float

Lecture 390 Smart usage of binary floating point numbers

Lecture 391 Decimal

Section 14: Events

Lecture 392 Section introduction

Lecture 393 A need for communication between objects

Lecture 394 A need for the Observer design pattern

Lecture 395 Observer design pattern

Lecture 396 Defining an event and subsribing to it

Lecture 397 Raising events

Lecture 398 EventHandler delegate & EventArgs type

Lecture 399 Event vs delegate members

Lecture 400 Memory leaks caused by events

Lecture 401 Windows Forms - introduction

Lecture 402 The first Windows Forms app

Lecture 403 Understanding Windows Forms files

Lecture 404 Events in Windows Forms

Lecture 405 Windows Forms - basic UI elements

Lecture 406 Assignment - Numeric Types Suggester - Description and requirements

Lecture 407 Assignment - Numeric Types Suggester - It's time for you to try to solve it

Lecture 408 Assignment - Numeric Types Suggester - User Interface & basic events

Lecture 409 Assignment - Numeric Types Suggester - Handling KeyPress event

Lecture 410 Assignment - Numeric Types Suggester - Numbers validation and BigInteger type

Lecture 411 Assignment - Numeric Types Suggester - Choosing numeric type

Section 15: Bonus section

Lecture 412 Bonus lecture

Beginners who have never programmed before.,Intermediete C# developers who want to improve their skills and gain in-depth understanding of this language.,Programmers switching languages to C#.