Introduction to Concurrency in C# Async and Paralellism

Introduction to Concurrency in C# – Async and Paralellism, available at $64.99, has an average rating of 4.1, with 77 lectures, based on 276 reviews, and has 1689 subscribers.

You will learn about Use asynchronous programming in C# Improve the speed of your programs with parallelism Patterns and antipatterns of asynchronous programming and parallelism This course is ideal for individuals who are C# developers who want to use asynchronous programming and parallelism in an effective way It is particularly useful for C# developers who want to use asynchronous programming and parallelism in an effective way.

Enroll now: Introduction to Concurrency in C# – Async and Paralellism

Summary

Title: Introduction to Concurrency in C# – Async and Paralellism

Price: $64.99

Average Rating: 4.1

Number of Lectures: 77

Number of Published Lectures: 77

Number of Curriculum Items: 77

Number of Published Curriculum Objects: 77

Original Price: $27.99

Quality Status: approved

Status: Live

What You Will Learn

Use asynchronous programming in C#

Improve the speed of your programs with parallelism

Patterns and antipatterns of asynchronous programming and parallelism

Who Should Attend

C# developers who want to use asynchronous programming and parallelism in an effective way

Target Audiences

C# developers who want to use asynchronous programming and parallelism in an effective way

In this course you will learn how to use asynchronous programming and parallelism in C #.

We will look at both patterns and antipatterns of concurrency. That is, we will see what things we should do, but we will also see what things we should not do.

With asynchronous programming we can:

Run a set of I / O tasks at the same time

Prevent the UI of our applications from freezing

Scale up our ASP.NET and ASP.NET Core applications

Cancel tasks so that the user does not have to wait for their completion

Implement generic retry logic

Create asynchronous streams

With parallel programming we can:

Accelerate the execution of certain algorithms

Apply transformations to a set of images in parallel

Use synchronization mechanisms to avoid race conditions

Define the maximum degree of parallelism

Configure instances of a class by threads

Use LINQ in parallel

We’ll also see:

Determinism vs Non-Determinism

Handling errors in asynchronous programming

Using Task.WhenAll to wait for the execution of multiple tasks

Reporting progress of multiples tasks

Retry pattern for handling momentaneous errors

Understanding and consuming ValueTask

Using Asynchronous streams

What does it mean for an app to be deadlocked

We will learn all of this in this course!

Course Curriculum

Chapter 1: Introduction – Basic Concepts

Lecture 1: Introduction

Lecture 2: What is Concurrency?

Lecture 3: Introduction to Parallel Programming

Lecture 4: Introduction to Asynchronous Programming

Lecture 5: CPU vs I/O Bound Operations

Lecture 6: Sequential Programming, Concurrency, Multi-threading, Parallelism, Multi-tasking

Lecture 7: Determinism vs Non-Determinism

Lecture 8: Preparing the Development Environment

Lecture 9: Source Code of the Course

Lecture 10: Conclusion

Chapter 2: Asynchronous Programming

Lecture 1: Introduction

Lecture 2: async-await

Lecture 3: Creating the Project

Lecture 4: Non-Freezing UI

Lecture 5: Task

Lecture 6: Task That Returns a Value

Lecture 7: Tasks with Errors

Lecture 8: Executing Multiple Tasks – Task.WhenAll

Lecture 9: Offloading the Current Thread – Task.Run

Lecture 10: Limiting the Amount of Concurrent Tasks – SemaphoreSlim

Lecture 11: Using the Response Task.WhenAll

Lecture 12: Reporting Progress with IProgress

Lecture 13: Reporting Progress in Intervals – Task.WhenAny

Lecture 14: Cancelling Tasks

Lecture 15: Cancelling Loops

Lecture 16: Cancelling with a Timeout

Lecture 17: Creating Finished Tasks – Task.FromResult and Friends

Lecture 18: Using the Same Thread – SynchronizationContext

Lecture 19: Ignoring the SynchronizationContext – ConfigureAwait

Lecture 20: Retry Pattern

Lecture 21: Only-One Pattern

Lecture 22: Controlling the Result of a Task – TaskCompletionSource

Lecture 23: Cancelling Non-Cancellable Tasks with TaskCompletionSource

Lecture 24: Understanding and Consuming ValueTask

Lecture 25: Conclusion

Chapter 3: Asynchronous Streams

Lecture 1: Introduction

Lecture 2: Reviewing IEnumerable and yield

Lecture 3: Asynchronous Streams

Lecture 4: Cancelling Asynchronous Streams

Lecture 5: Cancelling Through IAsyncEnumerable – EnumeratorCancellation

Lecture 6: Conclusion

Chapter 4: Antipatterns in Asynchronous Programming

Lecture 1: Introduction

Lecture 2: Deadlocking the App – sync-over-async

Lecture 3: async-over-sync

Lecture 4: Highly Dangerous – async void

Lecture 5: Avoid Task.Factory.StartNew

Lecture 6: Dispose CancellationTokenSource

Lecture 7: Correctly Dispose Streams

Lecture 8: Conclusion

Chapter 5: Parallelism

Lecture 1: Introduction

Lecture 2: Parallelism Review

Lecture 3: Simultaneous Tasks – Task.WhenAll

Lecture 4: Understanding Parallel.For

Lecture 5: Parallel.For – Speed Improvement

Lecture 6: Task.WhenAll vs Parallel.For

Lecture 7: Iterating Collections – Parallel.ForEach

Lecture 8: Speed Benefits

Lecture 9: Parallelizing Different Methods – Parallel.Invoke

Lecture 10: Cancelling Parallel Operations

Lecture 11: Maximum Degree of Parallelism

Lecture 12: Atomic Methods

Lecture 13: Thread-Safe

Lecture 14: Race Conditions

Lecture 15: Updating a Variable Atomically – Interlocked

Lecture 16: One Thread at a Time – Locks

Lecture 17: Each Thread Gets One – ThreadStatic

Lecture 18: Introduction to PLINQ

Lecture 19: Doing Aggregates in PLINQ

Lecture 20: Processing as Soon as it is Ready – ForAll

Lecture 21: Conclusion

Chapter 6: Parallelism Antipatterns

Lecture 1: Introduction

Lecture 2: Unnecessary Parallelism

Lecture 3: Race Conditions

Lecture 4: Too Much Can Be Bad – Oversaturation

Lecture 5: Using a Non-Thread-Safe Class

Lecture 6: Misuse of Locks

Lecture 7: Conclusion

Instructors

Felipe Gavilán
Software Engineer

Rating Distribution

1 stars: 2 votes

2 stars: 1 votes

3 stars: 24 votes

4 stars: 83 votes

5 stars: 166 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!