Added structured concurrency

Author: linkdotnet

README.md

@@ -4,6 +4,7 @@ Contains all of my examples from various blog posts. You can find a comprehensiv
 
 | BlogPost                                                                                                       | Publish Date |
 | -------------------------------------------------------------------------------------------------------------- | ------------ |
+| [Structured Concurrency in C#](StructuredConcurrency/)                                                         | 11.10.2023   |
 | [Building a Minimal ASP.NET Core clone](AspNetCoreFromScratch/)                                                | 14.09.2023   |
 | [Enabling List<T> to store large amounts of elements](ChunkedList/)                                            | 07.09.2023   |
 | [The combined power of F# and C#](FSharpCombined/)                                                             | 30.07.2023   |

StructuredConcurrency/README.md

@@ -0,0 +1,5 @@
+# Structured Concurrency in C#
+
+Did you ever hear about *"Structured Concurrency"*? If not, this article is for you. We will discover what it is, why it is useful, and what it could look like in C#.
+
+Found [here](https://steven-giesel.com/blogPost/59e57336-7c73-472f-a781-b0b79f0d47ad)

StructuredConcurrency/StructuredConcurrency.sln

@@ -0,0 +1,16 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StructuredConcurrency", "StructuredConcurrency\StructuredConcurrency.csproj", "{DEC85AAC-D35C-4078-A565-5794DAD5A561}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{DEC85AAC-D35C-4078-A565-5794DAD5A561}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DEC85AAC-D35C-4078-A565-5794DAD5A561}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DEC85AAC-D35C-4078-A565-5794DAD5A561}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DEC85AAC-D35C-4078-A565-5794DAD5A561}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

StructuredConcurrency/StructuredConcurrency/Program.cs

@@ -0,0 +1,40 @@
+using System.Diagnostics;
+
+var sw = Stopwatch.StartNew();
+var tasks = TaskScope.Create(group => 
+{
+    group.Run(async token => await Task.Delay(100, token));
+    group.Run(async token => await Task.Delay(200, token));
+});     
+
+// This runs 200 ms
+await tasks;
+Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds} ms");
+
+sw.Restart();
+var failedTasks = TaskScope.Create(group =>
+{
+    group.Run(async token =>
+    {
+        await Task.Delay(100, token);
+        throw new Exception("Boooommm!!!");
+    });
+    group.Run(async token => await Task.Delay(1000, token));
+});
+
+// Runs 100 ms as the first task fails and cancels the rest.
+// Also bubbles up the exception.
+try
+{
+    await failedTasks;
+}
+catch (Exception ex)
+{
+    Console.WriteLine(ex.Message);
+}
+
+// This runs 100 ms
+Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds} ms");
+
+// Prints True
+Console.WriteLine(failedTasks.IsFaulted);

StructuredConcurrency/StructuredConcurrency/StructuredConcurrency.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+</Project>

StructuredConcurrency/StructuredConcurrency/TaskScope.cs

@@ -0,0 +1,60 @@
+using System.Collections.Concurrent;
+
+public class TaskScope
+{
+    private readonly CancellationTokenSource _cts = new();
+    private readonly ConcurrentBag<Task> _tasks = new();
+
+    private TaskScope() { }
+
+    public static async Task Create(Func<TaskScope, Task> action)
+    {
+        await using var scope = new TaskScope();
+        await action(scope);
+        await scope.WaitForAll();
+    }
+    
+    public static async Task Create(Action<TaskScope> action)
+    {
+        await using var scope = new TaskScope();
+        action(scope);
+        await scope.WaitForAll();
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        _cts.Cancel();
+        await WaitForAll();
+    }
+
+    public Task Run(Func<CancellationToken, Task> action)
+    {
+        var task = Task.Run(async () =>
+        {
+            try
+            {
+                await action(_cts.Token);
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                _cts.Cancel();
+                throw;
+            }
+        });
+
+        _tasks.Add(task);
+        return task;
+    }
+
+    private async Task WaitForAll()
+    {
+        try
+        {
+            await Task.WhenAll(_tasks.ToArray());
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            throw;
+        }
+    }
+}