Ultimate C# Masterclass for 2024

Introduction
1 Welcome! Basic information & how to get help
2 seconds about your instructor
3 seconds about what this course is
4 seconds about what this course isn’t
5 seconds about practicing what you learn
6 seconds about time optimization
7 Installing Visual Studio Community
8 Accessing the code
9 Resources you can download
10 Coding exercises issues troubleshooting

C# Fundamentals
11 Section introduction
12 Our first C# program
13 From a text file to an executable program
14 Programmer’s most important skill
15 The goal for this section
16 Variables
17 Naming variables & introduction to clean code
18 Variables
19 Operators
20 Implicitly typed variables
21 User input
22 Debugging with breakpoints
23 Coding exercises introduction
24 Variables and operators
25 Comments
26 Boolean type. Logical negation, equality, comparison, and modulo operators
27 Bools & operators
28 AND and OR logical operators
29 Boolean type and operators
30 ifelse conditional statement
31 ifelse conditional statement
32 The scope of local variables
33 Booleans, operators and ifelse conditional statement
34 Methods – part 1 – void methods
35 Methods – part 2 – non-void methods
36 Methods – AbsoluteOfSum method
37 Methods – part 3 – parameters types and the return type. Static typing in C#
38 Methods and typing
39 Parsing a string to an int (int.Parse method)
40 The first exception
41 Adding a new project to a solution
42 Assignments – Introduction
43 Assignment – Simple Calculator – Description and requirements
44 Assignment – Simple Calculator – It’s time for you to implement it
45 Assignment – Simple Calculator – Solution
46 String interpolation
47 String interpolation – FormatDate
48 Switch statement
49 Switch statement – DescribeDay
50 Char
51 A need for loops
52 While loop – part 1
53 += and ++ operators. Infinite loops
54 While loop – part 2
55 While loop – CalculateSumOfNumbersBetween
56 Do…while loop
57 Do-while loop – RepeatCharacter
58 For loop
59 For loop – Factorial
60 Break
61 Continue
62 Break and continue
63 Nested loops
64 Loops performance
65 Arrays
66 Arrays
67 Arrays (1) – BuildHelloString
68 Arrays (2) – IsWordPresentInCollection
69 Multi-dimensional arrays
70 Multi-dimensional arrays – FindMax
71 Foreach loop
72 Foreach loop – IsAnyWordLongerThan
73 Lists
74 Lists – GetOnlyUpperCaseWords
75 out keyword
76 TryParse method
77 Assignment – TODO List – Description and requirements
78 Assignment – TODO List – It’s time for you to try to solve it
79 Assignment – TODO List – Implementation – User options & adding a TODO
80 Assignment – TODO List – Implementation – Listing and Removing TODOs
81 Assignment – TODO List – Refactoring

Basics of Object-Oriented Programming
82 Section introduction
83 The issues in our code. A need for Object-Oriented Programming
84 Introduction to object-oriented programming
85 Understanding OOP with the DateTime type
86 Basics of OOP
87 Abstraction
88 Our first class
89 Data hiding
90 Custom constructor
91 HotelBooking class
92 C# restrictions on code outside classes. Top-level statements
93 Adding methods to classes
94 Basics of classes
95 Encapsulation
96 The Triangle class
97 Methods overloading
98 Constructors overloading. Calling one constructor from another
99 Encapsulation & overloading
100 Expression-bodied methods
101 this keyword (current instance reference)
102 Optional parameters
103 Dog class
104 Validation of constructor parameters
105 Readonly and const
106 Optional parameters and more
107 Limitations of fields. A need for properties
108 Properties
109 Properties of the Order class
110 Object initializers
111 Computed properties
112 Computed properties – DailyAccountState class
113 Static methods and classes
114 Static classes – NumberToDayOfWeekTranslator
115 Static fields, properties and constructors
116 Properties & static
117 string.Split and string.Join methods
118 Single Responsibility Principle – Introduction
119 Single Responsibility Principle – Refactoring (part 1)
120 Single Responsibility Principle – Refactoring (part 2)
121 Single Responsibility Principle – Refactoring (part 3)
122 Single Responsibility Principle
123 Files, namespaces and the using directive
124 Global using directives
125 Assignment – Dice Roll Game – Description and requirements
126 Assignment – Dice Roll Game – It’s time for you to try to solve it
127 Assignment – Dice Roll Game – Random
128 Assignment – Dice Roll Game – Magic Number Antipattern
129 Assignment – Dice Roll Game – Designing classes
130 Assignment – Dice Roll Game – Enums
131 Assignment – Dice Roll Game – Ternary conditional operator

Object-Oriented Programming Polymorphism, Inheritance, Interfaces
132 Section introduction
133 A need for polymorphism
134 Inheritance
135 Inheriting members from the base class. Protected access modifier
136 Basics of polymorphism
137 Overriding members from the base class. Virtual methods and properties
138 Virtual methods – practice
139 Inheritance & Overriding – Animals
140 Virtual methods – StringsProcessor classes
141 A deeper inheritance hierarchy
142 Multiple inheritance
143 System.Object and the ToString method
144 Virtual methods and properties
145 Inheriting constructors and the base keyword
146 Implicit conversion
147 Explicit conversion
148 Conversion
149 Upcasting and downcasting
150 is operator
151 Null
152 is operator and null object -NumericTypesDescriber class
153 as operator
154 Abstract classes
155 Abstract methods
156 Abstract methods – Shapes
157 A need for abstract methods
158 Sealed classes and methods
159 Static classes are always sealed
160 Abstract & sealed
161 Extension methods
162 Extension methods – List extensions
163 A need for interfaces
164 Interfaces
165 Interfaces – Applying multiple transformations to a number
166 Interfaces vs abstract classes
167 Interfaces
168 JSON
169 Assignment – Cookies Cookbook – Description and requirements
170 Assignment – Cookies Cookbook – It’s time for you to try to solve it
171 Assignment – Cookies Cookbook – High-level design
172 Assignment – Cookies Cookbook – Dependency Inversion and Dependency Injection
173 Assignment – Cookies Cookbook – Designing data types
174 Assignment – Cookies Cookbook – Printing data object. LINQ
175 Assignment – Cookies Cookbook – Printing the ingredients
176 Assignment – Cookies Cookbook – Composing the recipe by the user
177 Assignment – Cookies Cookbook – Reading and writing from and to a .txt file
178 Assignment – Cookies Cookbook – Reading and writing from and to a .json file
179 Assignment – Cookies Cookbook – Template Method Design Pattern
180 Assignment – Cookies Cookbook – Cleanup and project organizing

Exceptions and error handling
181 Section introduction
182 Exception object
183 Stack trace
184 Handling exceptions. Try-catch-finally
185 Try-catch-finally. DivideNumbers
186 Multiple catch blocks
187 Basics of exceptions
188 Throwing exceptions explicitly
189 Built-in exception types
190 Built-in exceptions
191 StackOverflowException. Recursive methods
192 Precise exceptions
193 Rethrowing exceptions. throw vs throw ex
194 Rethrowing exceptions
195 Rethrowing a System.Exception object
196 Global try-catch block
197 Code inside the catch block
198 Exception filters
199 Exception handling
200 Custom exceptions
201 When to define custom exceptions
202 Custom exception – InvalidTransactionException
203 Exceptions as a hidden part of a method signature
204 Two extreme schools of using exceptions
205 Smart usage of exceptions – throw
206 Smart usage of exceptions – catch
207 Smart usage of exceptions
208 Assignment – Game Data Parser – Description and requirements
209 Assignment – Game Data Parser – It’s time for you to try to solve it
210 Assignment – Game Data Parser – Sunny day scenario
211 Assignment – Game Data Parser – Flow controlled by exceptions
212 Assignment – Game Data Parser – Adding details to JsonException
213 Assignment – Game Data Parser – Custom logger
214 Assignment – Game Data Parser – Reducing usage of exception
215 Assignment – Game Data Parser – Refactoring – Extracting methods
216 Assignment – Game Data Parser – Refactoring – SRP, DI and classes decoupling

Generic types & advanced use of methods
217 Section introduction
218 Introduction to generic types
219 Understanding how List works under the hood
220 Simplified List (adding a new item)
221 Simplified List (deleting an item at given index)
222 A need for generic types. Implementing a generic type
223 Generic types – Pair class
224 A need for tuples
225 Tuples
226 Generic types introduction
227 C# without generics. ArrayList
228 Generic methods
229 Generic methods with multiple type parameters
230 Generic methods – SwapTupleItems method
231 Convert.ChangeType method. typeof keyword and the Type object
232 Generic types and methods
233 A need for type constraints
234 Improving the performance of the List. Measuring the time of the code execution
235 Type constraints – the constraint on the base type
236 IComparable interface. Ordering objects
237 Type constraints – the constraint on the implemented interface
238 Type constraints & IComparable – SortedList of FullNames
239 Type constraints – numeric types. Generic math
240 Type constraints – summary. Multiple type constraints
241 Type constraints
242 Advanced use of methods – introduction
243 Funcs and Actions
244 Basics of Funcs and Actions
245 Lambda expressions
246 Basics of lambda expressions
247 Delegates
248 Funcs, lambda expressions and delegates
249 Dictionary – introduction
250 Dictionary – practice
251 Dictionaries – FindMaxWeights of pets
252 A need for the Strategy design pattern
253 Refactoring the code using Funcs and lambda expressions
254 Open-Closed Principle. Strategy design pattern
255 Generic filtering of collections
256 Advanced use of generic types
257 Caching
258 Assignment – Custom Cache – Description and requirements
259 Assignment – Custom Cache – It’s time for you to try to solve it
260 Assignment – Custom Cache – Implementation
261 Assignment – Custom Cache – The Decorator design pattern
262 Assignment – Custom Cache – Composing many Decorators together

LINQ
263 Section introduction
264 What is LINQ
265 LINQ and extension methods
266 LINQ, IEnumerableT and method chaining
267 Deferred execution
268 Basics of LINQ
269 Any
270 All
271 Any & All
272 Count
273 Contains
274 Count & Contains
275 OrderBy
276 First and Last
277 OrderBy, First & Last
278 Where
279 Distinct
280 Where & Distinct
281 Select
282 Average. Anonymous types
283 Select & Average
284 Assignment – Refactoring to LINQ – Description and requirements
285 Assignment – LINQ Refactoring – It’s time for you to try to solve it
286 Assignment – Refactoring to LINQ – Nested loop and code readability
287 Assignment – Refactoring to LINQ – Find and Replace window
288 Assignment – Refactoring to LINQ – Fewer loops & multiline strings formatting
289 Assignment – Refactoring to LINQ – Checking if collection has duplicates
290 If you want to learn more about LINQ

NET under the hood
291 Section introduction
292 NET and C#
293 Common Intermediate Language (CIL)
294 Common Language Runtime (CLR)
295 NET basics
296 Memory of a program. The stack and the heap
297 Value semantics vs reference semantics
298 Value types vs reference types
299 Memory of a program. Value vs reference types
300 Value types vs reference types – practical tips
301 ref keyword
302 ref modifier – FastForwardToSummer
303 Using ref with reference types
304 Unified type system. A need for boxing and unboxing
305 Boxing and unboxing
306 Boxing and unboxing – performance cost
307 Boxing and unboxing
308 Garbage Collector – introduction
309 Garbage Collector – memory fragmentation and defragmentation
310 Garbage Collector – the Mark-and-Sweep algorithm
311 Basics of Garbage Collector and memory management
312 Garbage Collector – generations of objects
313 Memory leaks
314 Finalizers
315 Garbage Collector and memory management – advanced
316 Dispose method – introduction
317 Dispose method – writing to a file using StreamWriter
318 Dispose method – reading from a file using StreamReader
319 Dispose method – implementation
320 Dispose method – AllLinesFromTextFileReader
321 CSV files
322 Reading CSV files
323 Assignment – CSV Processing Improvements – Description and requirements
324 Assignment – CSV Processing Improvements – It’s time for you to try to solve it
325 Assignment – CSV Processing Improvements – Code analysis & tips
326 Assignment – CSV Processing Improvements – Reducing the size of Dictionaries
327 Assignment – CSV Processing Improvements – Reducing the number of boxings
328 Assignment – CSV Processing Improvements – Analysis

Advanced C# types
329 Section introduction
330 Reflection
331 Attributes
332 Attributes – MustBeLargerThanAttribute
333 Limitations of attributes parameters types
334 Reflection
335 Structs
336 Structs vs Classes – crucial differences
337 Structs vs Classes – low-level differences
338 Choosing between structs and classes
339 Structs
340 Why should we make structs immutable
341 Immutable struct – Time
342 Non-destructive mutation
343 with expression
344 Readonly structs
345 Immutable types
346 A close look at the System.Object type. The ReferenceEquals method
347 Equals method
348 Overriding the Equals method in classes
349 Overriding the Equals method in structs
350 Equals – overriding it in the FullName class
351 IEquatableT interface
352 == operator
353 Equality checks
354 Operators overloading
355 Overloading of implicit and explicit conversion operators
356 Operators overloading – Time structs
357 Hash functions
358 Default implementation of the GetHashCode method
359 When to override the GetHashCode method
360 GetHashCode
361 Overriding the GetHashCode method
362 GetHashCode – Time struct
363 ValueTuples
364 Benefits of immutable types
365 Immutable types
366 Records
367 Record structs
368 Records – GpsCoordinates
369 Nullable value types
370 Nullable reference types
371 Null-forgiving operator
372 Using nullable reference types. Generic type constraints related to nullability
373 Nullable types
374 APIs
375 Querying an API using C#
376 A class for querying APIs
377 Assignment – Star Wars Planets Stats – Description and requirements
378 Assignment – Star Wars Planets Stats – It’s time for you to try to solve it
379 Assignment – Star Wars Planets Stats – JsonPropertyNameAttribute and DTOs
380 Assignment – Star Wars Planets Stats – Exceptions handling
381 Assignment – Star Wars Planets Stats – Type design
382 Assignment – Star Wars Planets Stats – Converting DTO to a custom type
383 Assignment – Star Wars Planets Stats – Finishing the app and the MaxBy method
384 Assignment – Star Wars Planets Stats – Refactoring
385 Assignment – Star Wars Planets Stats – Splitting the class
386 Assignment – Star Wars Planets Stats – Universal table printer

Collections
387 Section introduction
388 The role of the IEnumerable interface
389 A close look at the IEnumerable interface
390 Implementing IEnumerable
391 Implicit and explicit interface implementation
392 Implementing IEnumerableT
393 IEnumerable & interfaces implementation
394 Indexers
395 ValueTuples & Custom indexer – PairOfArrays
396 Collection initializers
397 ICollection and IList interfaces
398 Breaking the Interface Segregation Principle
399 Interface Segregation Principle
400 The benefits of readonly collections
401 Readonly collections. ReadOnlyCollection and ReadOnlyDictionary
402 Collections – advanced topics
403 Big O Notation
404 Binary search algorithm
405 Binary search algorithm – implementation
406 Binary search algorithm – complexity
407 Complexity of algorithms
408 Improving performance when using Lists
409 Linked list
410 Linked list vs List
411 Dictionaries under the hood
412 Performance of Dictionaries
413 Performance of collections
414 HashSet
415 HashSet – CreateUnion method
416 Queue
417 Stack
418 params keyword
419 params keyword – Does Stack contain any of the given words
420 A need for yield statement
421 yield statement – behavior analysis
422 yield statement and iterators
423 yield statement – practice. yield break statement
424 yield statement – GetAllAfterLastNullReversed method
425 Implementing IEnumerable interface using iterators
426 Assignment – Custom Linked List – Description and requirements
427 Assignment – Custom Linked List – It’s time for you to try to solve it
428 Assignment – Custom Linked List – Data structures
429 Assignment – Custom Linked List – The AddToFront method
430 Assignment – Custom Linked List – Implementing IEnumerable
431 Assignment – Custom Linked List – Adding new items at the end of the list
432 Assignment – Custom Linked List – The Clear method
433 Assignment – Custom Linked List – Removing items and the Contains method
434 Assignment – Custom Linked List – The CopyTo method
435 Assignment – Custom Linked List – Summary and performance. Private classes

Projects, assemblies, solutions
436 Section introduction
437 Projects and solutions
438 Project properties
439 Debug build vs Release build
440 Projects and solutions
441 Assemblies
442 Referencing types from another assembly
443 Referencing types from another project
444 Internal access modifier. Principles of using access modifiers
445 Protected internal access modifier
446 Private protected access modifier
447 Access modifiers – summary
448 Access modifiers
449 How to structure the code in a solution
450 NuGet
451 csproj files
452 sln files
453 Updating the .NET version

Strings
454 Section introduction
455 Char
456 Char representation in memory. Character encoding
457 Managing various encodings
458 Chars and encoding
459 Immutability of strings
460 Strings – value or reference types
461 Strings as members in structs
462 Strings
463 A need for StringBuilder
464 StringBuilder
465 StringBuilder – The Reverse method
466 String interning
467 Flyweight design pattern
468 Advanced string formatting
469 Culture-specific string formatting
470 Specific culture vs Invariant culture
471 Advanced features of strigs
472 Assignment – Tickets Data Aggregator – Description and requirements
473 Assignment – Tickets Data Aggregator – It’s time for you to try to solve it
474 Assignment – Tickets Data Aggregator – Reading text from PDF
475 Assignment – Tickets Data Aggregator – List all PDFs from a folder
476 Assignment – Tickets Data Aggregator – Splitting a string by multiple separators
477 Assignment – Tickets Data Aggregator – Parsing culture-specific strings
478 Assignment – Tickets Data Aggregator – Saving result in a text file
479 Assignment – Tickets Data Aggregator – Refactoring
480 Assignment – Tickets Data Aggregator – Compliance with the SRP

Numeric types
481 Section introduction
482 Decimal number system
483 Binary number system
484 Maximal numbers on a given number of digits
485 Binary number system
486 Numbers in memory. Integer
487 Adding binary numbers
488 Numeric overflow & silent failures
489 Numbers in memory
490 checked keyword
491 Checked context – when to use it
492 Scope of the checked context. unechecked keyword
493 Checked – Fibonacci sequence
494 Integral numeric types overview
495 Floating-point numbers
496 double and float
497 Smart usage of binary floating point numbers
498 Floating point numbers – The IsAverageEqualTo method
499 Decimal

Events
500 Section introduction
501 A need for communication between objects
502 A need for the Observer design pattern
503 Observer design pattern
504 Defining an event and subscribing to it
505 Raising events
506 Events – User and BankAccount
507 EventHandler delegate & EventArgs type
508 Observer design pattern & basics of events
509 Event vs delegate members
510 Memory leaks caused by events
511 Events – WeatherDataAggregator
512 Windows Forms – introduction
513 The first Windows Forms app
514 Understanding Windows Forms files
515 Events in Windows Forms
516 Windows Forms – basic UI elements
517 Assignment – Numeric Types Suggester – Description and requirements
518 Assignment – Numeric Types Suggester – It’s time for you to try to solve it
519 Assignment – Numeric Types Suggester – User Interface & basic events
520 Assignment – Numeric Types Suggester – Handling KeyPress event
521 Assignment – Numeric Types Suggester – Numbers validation and BigInteger type
522 Assignment – Numeric Types Suggester – Choosing numeric type

Unit Testing
523 Section introduction
524 Manual tests vs Automated tests
525 Setting up the testing environment
526 First unit tests
527 Unit testing fundamentals
528 Running the tests
529 Naming unit tests
530 Test messages
531 AAA pattern
532 Valuable tests
533 TestCase
534 Naming parameterized tests
535 TestCaseSource
536 Test cases
537 Assertions on exceptions. Multiple assertions in single test
538 Value of unit tests
539 Basic assertions
540 Assertions
541 Testing private methods
542 Testing internal methods
543 Benefits of unit tests – no fear of refactoring
544 Benefits of unit tests – better design
545 Benefits of unit tests – early bug detection
546 Downsides of unit tests
547 Upsides and downsides of unit tests
548 Assignment – Fibonacci generator tests – Description and requirements
549 Assignment – Fibonacci generator tests – solution
550 Testing classes depending on other classes
551 A need for mocks
552 Mocks
553 Controlling the mock behavior
554 Basics of mocks
555 The benefits of using mocks
556 Advanced mock setup
557 Assertions checking if a method was called
558 Advanced assertions on method calls
559 Usage of mocks
560 Clean code in unit tests
561 Common setup for tests
562 Tests, Dependency Inversion and Dependency Injection
563 Untestable code – no Dependency Inversion
564 Untestable code – static methods
565 Unit tests quality and code testability
566 Other kinds of software tests
567 Different types of tests
568 Assignment – Unit tests for GuessingGame – Description and requirements
569 Assignment – Unit tests for GuessingGame – Basic scenarios
570 Assignment – Unit tests for GuessingGame – Verifying messages
571 Assignment – Unit tests for GuessingGame – Approaches for messages validation
572 Assignment – Unit tests for GuessingGame – Resource files
573 Breaking changes in NUnit 4

Clean Code
574 Section introduction
575 The importance of clean code
576 Bad decisions related to code quality
577 Tech debt
578 Being professional
579 What is clean code
580 The importance of clean code
581 The importance of meaningful names
582 Renaming. The Boy Scout Rule
583 Dealing with problematic naming
584 Naming fundamentals
585 Expressive names
586 Long and short names
587 Clean Code – Coding Exercises introduction
588 Naming refactoring – Reverse method
589 Principle of the least surprise
590 Good naming
591 Bad names – meaningless words
592 Bad names – overspecific names
593 Bad names – Hungarian notation
594 Bad names – confusing names
595 Bad names – abbreviations
596 Bad names
597 Reasonable abbreviations. Conventional names
598 Context
599 Naming refactoring – Building file path based on DateTime
600 Refactoring case study – naming
601 Good signatures of methods
602 Number of parameters
603 Fewer parameters – splitting the method
604 Fewer parameters – bundling related parameters
605 Fewer parameters – avoiding boolean parameters
606 Signatures
607 Small methods
608 Method refactoring – ChooseBetterPath method
609 One method, one job
610 One method, one job – refactoring
611 Levels of abstraction
612 Composing different levels of abstraction
613 Levels of abstraction within methods
614 Methods
615 Refactoring case study – methods – introduction
616 Refactoring case study – methods – signature
617 Refactoring case study – methods – body
618 Comments
619 Method refactoring – IsNameValid method
620 The worst comments
621 The reasonable comments
622 Comments
623 When to make methods static Private methods
624 The risk of making public methods static
625 When to make methods static Public methods
626 The issues of static methods
627 Composition over inheritance
628 The issues of inheritance
629 Replacing inheritance with composition
630 The benefits of composition
631 Composition over inheritance
632 Assignment – Password Generator Refactoring – Description and requirements
633 Assignment – Password Generator Refactoring – Explaining the existing code
634 Assignment – Password Generator Refactoring – Fixing naming
635 Assignment – Password Generator Refactoring – Improving design

Multithreading & asynchrony
636 Section introduction
637 The computer’s processor
638 Threads and processes
639 Concurrency vs parallelism
640 Asynchrony
641 Multithreading basics
642 A single-threaded program
643 Starting a new thread. The Thread class
644 Multithreaded app’s code flow
645 Creating and starting new threads
646 The benefits of multithreading and asynchronous programming
647 The cost of threads. ThreadPool
648 Threads
649 Task Parallel Library (TPL)
650 Task class
651 Returning a value from a Task
652 Waiting for the Task result
653 Wait and WaitAll methods
654 Tasks & waiting
655 Continuations. The ContinueWith method
656 Chaining continuations. Continuations of multiple tasks
657 Continuations
658 Canceling a Task
659 Task lifecycle
660 OperationCanceledException
661 Exceptions thrown by other threads
662 Exceptions in tasks
663 Asynchronous exception handling
664 Handling AggregateException
665 Handling exceptions with continuations
666 Multiple continuations for one task
667 Handling task cancellation
668 The need for synchronization
669 Atomic operations
670 Race condition
671 Locks
672 Synchronization
673 The need for asyncawait
674 await keyword
675 Async methods
676 asyncawait
677 Asynchrony vs multithreading
678 The flow of an asynchronous program
679 Asyncawait and threads
680 Asyncawait summary
681 Asyncawait practice
682 Asyncawait
683 Exceptions in async methods
684 Downsides of multithreading & asynchrony
685 Using async methods in practice. HttpClient
686 Assignment – Quote Finder – Description and requirements
687 Assignment – Quote Finder – Fetching data
688 Assignment – Quote Finder – Smart asynchrony
689 Assignment – Quote Finder – Single-threaded processing
690 Assignment – Quote Finder – Multi-threaded processing
691 Assignment – Quote Finder – Refactoring

Bonus section
692 Bonus lecture