Transient instances now disposed and collected within constructing container

Author: gustavopsantos

Assets/Reflex.EditModeTests/GarbageCollectionTests.cs

@@ -14,7 +14,7 @@ private class Service
         {
         }
 
-        private static void ForceGarbageCollection()
+        public static void ForceGarbageCollection()
         {
             Resources.UnloadUnusedAssets();
             GC.Collect();

Assets/Reflex.EditModeTests/TransientTests.cs

@@ -0,0 +1,94 @@
+using System;
+using FluentAssertions;
+using NUnit.Framework;
+using Reflex.Core;
+
+namespace Reflex.EditModeTests
+{
+    public class TransientTests
+    {
+        private class Service : IDisposable
+        {
+            public bool IsDisposed { get; private set; }
+            
+            public void Dispose()
+            {
+                IsDisposed = true;
+            }
+        }
+        
+        [Test]
+        public void TransientFromType_ConstructedInstances_ShouldBeDisposed_WithinConstructingContainer()
+        {
+            var parentContainer = new ContainerBuilder().AddTransient(typeof(Service)).Build();
+            var childContainer = parentContainer.Scope();
+
+            var instanceConstructedByChild = childContainer.Resolve<Service>();
+            var instanceConstructedByParent = parentContainer.Resolve<Service>();
+            
+            childContainer.Dispose();
+
+            instanceConstructedByChild.IsDisposed.Should().BeTrue();
+            instanceConstructedByParent.IsDisposed.Should().BeFalse();
+        }
+        
+        [Test]
+        public void TransientFromFactory_ConstructedInstances_ShouldBeDisposed_WithinConstructingContainer()
+        {
+            var parentContainer = new ContainerBuilder().AddTransient(_ => new Service()).Build();
+            var childContainer = parentContainer.Scope();
+
+            var instanceConstructedByChild = childContainer.Resolve<Service>();
+            var instanceConstructedByParent = parentContainer.Resolve<Service>();
+            
+            childContainer.Dispose();
+
+            instanceConstructedByChild.IsDisposed.Should().BeTrue();
+            instanceConstructedByParent.IsDisposed.Should().BeFalse();
+        }
+        
+        [Test, Retry(3)]
+        public void TransientFromType_ConstructedInstances_ShouldBeCollected_WhenConstructingContainerIsDisposed()
+        {
+            WeakReference instanceConstructedByChild;
+            WeakReference instanceConstructedByParent;
+            var parentContainer = new ContainerBuilder().AddTransient(typeof(Service)).Build();
+
+            void Act()
+            {
+                using (var childContainer = parentContainer.Scope())
+                {
+                    instanceConstructedByChild = new WeakReference(childContainer.Resolve<Service>());
+                    instanceConstructedByParent = new WeakReference(parentContainer.Resolve<Service>());
+                }
+            }
+            
+            Act();
+            GarbageCollectionTests.ForceGarbageCollection();
+            instanceConstructedByChild.IsAlive.Should().BeFalse();
+            instanceConstructedByParent.IsAlive.Should().BeTrue();
+        }
+        
+        [Test, Retry(3)]
+        public void TransientFromFactory_ConstructedInstances_ShouldBeCollected_WhenConstructingContainerIsDisposed()
+        {
+            WeakReference instanceConstructedByChild;
+            WeakReference instanceConstructedByParent;
+            var parentContainer = new ContainerBuilder().AddTransient(c => new Service()).Build();
+
+            void Act()
+            {
+                using (var childContainer = parentContainer.Scope())
+                {
+                    instanceConstructedByChild = new WeakReference(childContainer.Resolve<Service>());
+                    instanceConstructedByParent = new WeakReference(parentContainer.Resolve<Service>());
+                }
+            }
+            
+            Act();
+            GarbageCollectionTests.ForceGarbageCollection();
+            instanceConstructedByChild.IsAlive.Should().BeFalse();
+            instanceConstructedByParent.IsAlive.Should().BeTrue();
+        }
+    }
+}

Assets/Reflex.EditModeTests/TransientTests.cs.meta

@@ -12,12 +12,12 @@ namespace Reflex.Core
 {
     public sealed class Container : IDisposable
     {
-        private readonly DisposableCollection _disposables;
 
         public string Name { get; }
         internal Container Parent { get; }
         internal List<Container> Children { get; } = new();
         internal Dictionary<Type, List<IResolver>> ResolversByContract { get; }
+        internal DisposableCollection Disposables { get; }
 
         internal Container(string name, Container parent, Dictionary<Type, List<IResolver>> resolversByContract, DisposableCollection disposables)
         {
@@ -26,7 +26,7 @@ internal Container(string name, Container parent, Dictionary<Type, List<IResolve
             Parent = parent;
             Parent?.Children.Add(this);
             ResolversByContract = resolversByContract;
-            _disposables = disposables;
+            Disposables = disposables;
             OverrideSelfInjection();
         }
 
@@ -49,7 +49,7 @@ public void Dispose()
 
             Parent?.Children.Remove(this);
             ResolversByContract.Clear();
-            _disposables.Dispose();
+            Disposables.Dispose();
             ReflexLogger.Log($"Container {Name} disposed", LogLevel.Info);
         }
 

Assets/Reflex/Core/Container.cs

@@ -19,7 +19,7 @@ public Container Build()
             var disposables = new DisposableCollection();
             var resolversByContract = new Dictionary<Type, List<IResolver>>();
 
-            // Inherit parent resolvers
+            // Inherited resolvers
             if (Parent != null)
             {
                 foreach (var kvp in Parent.ResolversByContract)
@@ -28,7 +28,7 @@ public Container Build()
                 }
             }
 
-            // Owned Resolvers
+            // Owned resolvers
             foreach (var binding in Bindings)
             {
                 disposables.Add(binding.Resolver);

Assets/Reflex/Core/ContainerBuilder.cs

@@ -1,14 +1,12 @@
 using System;
 using Reflex.Core;
 using Reflex.Enums;
-using Reflex.Generics;
 
 namespace Reflex.Resolvers
 {
     internal sealed class TransientFactoryResolver : IResolver
     {
         private readonly Func<Container, object> _factory;
-        private readonly DisposableCollection _disposables = new();
         public Lifetime Lifetime => Lifetime.Transient;
 
         public TransientFactoryResolver(Func<Container, object> factory)
@@ -21,14 +19,13 @@ public object Resolve(Container container)
         {
             Diagnosis.IncrementResolutions(this);
             var instance = _factory.Invoke(container);
-            _disposables.TryAdd(instance);
+            container.Disposables.TryAdd(instance);
             Diagnosis.RegisterInstance(this, instance);
             return instance;
         }
 
         public void Dispose()
         {
-            _disposables.Dispose();
         }
     }
 }

Assets/Reflex/Resolvers/TransientFactoryResolver.cs

@@ -1,14 +1,12 @@
 using System;
 using Reflex.Core;
 using Reflex.Enums;
-using Reflex.Generics;
 
 namespace Reflex.Resolvers
 {
     internal sealed class TransientTypeResolver : IResolver
     {
         private readonly Type _concreteType;
-        private readonly DisposableCollection _disposables = new();
         public Lifetime Lifetime => Lifetime.Transient;
 
         public TransientTypeResolver(Type concreteType)
@@ -21,14 +19,13 @@ public object Resolve(Container container)
         {
             Diagnosis.IncrementResolutions(this);
             var instance = container.Construct(_concreteType);
-            _disposables.TryAdd(instance);
+            container.Disposables.TryAdd(instance);
             Diagnosis.RegisterInstance(this, instance);
             return instance;
         }
 
         public void Dispose()
         {
-            _disposables.Dispose();
         }
     }
 }