Fashionable programming languages equivalent to C# facilitate the environment friendly use of assets by permitting a number of operations to be executed concurrently. Right here concurrently typically means asynchronously, when a number of processes should share the identical CPU core. Nonetheless, managing concurrent execution paths (utilizing threads or duties) can shortly turn into difficult as a result of overhead of juggling asynchronous duties.

“Structured concurrency” is a programming paradigm that was launched to deal with this. Structured concurrency promotes a extra disciplined and arranged solution to handle concurrency. On this article, we’ll delve into structured concurrency and see how it may be carried out in C#. 

Create a console utility venture in Visible Studio

First off, let’s create a .NET Core console utility venture in Visible Studio. Assuming Visible Studio 2022 is put in in your system, observe the steps outlined under to create a brand new .NET Core console utility venture.

1. Launch the Visible Studio IDE.
2. Click on on “Create new venture.”
3. Within the “Create new venture” window, choose “Console App (.NET Core)” from the record of templates displayed.
4. Click on Subsequent.
5. Within the “Configure your new venture” window proven subsequent, specify the title and placement for the brand new venture.
6. Click on Subsequent.
7. Within the “Extra data” window, select “.NET 7.0 (Customary Time period Help)” because the Framework model you want to use.
8. Click on Create.

We’ll use this .NET 7 console utility venture to work with structured concurrency within the subsequent sections of this text.

What’s asynchronous programming?

Asynchronous programming permits purposes to carry out resource-intensive operations concurrently, with out having to dam on the primary or the executing thread of the appliance. Conventional approachеs to async programming, likе utilizing callback capabilities or thе Activity Parallеl Library (TPL), oftеn fall quick whеn it comеs to managing concurrеncy and controlling thе lifеtimе of asynchronous opеrations. Structurеd concurrеncy offеrs a morе structurеd and intuitive means of managing asynchronous programming.

What’s structured concurrency?

Structured concurrency is a technique for dealing with concurrent operations in asynchronous programming. It depends on activity scopes and correct useful resource cleanup to offer a number of advantages together with cleaner code, less complicated error dealing with, and prevention of useful resource leaks. Structured concurrency emphasizes the concept all asynchronous duties needs to be structured inside a particular context, permitting builders to successfully compose and management the circulate of those duties.

To higher handle the execution of async operations, structured concurrency introduces the idea of activity scopes. Activity scopes present a logical unit that units boundaries for concurrent duties. All duties executed inside a activity scope are carefully monitored and their lifecycle is fastidiously managed. If any activity throughout the scope encounters failure or cancellation, all different duties inside that scope are robotically canceled as nicely. This ensures correct cleanup and prevents re­supply leaks.

Advantages of structured concurrency

Listed below are among the key advantages of structured concurrency:

• Cleaner code: Structured concurrency helps you write clear and maintainable code by preserving asynchronous operations logically organized inside outlined scopes. With structured concurrency, duties have a transparent scope. When the scope exits, we will ensure that all duties inside that scope have been accomplished.
• Environment friendly useful resource cleanup: Structured concurrency offers an automated useful resource cleanup mechanism. It ensures that every one duties inside a scope are canceled if any activity encounters an error or is canceled, successfully managing the cleanup of assets.
• Higher error dealing with: With structured concurrency, dealing with errors and stopping error propagation are made simpler by canceling all duties inside a scope. This promotes higher management circulate and reduces complexity.
• Eliminates useful resource leaks: In conventional approaches to asynchronous programming, there’s a threat of useful resource leaks when an operation fails or will get canceled. Structured concurrency helps deal with this drawback by guaranteeing that appropriate cleanup is enforced.

Structured concurrency instance in C#

In C#, we will implement structured concurrency by utilizing the options accessible within the System.Threading.Duties.Channels namespace. This namespace presents useful constructs like Channel and ChannelReader that make implementing structured concurrency simpler.

Check out the next instance code, which I’ll clarify under.

utilizing System;
utilizing System.Threading.Channels;
utilizing System.Threading.Duties;
async Activity MyAsyncOperation (ChannelWriter channelWrite­r)
{
    await channelWriter.WriteAsync(100);
}
async Activity Most important()
{
    var channel = Channel.CreateUnbounde­d();
    var channelWriter = channel.Author;
    await utilizing (channel.Reader.EnterAsync())
    {
        var taskA = MyAsyncOperation (channelWriter);
        var taskB = MyAsyncOperation (channelWriter);
        await Activity.WhenAll(taskA, taskB);
    }
    channelWriter.Full();
    await channel.Reader.Completion;
}

Within the instance code above, we set up a channel to allow communication between the primary thread and concurrent duties. The MyAsyncOperation technique represents the asynchronous operation that might be executed concurrently. Through the use of the EnterAsync technique of the ChannelReader object, we enter a activity scope. Right here a number of duties are scheduled and waited utilizing a name to the the Activity.WhenAll technique. If any activity fails or is canceled, then all different duties inside that scope additionally might be canceled. Lastly, the Author occasion is closed and we await the completion of the Reader.

Set up the Nito.StructuredConcurrency NuGet bundle

You may implement structured concurrency utilizing the Nito.StructuredConcurrency NuGet bundle. Earlier than we dive into utilizing this bundle, let’s set up it into the console utility venture we created earlier. To do that, choose the venture within the Answer Explorer window and right-click and choose “Handle NuGet Packages.” Within the NuGet Bundle Supervisor window, seek for the Nito.StructuredConcurrency bundle and set up it.

Alternatively, you may set up the Nito.StructuredConcurrency bundle through the NuGet Bundle Supervisor console by coming into the road of code under.

PM> Set up-Bundle Nito.StructuredConcurrency

Use the TaskGroup class to create activity scopes

You may create a activity scope in which you’ll outline the work to be completed by your asynchronous duties. To do that, you should use the RunGroupAsync technique of the TaskGroup class as proven within the code snippet given under.

var group = TaskGroup.RunGroupAsync(default, group =>
{
    group.Run(async token => await Activity.Delay(TimeSpan.FromSeconds(1), token));
    group.Run(async token => await Activity.Delay(TimeSpan.FromSeconds(2), token));
    group.Run(async token => await Activity.Delay(TimeSpan.FromSeconds(3), token));
});
await group;

Within the preceeding code snippet, notice how the delegate is handed to the RunGroupAsync technique. This delegate represents the primary work merchandise. The following work gadgets are added to the identical activity group. When all of the work gadgets have accomplished their execution, the management exits the duty group and the group is closed.

Within the occasion of an exception, the duty group enters a faulted state.

var group = TaskGroup.RunGroupAsync(default, group =>
{
    group.Run(async token =>
    {
        await Activity.Delay(TimeSpan.FromSeconds(1), token);
        throw new Exception("It is a take a look at exception.");
    });
});
await group;

Activity teams ignore duties which have been cancelled, i.e., they catch and ignore any occurrences of OperationCanceledException. Moreover, activity teams can personal assets, that are disposed when the execution of the duty group is full.

var groupTask = TaskGroup.RunGroupAsync(default, async group =>
{
    await group.AddResourceAsync(myResource);
    group.Run(async token => await myResource.PerformWork(token));
});
await groupTask;

Structurеd concurrеncy offеrs a disciplinеd method to dealing with concurrеnt duties by еnsuring that duties havе a clеar scopе and lifеtimе. It presents vital advantages when it comes to code maintainability, error dealing with, and useful resource administration in asynchronous programming situations. By following this method, dеvеlopеrs can rеducе thе threat of widespread pitfalls associatеd with concurrеncy, equivalent to dangling duties or unhandlеd еxcеptions, lеading to morе maintainablе and rеliablе codе.