Merge pull request #1 from malforge/container-disposal

Dispose container-owned singletons

Author: malware-dev

README.md

@@ -158,6 +158,29 @@ var container = new DependencyContainerBuilder()
 var userRepo = container.Resolve<UserRepository>();
 ```
 
+### Disposal
+
+The container owns the lifetime of every singleton it **constructs**. Disposing the container disposes those singletons in **reverse construction order**, so a dependent is always disposed before the dependency it was handed:
+
+```csharp
+using var container = new DependencyContainerBuilder()
+    .AddRegistry<GeneratedRegistry>()
+    .Build();
+
+// ... resolve and use services ...
+// leaving the scope disposes every singleton the container constructed
+```
+
+Instances you supply yourself — through `RegisterInstance` or `AddInstance` — are **not** the container's to dispose, and are left alone. Resolving from a disposed container throws `ObjectDisposedException`.
+
+A singleton that implements `IAsyncDisposable` is disposed with `DisposeAsync`:
+
+```csharp
+await container.DisposeAsync();
+```
+
+Calling the synchronous `Dispose()` throws if a singleton disposes *only* asynchronously; one that implements both interfaces is disposed synchronously. If a singleton throws while disposing, the rest are still disposed and the failures are reported together as an `AggregateException`.
+
 ## Advanced Usage
 
 ### Assembly-Level Registrations

Source/Mal.SourceGeneratedDI.Abstractions/DependencyInjectionAbstractions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Mal.SourceGeneratedDI;
 
@@ -152,6 +153,14 @@ public interface IDependencyContainer : IServiceProvider
 public interface IServiceRegistry
 {
     void AddSingleton(Type serviceType, Func<IDependencyContainer, object> factory);
+
+    /// <summary>
+    /// Registers a container-owned singleton that disposes asynchronously. <paramref name="asyncDisposer"/>
+    /// disposes an instance of the service; it is supplied by the caller because this assembly targets
+    /// netstandard2.0 and cannot name <c>IAsyncDisposable</c> itself.
+    /// </summary>
+    void AddSingleton(Type serviceType, Func<IDependencyContainer, object> factory, Func<object, Task> asyncDisposer);
+
     void AddInstance(Type serviceType, Func<IDependencyContainer, object> factory);
 }
 
@@ -165,14 +174,22 @@ public interface IRegistrationSource
 
 internal sealed class Registration
 {
-    public Registration(Func<IDependencyContainer, object> factory, bool isInstance)
+    public Registration(Func<IDependencyContainer, object> factory, bool isInstance,
+        Func<object, Task>? asyncDisposer = null)
     {
         Factory = factory ?? throw new ArgumentNullException(nameof(factory));
         IsInstance = isInstance;
+        AsyncDisposer = asyncDisposer;
     }
 
     public Func<IDependencyContainer, object> Factory { get; }
     public bool IsInstance { get; }
+
+    /// <summary>
+    /// Disposes an instance of this service asynchronously, or <c>null</c> if it disposes synchronously
+    /// (or not at all). Supplied by the caller because this assembly cannot name <c>IAsyncDisposable</c>.
+    /// </summary>
+    public Func<object, Task>? AsyncDisposer { get; }
 }
 
 /// <summary>
@@ -294,6 +311,11 @@ public DependencyContainerBuilder RegisterInstance<TService>(Func<IDependencyCon
     public void AddSingleton(Type serviceType, Func<IDependencyContainer, object> factory)
         => Add(serviceType, new Registration(factory, isInstance: false));
 
+    /// <inheritdoc />
+    public void AddSingleton(Type serviceType, Func<IDependencyContainer, object> factory, Func<object, Task> asyncDisposer)
+        => Add(serviceType, new Registration(factory, isInstance: false,
+            asyncDisposer ?? throw new ArgumentNullException(nameof(asyncDisposer))));
+
     /// <inheritdoc />
     public void AddInstance(Type serviceType, Func<IDependencyContainer, object> factory)
         => Add(serviceType, new Registration(factory, isInstance: true));
@@ -336,14 +358,31 @@ private void Add(Type serviceType, Registration registration)
 /// <summary>
 /// Runtime container built from one or more registration sources.
 /// </summary>
-public sealed class DependencyContainer : IDependencyContainer, IServiceProvider
+/// <remarks>
+/// The container owns the lifetime of every singleton it constructs: disposing it disposes those
+/// instances, in reverse construction order, so a dependent is always disposed before the dependency
+/// it was given. Instances supplied by the caller through <see cref="IServiceRegistry.AddInstance"/>
+/// are not owned and are never disposed. Resolving from a disposed container throws.
+/// <para>
+/// This assembly targets netstandard2.0, where <c>IAsyncDisposable</c> does not exist. A singleton that
+/// disposes asynchronously is therefore registered with an <c>asyncDisposer</c> delegate, produced by the
+/// caller — normally the generated registry, which is compiled against a framework that does have the
+/// interface. Await <see cref="DisposeAsync"/> to run those; <see cref="Dispose"/> throws if any are present.
+/// </para>
+/// </remarks>
+public sealed class DependencyContainer : IDependencyContainer, IServiceProvider, IDisposable
 {
     private readonly Dictionary<Type, Registration> _registrations;
     private readonly Dictionary<Type, object> _singletons = new();
     private readonly IServiceProvider? _fallbackProvider;
     private readonly Stack<Type> _resolvingStack = new();
     private readonly HashSet<Type> _resolvingSet = new();
 
+    // Construction order. A dependency is always constructed before the dependent that asked for it,
+    // so disposing this list in reverse disposes dependents first.
+    private readonly List<OwnedInstance> _ownedInstances = new();
+    private bool _disposed;
+
     internal DependencyContainer(Dictionary<Type, Registration> registrations, IServiceProvider? fallbackProvider)
     {
         _registrations = registrations ?? throw new ArgumentNullException(nameof(registrations));
@@ -389,6 +428,9 @@ public bool TryResolve(Type serviceType, out object? instance)
         if (serviceType == null)
             throw new ArgumentNullException(nameof(serviceType));
 
+        if (_disposed)
+            throw new ObjectDisposedException(nameof(DependencyContainer));
+
         if (_singletons.TryGetValue(serviceType, out instance))
             return true;
 
@@ -423,8 +465,128 @@ public bool TryResolve(Type serviceType, out object? instance)
         }
 
         if (!registration.IsInstance)
+        {
             _singletons[serviceType] = instance;
+            TrackOwned(instance!, registration.AsyncDisposer);
+        }
 
         return true;
     }
+
+    /// <summary>
+    /// Disposes every singleton this container constructed, in reverse construction order. Instances
+    /// registered through <see cref="IServiceRegistry.AddInstance"/> belong to the caller and are left alone.
+    /// Throws if any owned singleton disposes asynchronously — await <see cref="DisposeAsync"/> for those.
+    /// </summary>
+    public void Dispose()
+    {
+        if (_disposed)
+            return;
+
+        _disposed = true;
+
+        List<Exception>? failures = null;
+
+        for (var i = _ownedInstances.Count - 1; i >= 0; i--)
+        {
+            var owned = _ownedInstances[i];
+            try
+            {
+                // A singleton that disposes both ways is disposed synchronously here; only one that has no
+                // synchronous path at all forces the caller to DisposeAsync.
+                if (owned.Instance is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+                else
+                {
+                    throw new InvalidOperationException(
+                        $"Singleton of type {owned.Instance.GetType()} disposes only asynchronously and cannot be "
+                        + "disposed synchronously. Await DisposeAsync on the container instead.");
+                }
+            }
+            catch (Exception ex)
+            {
+                (failures ??= new List<Exception>()).Add(ex);
+            }
+        }
+
+        Clear();
+
+        if (failures != null)
+            throw new AggregateException("One or more singletons failed to dispose.", failures);
+    }
+
+    /// <summary>
+    /// Asynchronously disposes every singleton this container constructed, in reverse construction order,
+    /// using each singleton's async disposer where it has one. Instances registered through
+    /// <see cref="IServiceRegistry.AddInstance"/> belong to the caller and are left alone.
+    /// </summary>
+    public async Task DisposeAsync()
+    {
+        if (_disposed)
+            return;
+
+        _disposed = true;
+
+        List<Exception>? failures = null;
+
+        for (var i = _ownedInstances.Count - 1; i >= 0; i--)
+        {
+            var owned = _ownedInstances[i];
+            try
+            {
+                if (owned.AsyncDisposer != null)
+                    await owned.AsyncDisposer(owned.Instance).ConfigureAwait(false);
+                else
+                    ((IDisposable)owned.Instance).Dispose();
+            }
+            catch (Exception ex)
+            {
+                (failures ??= new List<Exception>()).Add(ex);
+            }
+        }
+
+        Clear();
+
+        if (failures != null)
+            throw new AggregateException("One or more singletons failed to dispose.", failures);
+    }
+
+    /// <summary>
+    /// Records an instance the container constructed, so it can be disposed with the container. The same
+    /// object may be registered under several service types; it is constructed once and disposed once.
+    /// </summary>
+    private void TrackOwned(object instance, Func<object, Task>? asyncDisposer)
+    {
+        if (asyncDisposer == null && !(instance is IDisposable))
+            return;
+
+        foreach (var owned in _ownedInstances)
+        {
+            if (ReferenceEquals(owned.Instance, instance))
+                return;
+        }
+
+        _ownedInstances.Add(new OwnedInstance(instance, asyncDisposer));
+    }
+
+    private void Clear()
+    {
+        _ownedInstances.Clear();
+        _singletons.Clear();
+        _registrations.Clear();
+    }
+
+    private readonly struct OwnedInstance
+    {
+        public OwnedInstance(object instance, Func<object, Task>? asyncDisposer)
+        {
+            Instance = instance;
+            AsyncDisposer = asyncDisposer;
+        }
+
+        public object Instance { get; }
+        public Func<object, Task>? AsyncDisposer { get; }
+    }
 }

Source/Mal.SourceGeneratedDI.Abstractions/PackageVersion.txt

@@ -1 +1 @@
-2.0.3
+2.1.0

Source/Mal.SourceGeneratedDI.Abstractions/ReleaseNotes.txt

@@ -1,3 +1,11 @@
+v2.1.0
+   - `DependencyContainer` now implements `IDisposable`: it disposes every singleton it constructed, in reverse construction order, so a dependent is disposed before the dependency it was given
+   - Instances registered through `AddInstance`/`RegisterInstance` belong to the caller and are never disposed
+   - Added `DependencyContainer.DisposeAsync()` for singletons that dispose asynchronously. `Dispose()` throws for a singleton that has no synchronous path; one that disposes both ways is disposed synchronously
+   - A singleton failing to dispose no longer strands the rest — all are attempted and the failures reported together as an `AggregateException`
+   - Resolving from a disposed container throws `ObjectDisposedException`
+   - Breaking: `IServiceRegistry` gains an `AddSingleton` overload taking an async disposer. This package targets netstandard2.0 and cannot name `IAsyncDisposable`, so the delegate is supplied by the caller — normally the generated registry, which is compiled against a framework that has the interface
+
 v2.0.3
    - IDependencyContainer now extends IServiceProvider for compatibility with generalized service consumers