Dispose container-owned singletons

The container constructed singletons and never disposed them, so anything
holding an unmanaged resource leaked for the process lifetime. It now owns
what it constructs: disposing the container disposes those instances in
reverse construction order, so a dependent is always disposed before the
dependency it was handed. Instances supplied through AddInstance belong to
the caller and are left alone.

Async disposal needs IAsyncDisposable, which netstandard2.0 cannot name.
Rather than take a dependency or add a second target framework, the
generator emits the disposer into the consuming assembly — which is
compiled against a framework that has the interface — and the container
stores it as a plain delegate.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

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