add more extensions for the disposables and add base implementations of a disposable-scope

Author: fembina

Sources/Falko.Common.Disposables/Disposables/ElementaryDisposableScope.cs

@@ -0,0 +1,62 @@
+using Falko.Common.Sequences;
+
+namespace Falko.Common.Disposables;
+
+public abstract class ElementaryDisposableScope : IDisposableScope
+{
+    private const int IsAlreadyDisposed = 1;
+
+    private const int IsNotDisposed = 0;
+
+    private Lock _locker = new();
+
+    // ReSharper disable InconsistentlySynchronizedField
+    private Sequence<IAsyncDisposable> _asyncDisposables = new();
+
+    private volatile int _disposed = IsNotDisposed;
+
+    public void Register(IAsyncDisposable asyncDisposable)
+    {
+        if (_disposed == IsAlreadyDisposed)
+        {
+            asyncDisposable
+                .DisposeAsync()
+                .AsTask()
+                .Wait();
+
+            return;
+        }
+
+        lock (_locker)
+        {
+            _asyncDisposables.Add(asyncDisposable);
+        }
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        var disposed = _disposed;
+
+        if (disposed == IsAlreadyDisposed)
+        {
+            return;
+        }
+
+        if (Interlocked.CompareExchange(ref _disposed, IsAlreadyDisposed, disposed) == IsAlreadyDisposed)
+        {
+            return;
+        }
+
+        try
+        {
+            await DisposeAsync(_asyncDisposables);
+        }
+        finally
+        {
+            _locker = null!;
+            _asyncDisposables = null!;
+        }
+    }
+
+    protected abstract ValueTask DisposeAsync(Sequence<IAsyncDisposable> asyncDisposables);
+}

Sources/Falko.Common.Disposables/Disposables/ForwardDisposableScope.cs

@@ -0,0 +1,28 @@
+using Falko.Common.Sequences;
+
+namespace Falko.Common.Disposables;
+
+public sealed class ForwardDisposableScope : ElementaryDisposableScope
+{
+    protected override async ValueTask DisposeAsync(Sequence<IAsyncDisposable> asyncDisposables)
+    {
+        var exceptions = new Sequence<Exception>();
+
+        foreach (var asyncDisposable in asyncDisposables)
+        {
+            try
+            {
+                await asyncDisposable.DisposeAsync();
+            }
+            catch (Exception exception)
+            {
+                exceptions.Add(exception);
+            }
+        }
+
+        if (exceptions.Count > 0)
+        {
+            throw new AggregateException(exceptions);
+        }
+    }
+}

Sources/Falko.Common.Disposables/Disposables/ParallelDisposableScope.cs

@@ -0,0 +1,18 @@
+using Falko.Common.Extensions;
+using Falko.Common.Sequences;
+
+namespace Falko.Common.Disposables;
+
+public sealed class ParallelDisposableScope : ElementaryDisposableScope
+{
+    protected override ValueTask DisposeAsync(Sequence<IAsyncDisposable> asyncDisposables)
+    {
+        return Parallel
+            .ForEachAsync
+            (
+                source: asyncDisposables,
+                body: static (asyncDisposable, _) => asyncDisposable.DisposeAsync()
+            )
+            .AsValueTask();
+    }
+}

Sources/Falko.Common.Disposables/Disposables/ReverseDisposableScope.cs

@@ -0,0 +1,28 @@
+using Falko.Common.Sequences;
+
+namespace Falko.Common.Disposables;
+
+public sealed class ReverseDisposableScope : ElementaryDisposableScope
+{
+    protected override async ValueTask DisposeAsync(Sequence<IAsyncDisposable> asyncDisposables)
+    {
+        var exceptions = new Sequence<Exception>();
+
+        foreach (var asyncDisposable in asyncDisposables.Reverse())
+        {
+            try
+            {
+                await asyncDisposable.DisposeAsync();
+            }
+            catch (Exception exception)
+            {
+                exceptions.Add(exception);
+            }
+        }
+
+        if (exceptions.Count > 0)
+        {
+            throw new AggregateException(exceptions);
+        }
+    }
+}

Sources/Falko.Common.Disposables/Extensions/DisposableScopeExtensions.cs

@@ -0,0 +1,21 @@
+using Falko.Common.Disposables;
+
+namespace Falko.Common.Extensions;
+
+public static partial class DisposableScopeExtensions
+{
+    public static void Register(this IRegisterOnlyDisposableScope scope, IDisposable disposable)
+    {
+        scope.Register(new AsyncDisposableWrapper(disposable));
+    }
+}
+
+file sealed class AsyncDisposableWrapper(IDisposable disposable) : IAsyncDisposable
+{
+    public ValueTask DisposeAsync()
+    {
+        disposable.Dispose();
+
+        return ValueTask.CompletedTask;
+    }
+}