Home Search Profile

Master C# Concurrent Collections: Pro Multithreading 2024

Focused View

2:42:23

  • 1. Course Overview.mp4
    01:58
  • 01. Version Check.mp4
    00:15
  • 02. Overview.mp4
    01:52
  • 03. Introducing the Code.mp4
    03:14
  • 04. Adding Concurrency.mp4
    03:53
  • 05. Fixing the Code with ConcurrentQueueT.mp4
    02:02
  • 06. Inconsistent Results.mp4
    01:46
  • 07. Explaining the Thread Timing Inconsistency.mp4
    03:07
  • 08. Why Did QueueT.Enqueue() Fail.mp4
    03:57
  • 09. Atomic Operations.mp4
    01:55
  • 10. Summary.mp4
    00:59
  • 01. Overview.mp4
    01:11
  • 02. Introducing the SellShirts Demo.mp4
    01:26
  • 03. Storing Shirts in an ImmutableArray.mp4
    02:31
  • 04. The Stock Controller and the Dictionary.mp4
    02:42
  • 05. Generating Random Numbers.mp4
    02:01
  • 06. The Main() Method.mp4
    01:17
  • 07. Simulating Serving Customers.mp4
    03:56
  • 08. Adding Concurrency and ConcurrentDictionary.mp4
    03:01
  • 09. The Indexer vs. TryGetValue().mp4
    03:02
  • 10. Fixing the Code to Allow for Failure.mp4
    02:55
  • 11. Remove() vs. TryRemove().mp4
    02:51
  • 12. Concurrent Collection State Can Be Uncertain.mp4
    02:41
  • 13. Summary.mp4
    00:59
  • 01. Overview.mp4
    00:48
  • 02. Introducing the BuyAndSell Demo.mp4
    02:03
  • 03. Storing the Stock in a Dictionary.mp4
    01:45
  • 04. Updating a Standard Dictionary.mp4
    01:49
  • 05. Summing Values with LINQ and Checking for Errors.mp4
    01:46
  • 06. Modelling Serving a Customer.mp4
    02:02
  • 07. Adding Concurrency.mp4
    01:51
  • 08. Race Conditions and Data Corruption.mp4
    03:59
  • 09. Updating Atomically with TryUpdate().mp4
    03:12
  • 10. Introducing AddOrUpdate().mp4
    01:38
  • 11. Interlocked.Add().mp4
    01:08
  • 12. Protecting against Race Conditions.mp4
    02:05
  • 13. Lambdas to Conditionally Update the Dictionary.mp4
    02:44
  • 14. Solving the Update Problem with a Closure.mp4
    02:55
  • 15. GetOrAdd() to Read the Dictionary.mp4
    02:10
  • 16. Summary.mp4
    00:47
  • 1. Overview.mp4
    02:11
  • 2. Adding the Logging Tasks.mp4
    02:56
  • 3. Calculating Commissions.mp4
    03:00
  • 4. Enqueueing to the Concurrent Queue.mp4
    01:38
  • 5. Consuming the Queue - The Problem of Polling.mp4
    04:12
  • 6. ConcurrentStackT.mp4
    01:58
  • 7. ConcurrentBagT.mp4
    02:33
  • 8. The IProducerConsumerCollectionT Interface.mp4
    03:41
  • 9. Summary.mp4
    01:04
  • 1. Overview.mp4
    01:50
  • 2. Understanding BlockingCollectionT.mp4
    01:52
  • 3. How BlockingCollectionT Avoids Polling.mp4
    02:40
  • 4. The Consuming Enumerable.mp4
    02:29
  • 5. Enumerating Directly Wont Work.mp4
    01:05
  • 6. Summary.mp4
    00:56
  • 01. Overview.mp4
    00:46
  • 02. Concurrent Collections and Performance.mp4
    01:05
  • 03. The Dictionary Benchmark Demo.mp4
    04:16
  • 04. Benchmarking with Multiple Threads.mp4
    01:47
  • 05. Running the Benchmark.mp4
    02:36
  • 06. Use Shared State Sparingly.mp4
    01:49
  • 07. Using ConcurrentDictionary Correctly.mp4
    02:28
  • 08. The Problem with Count.mp4
    02:35
  • 09. Aggregate State.mp4
    01:48
  • 10. Good Practices for State.mp4
    02:14
  • 11. Summary.mp4
    01:06
  • 1. Overview.mp4
    00:43
  • 2. Enumerating a Standard Dictionary.mp4
    02:59
  • 3. Enumerating a Concurrent Dictionary.mp4
    03:43
  • 4. Forcing a Snapshot Enumeration.mp4
    02:22
  • 5. Snapshot Pros and Cons.mp4
    01:46
  • 6. Module Summary.mp4
    00:51
  • 7. Course Summary.mp4
    01:24
  • 8. T-shirt Models - Thank You!.mp4
    02:22
  • 9. Your Challenge!.mp4
    01:25
  • More details


    Course Overview

    Learn to use concurrent collections effectively in C# to build high-performance multithreaded applications while avoiding race conditions and data corruption. This course teaches thread-safe data manipulation techniques for modern software development.

    What You'll Learn

    • Implement thread-safe operations with ConcurrentDictionary and producer-consumer collections
    • Solve race conditions using atomic operations and lambda expressions
    • Optimize performance while enumerating concurrent collections

    Who This Is For

    • C# developers building multithreaded applications
    • Software engineers optimizing concurrent systems
    • .NET programmers needing thread-safe collection skills

    Key Benefits

    • Avoid common threading bugs that crash applications
    • Write efficient code that scales across CPU cores
    • Master industry-standard concurrent programming patterns

    Curriculum Highlights

    1. Collections and Atomic Operations
    2. ConcurrentDictionary Techniques
    3. Producer-Consumer Collections
    Focused display
    Category

    C#

    • language english
    • Training sessions 75
    • duration 2:42:23
    • level advanced
    • English subtitles has
    • Release Date 2025/06/07

    Courses related to C#