UDEMY.Ultimate.C.Sharp.Masterclass.for.2026.BOOKWARE-MiMiR

Section

eBooks/Audiobooks

Group

MiMiR

Size

28,35 GB

Files

79

Date

2026-02-17

NFO

Mímir, Keeper of the Well of Wisdom
  
  Ultimate C# Masterclass for 2026

  https://www.udemy.com/course/ultimate-csharp-masterclass/

  Year         : 2026
  Language     : English
  Level        : All Levels
  Category     : Development
  Subcategory  : Programming Languages
  Duration     : 47h 58m
  Lectures     : 563
  Rating       : 4.7/5 (7,288 reviews)
  Students     : 40,594

  INSTRUCTOR(S)


  HEADLINE
    In-depth .NET programming course from basics to advanced with
    OOP & LINQ. Focus on clean code, performance and practice.


  WHAT YOU'LL LEARN
  * Gain an in-depth understanding of C#.
  * Write high-performance, efficient C# code.
  * Master object-oriented programming principles.
  * Learn essential design patterns.
  * Write clean, maintainable code of excellent quality.
  * Prepare for C# job interviews with confidence.
  * Practice with browser-based exercises and advanced projects.
  * Use Visual Studio like a pro.
  * Create unit tests with NUnit and Moq.
  * Master asynchrony and multithreading.


  REQUIREMENTS
  * No programming experience is needed. I'll teach you
    everything
    you need to know.
  * A computer (Windows/macOS) with an access to the Internet.
  * No paid software is needed; all tools used in this course
    are
    free.


  WHO IS THIS COURSE FOR
  * Complete Beginners ? We start from scratch, covering all
    fundamentals.
  * Intermediate Developers ? Take your skills further with
    advanced topics.
  * Self-Taught Programmers ? Connect the dots and solidify your
    knowledge.
  * Programmers switching languages to C#.


  DESCRIPTION
  Welcome to the "Ultimate C# Masterclass" course - the only
  course you need to master C#! With 47 hours of video, 67
    coding
  exercises, 86 quizzes, and 16 assignments, this course is
    packed
  with hands-on learning. As a .NET Technical Lead with over a
  decade of experience, I'll be guiding you every step of the
  way?whether you're a complete beginner or an experienced
  developer looking to level up. Why learn C#? C# is the
    backbone
  of modern software development, powering desktop applications,
  web services, cloud computing, and game development with
    Unity.
  Mastering C# isn?t just about learning syntax?it?s about
    writing
  efficient, maintainable, and professional-grade code. That?s
  exactly what this course will teach you. What makes this
    course
  different? We go beyond syntax. You'll learn why all the
    things
  we learn are needed and how to use them right. We emphasize
  clean code and good design principles from the start. Design
  patterns will be demonstrated in practice, not just as
    abstract
  concepts that seem impossible to apply in real-world
    challenges.
  Refactoring will be something we practice all the time. You'll
  gain hands-on experience through implementing various
    projects,
  from processing API data to analyzing PDF files. You'll learn
  how things work under the hood, and thanks to that, you will
  gain an in-depth understanding of C#. You'll master
    asynchrony,
  multithreading, and performance tuning. You'll practice unit
  testing with NUnit and Moq to build reliable software. No
    fluff.
  No endless theory. You?ll learn by doing. You will solve
    dozens
  of coding exercises right in the browser. Additional perks:
    Full
  Git repository with all code shown in the course. 30-day
    money-
  back guarantee?if you're not satisfied, get a full refund, no
  questions asked. C# is one of the most in-demand programming
  languages today. Learn it the right way and accelerate your
  career. Enroll now and start coding like a pro!


  COURSE CONTENT

  Chapter 1: Introduction
    1. Welcome! Basic information & how to get help
    2. 46 seconds about your instructor
    3. 72 seconds about what this course is
    4. 105 seconds about what this course isn?t
    5. 97 seconds about practicing what you learn
    6. 112 seconds about time optimization
    7. (Windows) Installing Visual Studio Community
    8. (MacOS) Installing Visual Studio Code
    9. (Windows) Accessing the code
    10. (MacOS) Accessing the code
    11. Resources you can download
    12. Coding exercises issues troubleshooting

  Chapter 2: C# Fundamentals
    13. Section introduction
    14. Our first C# program (using Visual Studio Community)
    15. Our first C# program (using Visual Studio Code)
    16. From a text file to an executable program
    17. Programmer's most important skill
    18. The goal for this section
    19. Variables
    20. Naming variables & introduction to clean code
    21. Operators
    22. Implicitly typed variables
    23. User input
    24. Debugging with breakpoints
    25. Coding exercises introduction
    26. Comments
    27. Boolean type. Logical negation, equality, comparison,
        and modulo operators
    28. AND and OR logical operators
    29. if/else conditional statement
    30. The scope of local variables
    31. Methods - part 1 - void methods
    32. Methods - part 2 - non-void methods
    33. Methods - part 3 - parameters types and the return type.
        Static typing in C#
    34. Parsing a string to an int (int.Parse method)
    35. The first exception
    36. Adding a new project to a solution
    37. Assignments - Introduction
    38. Assignment - Simple Calculator - Description and
        requirements
    39. Assignment - Simple Calculator -  It's time for you to
        implement it
    40. Assignment - Simple Calculator  - Solution
    41. String interpolation
    42. Switch statement
    43. Switch expressions
    44. Char
    45. A need for loops
    46. While loop - part 1
    47. += and ++ operators. Infinite loops
    48. While loop - part 2
    49. Do...while loop
    50. For loop
    51. Break
    52. Continue
    53. Nested loops
    54. Loops performance
    55. Arrays
    56. Multi-dimensional arrays
    57. Foreach loop
    58. Lists
    59. "out" keyword
    60. TryParse method
    61. Assignment - TODO List - Description and requirements
    62. Assignment - TODO List - It's time for you to try to
        solve it
    63. Assignment - TODO List - Implementation - User options &
        adding a TODO
    64. Assignment - TODO List - Implementation - Listing and
        Removing TODOs
    65. Assignment - TODO List - Refactoring

  Chapter 3: Basics of Object-Oriented Programming
    66. Section introduction
    67. The issues in our code. A need for Object-Oriented
        Programming
    68. Introduction to object-oriented programming
    69. Understanding OOP with the DateTime type
    70. Abstraction
    71. Our first class
    72. Data hiding
    73. Custom constructor
    74. C# restrictions on code outside classes. Top-level
        statements
    75. Adding methods to classes
    76. Encapsulation
    77. Methods overloading
    78. Constructors overloading. Calling one constructor from
        another
    79. Expression-bodied methods
    80. "this" keyword (current instance reference)
    81. Optional parameters
    82. Validation of constructor parameters
    83. Readonly and const
    84. Limitations of fields. A need for properties
    85. Properties
    86. Object initializers
    87. Computed properties
    88. Static methods and classes
    89. Static fields, properties and constructors
    90. Single Responsibility Principle - Introduction
    91. Single Responsibility Principle - Refactoring (part 1)
    92. Single Responsibility Principle - Refactoring (part 2)
    93. Single Responsibility Principle - Refactoring (part 3)
    94. Files, namespaces and the using directive
    95. Global using directives
    96. Assignment - Dice Roll Game - Description and
        requirements
    97. Assignment - Dice Roll Game - It's time for you to try
        to solve it
    98. Assignment - Dice Roll Game - Random
    99. Assignment - Dice Roll Game - Magic Number Antipattern
    100. Assignment - Dice Roll Game - Designing classes
    101. Assignment - Dice Roll Game - Enums
    102. Assignment - Dice Roll Game - Ternary conditional
         operator

  Chapter 4: Object-Oriented Programming: Polymorphism,
    Inheritance, Interfaces
    103. Section introduction
    104. A need for polymorphism
    105. Inheritance
    106. Inheriting members from the base class. Protected
         access modifier
    107. Overriding members from the base class. Virtual methods
         and properties
    108. Virtual methods - practice
    109. A deeper inheritance hierarchy
    110. Multiple inheritance
    111. System.Object and the ToString method
    112. Inheriting constructors and the "base" keyword
    113. Implicit conversion
    114. Explicit conversion
    115. Upcasting and downcasting
    116. "is" operator
    117. Null
    118. "as" operator
    119. Abstract classes
    120. Abstract methods
    121. A need for abstract methods
    122. Sealed classes and methods
    123. Static classes are always sealed
    124. Extension methods
    125. A need for interfaces
    126. Interfaces
    127. Interfaces vs abstract classes
    128. JSON
    129. Assignment - Cookies Cookbook - Description and
         requirements
    130. Assignment - Cookies Cookbook - It's time for you to
         try to solve it
    131. Assignment - Cookies Cookbook - High-level design
    132. Assignment - Cookies Cookbook - Dependency Inversion
         and Dependency Injection
    133. Assignment - Cookies Cookbook - Designing data types
    134. Assignment - Cookies Cookbook - Printing data object.
         LINQ.
    135. Assignment - Cookies Cookbook - Printing the
         ingredients
    136. Assignment - Cookies Cookbook - Composing the recipe by
         the user
    137. Assignment - Cookies Cookbook - Reading and writing
         from and to a *.txt file
    138. Assignment - Cookies Cookbook - Reading and writing
         from and to a *.json file
    139. Assignment - Cookies Cookbook - Template Method Design
         Pattern
    140. Assignment - Cookies Cookbook - Cleanup and project
         organizing

  Chapter 5: Exceptions and error handling
    141. Section introduction
    142. Exception object
    143. Stack trace
    144. Handling exceptions. Try-catch-finally
    145. Multiple catch blocks
    146. Throwing exceptions explicitly
    147. Built-in exception types
    148. StackOverflowException. Recursive methods
    149. Precise exceptions
    150. Rethrowing exceptions. "throw" vs "throw ex"
    151. Rethrowing a System.Exception object
    152. Global try-catch block
    153. Code inside the catch block
    154. Exception filters
    155. Custom exceptions
    156. When to define custom exceptions
    157. Exceptions as a hidden part of a method signature
    158. Two extreme schools of using exceptions
    159. Smart usage of exceptions - throw
    160. Smart usage of exceptions - catch
    161. Assignment - Game Data Parser - Description and
         requirements
    162. Assignment - Game Data Parser - It's time for you to
         try to solve it
    163. Assignment - Game Data Parser - Sunny day scenario
    164. Assignment - Game Data Parser - Flow controlled by
         exceptions
    165. Assignment - Game Data Parser - Adding details to
         JsonException
    166. Assignment - Game Data Parser - Custom logger
    167. Assignment - Game Data Parser - Reducing usage of
         exception
    168. Assignment - Game Data Parser - Refactoring -
         Extracting methods
    169. Assignment - Game Data Parser - Refactoring - SRP, DI
         and classes decoupling

  Chapter 6: Generic types & advanced use of methods
    170. Section introduction
    171. Introduction to generic types
    172. Understanding how List works under the hood
    173. Simplified List (adding a new item)
    174. Simplified List (deleting an item at given index)
    175. A need for generic types. Implementing a generic type
    176. A need for tuples
    177. Tuples
    178. C# without generics. ArrayList
    179. Generic methods
    180. Generic methods with multiple type parameters
    181. Convert.ChangeType method. "typeof" keyword and the
         Type object
    182. A need for type constraints
    183. Improving the performance of the List. Measuring the
         time of the code execution
    184. Type constraints - the constraint on the base type
    185. IComparable interface. Ordering objects
    186. Type constraints - the constraint on the implemented
         interface
    187. Type constraints - numeric types. Generic math
    188. Type constraints - summary. Multiple type constraints
    189. Advanced use of methods - introduction
    190. Funcs and Actions
    191. Lambda expressions
    192. Delegates
    193. Dictionary - introduction
    194. Dictionary - practice
    195. A need for the Strategy design pattern
    196. Refactoring the code using Funcs and lambda expressions
    197. Open-Closed Principle. Strategy design pattern
    198. Generic filtering of collections
    199. Caching
    200. Assignment - Custom Cache - Description and
         requirements
    201. Assignment - Custom Cache - It's time for you to try to
         solve it
    202. Assignment - Custom Cache - Implementation
    203. Assignment - Custom Cache - The Decorator design
         pattern
    204. Assignment - Custom Cache - Composing many Decorators
         together

  Chapter 7: LINQ
    205. Section introduction
    206. What is LINQ?
    207. LINQ and extension methods
    208. LINQ, IEnumerable<T> and method chaining
    209. Deferred execution
    210. Any
    211. All
    212. Count
    213. Contains
    214. OrderBy
    215. First and Last
    216. Where
    217. Distinct
    218. Select
    219. Average. Anonymous types
    220. Assignment - Refactoring to LINQ - Description and
         requirements
    221. Assignment - LINQ Refactoring - It's time for you to
         try to solve it
    222. Assignment - Refactoring to LINQ - Nested loop and code
         readability
    223. Assignment - Refactoring to LINQ - Find and Replace
         window
    224. Assignment - Refactoring to LINQ - Fewer loops &
         multiline strings formatting
    225. Assignment - Refactoring to LINQ - Checking if
         collection has duplicates
    226. LINQ Tutorial - Master the Key C# Library

  Chapter 8: .NET under the hood
    227. Section introduction
    228. .NET and C#
    229. Common Intermediate Language (CIL)
    230. Common Language Runtime (CLR)
    231. Memory of a program. The stack and the heap
    232. Value semantics vs reference semantics
    233. Value types vs reference types
    234. Value types vs reference types - practical tips
    235. "ref" keyword
    236. Using "ref" with reference types
    237. Unified type system. A need for boxing and unboxing
    238. Boxing and unboxing
    239. Boxing and unboxing - performance cost
    240. Garbage Collector - introduction
    241. Garbage Collector - memory fragmentation and
         defragmentation
    242. Garbage Collector - the Mark-and-Sweep algorithm
    243. Garbage Collector - generations of objects
    244. Memory leaks
    245. Finalizers
    246. Dispose method - introduction
    247. Dispose method - writing to a file using StreamWriter
    248. Dispose method - reading from a file using StreamReader
    249. Dispose method - implementation
    250. CSV files
    251. Reading CSV files
    252. Assignment - CSV Processing Improvements - Description
         and requirements
    253. Assignment - CSV Processing Improvements - It's time
         for you to try to solve it
    254. Assignment - CSV Processing Improvements - Code
         analysis & tips
    255. Assignment - CSV Processing Improvements - Reducing the
         size of Dictionaries
    256. Assignment - CSV Processing Improvements - Reducing the
         number of boxings
    257. Assignment - CSV Processing Improvements - Analysis

  Chapter 9: Advanced C# types
    258. Section introduction
    259. Reflection
    260. Attributes
    261. Limitations of attributes parameters types
    262. Structs
    263. Structs vs Classes - crucial differences
    264. Structs vs Classes - low-level differences
    265. Choosing between structs and classes
    266. Why should we make structs immutable?
    267. Non-destructive mutation
    268. "with" expression
    269. Readonly structs
    270. A close look at the System.Object type. The
         ReferenceEquals method
    271. Equals method
    272. Overriding the Equals method in classes
    273. Overriding the Equals method in structs
    274. IEquatable<T> interface
    275. == operator
    276. Operators overloading
    277. Overloading of implicit and explicit conversion
         operators
    278. Hash functions
    279. Default implementation of the GetHashCode method
    280. When to override the GetHashCode method
    281. Overriding the GetHashCode method
    282. ValueTuples
    283. Benefits of immutable types
    284. Records
    285. Record structs
    286. Nullable value types
    287. Nullable reference types
    288. Null-forgiving operator
    289. Using nullable reference types. Generic type
         constraints related to nullability
    290. APIs
    291. Querying an API using C#
    292. A class for querying APIs
    293. Assignment - Star Wars Planets Stats - Description and
         requirements
    294. Assignment - Star Wars Planets Stats - It's time for
         you to try to solve it
    295. Assignment - Star Wars Planets Stats -
         JsonPropertyNameAttribute and DTOs
    296. Assignment - Star Wars Planets Stats - Exceptions
         handling
    297. Assignment - Star Wars Planets Stats - Type design
    298. Assignment - Star Wars Planets Stats - Converting DTO
         to a custom type
    299. Assignment - Star Wars Planets Stats - Finishing the
         app and the MaxBy method
    300. Assignment - Star Wars Planets Stats - Refactoring
    301. Assignment - Star Wars Planets Stats - Splitting the
         class
    302. Assignment - Star Wars Planets Stats - Universal table
         printer

  Chapter 10: Collections
    303. Section introduction
    304. The role of the IEnumerable interface
    305. A close look at the IEnumerable interface
    306. Implementing IEnumerable
    307. Implicit and explicit interface implementation
    308. Implementing IEnumerable<T>
    309. Indexers
    310. Collection initializers
    311. ICollection and IList interfaces
    312. Breaking the Interface Segregation Principle
    313. Interface Segregation Principle
    314. The benefits of readonly collections
    315. Readonly collections. ReadOnlyCollection and
         ReadOnlyDictionary
    316. Big O Notation
    317. Binary search algorithm
    318. Binary search algorithm - implementation
    319. Binary search algorithm - complexity
    320. Improving performance when using Lists
    321. Linked list
    322. Linked list vs List
    323. Dictionaries under the hood
    324. Performance of Dictionaries
    325. HashSet
    326. Queue
    327. Stack
    328. "params" keyword
    329. A need for yield statement
    330. yield statement - behavior analysis
    331. yield statement and iterators
    332. yield statement - practice. yield break statement
    333. Implementing IEnumerable interface using iterators
    334. Assignment - Custom Linked List - Description and
         requirements
    335. Assignment - Custom Linked List - It's time for you to
         try to solve it
    336. Assignment - Custom Linked List - Data structures
    337. Assignment - Custom Linked List - The AddToFront method
    338. Assignment - Custom Linked List - Implementing
         IEnumerable
    339. Assignment - Custom Linked List - Adding new items at
         the end of the list
    340. Assignment - Custom Linked List - The Clear method
    341. Assignment - Custom Linked List - Removing items and
         the Contains method
    342. Assignment - Custom Linked List - The CopyTo method
    343. Assignment - Custom Linked List - Summary and
         performance. Private classes

  Chapter 11: Projects, assemblies, solutions
    344. Section introduction
    345. Projects and solutions
    346. Project properties
    347. Debug build vs Release build
    348. Assemblies
    349. Referencing types from another assembly
    350. Referencing types from another project
    351. Internal access modifier. Principles of using access
         modifiers
    352. Protected internal access modifier
    353. Private protected access modifier
    354. Access modifiers - summary
    355. How to structure the code in a solution
    356. NuGet
    357. *.csproj files
    358. *.sln files
    359. Updating the .NET version

  Chapter 12: Strings
    360. Section introduction
    361. Char
    362. Char representation in memory. Character encoding
    363. Managing various encodings
    364. Immutability of strings
    365. Strings - value or reference types?
    366. Strings as members in structs
    367. A need for StringBuilder
    368. StringBuilder
    369. String interning
    370. Flyweight design pattern
    371. Advanced string formatting
    372. Culture-specific string formatting
    373. Specific culture vs Invariant culture
    374. Assignment - Tickets Data Aggregator - Description and
         requirements
    375. Assignment - Tickets Data Aggregator - It's time for
         you to try to solve it
    376. Assignment - Tickets Data Aggregator - Reading text
         from PDF
    377. Assignment - Tickets Data Aggregator - List all PDFs
         from a folder
    378. Assignment - Tickets Data Aggregator - Splitting a
         string by multiple separators
    379. Assignment - Tickets Data Aggregator - Parsing culture-
         specific strings
    380. Assignment - Tickets Data Aggregator - Saving result in
         a text file
    381. Assignment - Tickets Data Aggregator - Refactoring
    382. Assignment - Tickets Data Aggregator - Compliance with
         the SRP

  Chapter 13: Numeric types
    383. Section introduction
    384. Decimal number system
    385. Binary number system
    386. Maximal numbers on a given number of digits
    387. Numbers in memory. Integer
    388. Adding binary numbers
    389. Numeric overflow & silent failures
    390. "checked" keyword
    391. Checked context - when to use it?
    392. Scope of the checked context. "unechecked" keyword
    393. Integral numeric types overview
    394. Floating-point numbers
    395. double and float
    396. Smart usage of binary floating point numbers
    397. Decimal

  Chapter 14: Events
    398. Section introduction
    399. A need for communication between objects
    400. A need for the Observer design pattern
    401. Observer design pattern
    402. Defining an event and subscribing to it
    403. Raising events
    404. EventHandler delegate & EventArgs type
    405. Event vs delegate members
    406. Memory leaks caused by events
    407. Windows Forms - introduction
    408. The first Windows Forms app
    409. Understanding Windows Forms files
    410. Events in Windows Forms
    411. Windows Forms - basic UI elements
    412. Assignment - Numeric Types Suggester - Description and
         requirements
    413. Assignment - Numeric Types Suggester - It's time for
         you to try to solve it
    414. Assignment - Numeric Types Suggester - User Interface &
         basic events
    415. Assignment - Numeric Types Suggester - Handling
         KeyPress event
    416. Assignment - Numeric Types Suggester - Numbers
         validation and BigInteger type
    417. Assignment - Numeric Types Suggester - Choosing numeric
         type

  Chapter 15: Unit Testing
    418. Section introduction
    419. Manual tests vs Automated tests
    420. Setting up the testing environment
    421. First unit tests
    422. Running the tests
    423. Naming unit tests
    424. Test messages
    425. AAA pattern
    426. TestCase
    427. Naming parameterized tests
    428. TestCaseSource
    429. Assertions on exceptions. Multiple assertions in single
         test
    430. Value of unit tests
    431. Basic assertions
    432. Testing private methods
    433. Testing internal methods
    434. Benefits of unit tests - no fear of refactoring
    435. Benefits of unit tests - better design
    436. Benefits of unit tests - early bug detection
    437. Downsides of unit tests
    438. Assignment - Fibonacci generator tests - Description
         and requirements
    439. Assignment - Fibonacci generator tests - solution
    440. Testing classes depending on other classes
    441. A need for mocks
    442. Mocks
    443. Controlling the mock behavior
    444. The benefits of using mocks
    445. Advanced mock setup
    446. Assertions checking if a method was called
    447. Advanced assertions on method calls
    448. Clean code in unit tests
    449. Common setup for tests
    450. Tests, Dependency Inversion and Dependency Injection
    451. Untestable code - no Dependency Inversion
    452. Untestable code - static methods
    453. Other kinds of software tests
    454. Assignment - Unit tests for GuessingGame - Description
         and requirements
    455. Assignment - Unit tests for GuessingGame - Basic
         scenarios
    456. Assignment - Unit tests for GuessingGame - Verifying
         messages
    457. Assignment - Unit tests for GuessingGame - Approaches
         for messages validation
    458. Assignment - Unit tests for GuessingGame - Resource
         files
    459. Breaking changes in NUnit 4

  Chapter 16: Clean code
    460. Section introduction
    461. The importance of clean code
    462. Bad decisions related to code quality
    463. Tech debt
    464. Being professional
    465. What is clean code?
    466. The importance of meaningful names
    467. Renaming. The Boy Scout Rule
    468. Dealing with problematic naming
    469. Expressive names
    470. Long and short names
    471. Clean Code - Coding Exercises introduction
    472. Principle of the least surprise
    473. Bad names - meaningless words
    474. Bad names - overspecific names
    475. Bad names - Hungarian notation
    476. Bad names - confusing names
    477. Bad names - abbreviations
    478. Reasonable abbreviations. Conventional names
    479. Context
    480. Refactoring case study - naming
    481. Good signatures of methods
    482. Number of parameters
    483. Fewer parameters - splitting the method
    484. Fewer parameters - bundling related parameters
    485. Fewer parameters - avoiding boolean parameters
    486. Small methods
    487. One method, one job
    488. One method, one job - refactoring
    489. Levels of abstraction
    490. Composing different levels of abstraction
    491. Levels of abstraction within methods
    492. Refactoring case study - methods - introduction
    493. Refactoring case study - methods - signature
    494. Refactoring case study - methods - body
    495. Comments
    496. The worst comments
    497. The reasonable comments
    498. When to make methods static? Private methods
    499. The risk of making public methods static
    500. When to make methods static? Public methods
    501. Composition over inheritance
    502. The issues of inheritance
    503. Replacing inheritance with composition
    504. The benefits of composition
    505. Next steps: continuing your clean code journey
    506. Assignment - Password Generator Refactoring -
         Description and requirements
    507. Assignment - Password Generator Refactoring -
         Explaining the existing code
    508. Assignment - Password Generator Refactoring - Fixing
         naming
    509. Assignment - Password Generator Refactoring - Improving
         design

  Chapter 17: Multithreading & asynchrony
    510. Section introduction
    511. The computer's processor
    512. Threads and processes
    513. Concurrency vs parallelism
    514. Asynchrony
    515. A single-threaded program
    516. Starting a new thread. The Thread class
    517. Multithreaded app?s code flow
    518. The benefits of multithreading and asynchronous
         programming
    519. The cost of threads. ThreadPool
    520. Task Parallel Library (TPL)
    521. Task class
    522. Returning a value from a Task
    523. Waiting for the Task result
    524. Wait and WaitAll methods
    525. Continuations. The ContinueWith method
    526. Chaining continuations. Continuations of multiple tasks
    527. Canceling a Task
    528. Task lifecycle
    529. OperationCanceledException
    530. Exceptions thrown by other threads
    531. Exceptions in tasks
    532. Asynchronous exception handling
    533. Handling AggregateException
    534. Multiple continuations for one task
    535. Handling task cancellation
    536. The need for synchronization
    537. Atomic operations
    538. Race condition
    539. Locks
    540. The need for async/await
    541. "await" keyword
    542. Async methods
    543. Asynchrony vs multithreading
    544. The flow of an asynchronous program
    545. Async/await and threads
    546. Async/await summary
    547. Async/await practice
    548. Exceptions in async methods
    549. Downsides of multithreading & asynchrony
    550. Using async methods in practice. HttpClient
    551. Assignment - Quote Finder - Description and
         requirements
    552. Assignment - Quote Finder - Fetching data
    553. Assignment - Quote Finder - Smart asynchrony
    554. Assignment - Quote Finder - Single-threaded processing
    555. Assignment - Quote Finder - Multi-threaded processing
    556. Assignment - Quote Finder - Refactoring

  Chapter 18: C# evolution
    557. Section introduction
    558. C# 11 - Raw string literals
    559. C# 11 - Required members
    560. C# 11 - Required members - using them with a
         constructor
    561. C# 12 - Primary constructors for classes and structs
    562. C# 12 - Collection expressions

  Chapter 19: Bonus section
    563. Bonus lecture


  DATES
  Published    : 2023-04-01
  Last Updated : 2026-01-23

If you fear the truth, don?t come to my well.

Files