Add scoped api

Assets/Reflex.EditModeTests/GarbageCollectionTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using FluentAssertions;
 using NUnit.Framework;
@@ -21,6 +22,12 @@ public static void ForceGarbageCollection()
             GC.WaitForPendingFinalizers();
         }
 
+        [Conditional("REFLEX_DEBUG")]
+        public static void MarkAsInconclusiveWhenReflexDebugIsEnabled()
+        {
+            Assert.Inconclusive("Disable REFLEX_DEBUG symbol when running garbage collection tests!");
+        }
+
         [Test, Retry(3)]
         public void Singleton_ShouldBeFinalized_WhenOwnerIsDisposed()
         {

Assets/Reflex.EditModeTests/ScopedTests.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using FluentAssertions;
+using NUnit.Framework;
+using Reflex.Core;
+using UnityEditor;
+
+namespace Reflex.EditModeTests
+{
+    public class ScopedTests
+    {
+        private class Service : IDisposable
+        {
+            public bool IsDisposed { get; private set; }
+
+            public void Dispose()
+            {
+                IsDisposed = true;
+            }
+        }
+
+        [Test]
+        public void ScopedFromType_ShouldReturnAlwaysSameInstance_WhenCalledFromSameContainer()
+        {
+            var parentContainer = new ContainerBuilder().AddScoped(typeof(Service)).Build();
+            var childContainer = parentContainer.Scope();
+            parentContainer.Resolve<Service>().Should().Be(parentContainer.Resolve<Service>());
+            childContainer.Resolve<Service>().Should().Be(childContainer.Resolve<Service>());
+        }
+
+        [Test]
+        public void ScopedFromFactory_ShouldReturnAlwaysSameInstance_WhenCalledFromSameContainer()
+        {
+            var parentContainer = new ContainerBuilder().AddScoped(_ => new Service()).Build();
+            var childContainer = parentContainer.Scope();
+            parentContainer.Resolve<Service>().Should().Be(parentContainer.Resolve<Service>());
+            childContainer.Resolve<Service>().Should().Be(childContainer.Resolve<Service>());
+        }
+
+        [Test]
+        public void ScopedFromType_NewInstanceShouldBeConstructed_ForEveryNewContainer()
+        {
+            var instances = new HashSet<Service>();
+            var parentContainer = new ContainerBuilder().AddScoped(typeof(Service)).Build();
+            var childContainer = parentContainer.Scope();
+            instances.Add(parentContainer.Resolve<Service>());
+            instances.Add(childContainer.Resolve<Service>());
+            instances.Add(parentContainer.Resolve<Service>());
+            instances.Add(childContainer.Resolve<Service>());
+            instances.Count.Should().Be(2);
+        }
+
+        [Test]
+        public void ScopedFromFactory_NewInstanceShouldBeConstructed_ForEveryNewContainer()
+        {
+            var instances = new HashSet<Service>();
+            var parentContainer = new ContainerBuilder().AddScoped(_ => new Service()).Build();
+            var childContainer = parentContainer.Scope();
+            instances.Add(parentContainer.Resolve<Service>());
+            instances.Add(childContainer.Resolve<Service>());
+            instances.Add(parentContainer.Resolve<Service>());
+            instances.Add(childContainer.Resolve<Service>());
+            instances.Count.Should().Be(2);
+        }
+
+        [Test]
+        public void ScopedFromType_ConstructedInstances_ShouldBeDisposed_WithinConstructingContainer()
+        {
+            var parentContainer = new ContainerBuilder().AddScoped(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 ScopedFromFactory_ConstructedInstances_ShouldBeDisposed_WithinConstructingContainer()
+        {
+            var parentContainer = new ContainerBuilder().AddScoped(_ => 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 ScopedFromType_ConstructedInstances_ShouldBeCollected_WhenConstructingContainerIsDisposed()
+        {
+            GarbageCollectionTests.MarkAsInconclusiveWhenReflexDebugIsEnabled();
+
+            WeakReference instanceConstructedByChild;
+            WeakReference instanceConstructedByParent;
+            var parentContainer = new ContainerBuilder().AddScoped(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 ScopedFromFactory_ConstructedInstances_ShouldBeCollected_WhenConstructingContainerIsDisposed()
+        {
+            GarbageCollectionTests.MarkAsInconclusiveWhenReflexDebugIsEnabled();
+
+            WeakReference instanceConstructedByChild;
+            WeakReference instanceConstructedByParent;
+            var parentContainer = new ContainerBuilder().AddScoped(_ => 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

@@ -50,6 +50,8 @@ public void TransientFromFactory_ConstructedInstances_ShouldBeDisposed_WithinCon
         [Test, Retry(3)]
         public void TransientFromType_ConstructedInstances_ShouldBeCollected_WhenConstructingContainerIsDisposed()
         {
+            GarbageCollectionTests.MarkAsInconclusiveWhenReflexDebugIsEnabled();
+
             WeakReference instanceConstructedByChild;
             WeakReference instanceConstructedByParent;
             var parentContainer = new ContainerBuilder().AddTransient(typeof(Service)).Build();
@@ -72,6 +74,8 @@ void Act()
         [Test, Retry(3)]
         public void TransientFromFactory_ConstructedInstances_ShouldBeCollected_WhenConstructingContainerIsDisposed()
         {
+            GarbageCollectionTests.MarkAsInconclusiveWhenReflexDebugIsEnabled();
+
             WeakReference instanceConstructedByChild;
             WeakReference instanceConstructedByParent;
             var parentContainer = new ContainerBuilder().AddTransient(c => new Service()).Build();

Assets/Reflex/Core/Container.cs

@@ -12,7 +12,6 @@ namespace Reflex.Core
 {
     public sealed class Container : IDisposable
     {
-
         public string Name { get; }
         internal Container Parent { get; }
         internal List<Container> Children { get; } = new();

Assets/Reflex/Core/ContainerBuilder.cs

@@ -117,6 +117,34 @@ public ContainerBuilder AddTransient<T>(Func<Container, T> factory)
         {
             return AddTransient(factory, typeof(T));
         }
+
+        // Scoped
+
+        public ContainerBuilder AddScoped(Type concrete, params Type[] contracts)
+        {
+            return Add(concrete, contracts, new ScopedTypeResolver(concrete));
+        }
+
+        public ContainerBuilder AddScoped(Type concrete)
+        {
+            return AddScoped(concrete, concrete);
+        }
+
+        public ContainerBuilder AddScoped<T>(Func<Container, T> factory, params Type[] contracts)
+        {
+            var resolver = new ScopedFactoryResolver(Proxy);
+            return Add(typeof(T), contracts, resolver);
+
+            object Proxy(Container container)
+            {
+                return factory.Invoke(container);
+            }
+        }
+
+        public ContainerBuilder AddScoped<T>(Func<Container, T> factory)
+        {
+            return AddScoped(factory, typeof(T));
+        }
 
         public bool HasBinding(Type type)
         {

Assets/Reflex/Enums/Lifetime.cs

@@ -4,5 +4,6 @@ public enum Lifetime
     {
         Singleton,
         Transient,
+        Scoped,
     }
 }

Assets/Reflex/Resolvers/ScopedFactoryResolver.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Runtime.CompilerServices;
+using Reflex.Core;
+using Reflex.Enums;
+
+namespace Reflex.Resolvers
+{
+    internal sealed class ScopedFactoryResolver : IResolver
+    {
+        private readonly Func<Container, object> _factory;
+        private readonly ConditionalWeakTable<Container, object> _instances = new();
+        public Lifetime Lifetime => Lifetime.Scoped;
+
+        public ScopedFactoryResolver(Func<Container, object> factory)
+        {
+            Diagnosis.RegisterCallSite(this);
+            _factory = factory;
+        }
+
+        public object Resolve(Container container)
+        {
+            Diagnosis.IncrementResolutions(this);
+
+            if (!_instances.TryGetValue(container, out var instance))
+            {
+                instance = _factory.Invoke(container);
+                _instances.Add(container, instance);
+                container.Disposables.TryAdd(instance);
+                Diagnosis.RegisterInstance(this, instance);
+            }
+
+            return instance;
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+}

Assets/Reflex/Resolvers/ScopedTypeResolver.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Runtime.CompilerServices;
+using Reflex.Core;
+using Reflex.Enums;
+
+namespace Reflex.Resolvers
+{
+    internal sealed class ScopedTypeResolver : IResolver
+    {
+        private readonly Type _concreteType;
+        private readonly ConditionalWeakTable<Container, object> _instances = new();
+        public Lifetime Lifetime => Lifetime.Scoped;
+
+        public ScopedTypeResolver(Type concreteType)
+        {
+            Diagnosis.RegisterCallSite(this);
+            _concreteType = concreteType;
+        }
+
+        public object Resolve(Container container)
+        {
+            Diagnosis.IncrementResolutions(this);
+
+            if (!_instances.TryGetValue(container, out var instance))
+            {
+                instance = container.Construct(_concreteType);
+                _instances.Add(container, instance);
+                container.Disposables.TryAdd(instance);
+                Diagnosis.RegisterInstance(this, instance);
+            }
+
+            return instance;
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+}