Merge pull request #634 from hadashiA/ku/improve-exists

Improve IContainerBuilder.Exists()

Author: hadashiA

Diff for: .github/workflows/release.yaml

@@ -14,7 +14,7 @@ on:
 
 env:
   GIT_TAG: ${{ github.event.inputs.tag }}
-    
+   
 jobs:
   update-version-number:
     uses: ./.github/workflows/update-version-number.yaml

Diff for: VContainer/Assets/Tests/ContainerBuilderTest.cs

@@ -0,0 +1,46 @@
+using NUnit.Framework;
+
+namespace VContainer.Tests
+{
+    [TestFixture]
+    public class ContainerBuilderTest
+    {
+        [Test]
+        public void Exists()
+        {
+            var builder = new ContainerBuilder();
+            builder.Register<ServiceA>(Lifetime.Singleton)
+                .AsImplementedInterfaces()
+                .AsSelf();
+
+            Assert.That(builder.Exists(typeof(ServiceA)), Is.True);
+            Assert.That(builder.Exists(typeof(I4)), Is.False);
+            Assert.That(builder.Exists(typeof(I4), includeInterfaceTypes: true), Is.True);
+        }
+
+        [Test]
+        public void Exists_FromChild()
+        {
+            var builder = new ContainerBuilder();
+            builder.Register<ServiceA>(Lifetime.Singleton)
+                .AsImplementedInterfaces()
+                .AsSelf();
+
+            var parentScope = builder.Build();
+            var childScope = parentScope.CreateScope(childBuilder =>
+            {
+                childBuilder.Register<ServiceB>(Lifetime.Singleton);
+
+                Assert.That(childBuilder.Exists(typeof(ServiceA)), Is.False);
+                Assert.That(childBuilder.Exists(typeof(I4)), Is.False);
+                Assert.That(childBuilder.Exists(typeof(I4), includeInterfaceTypes: true), Is.False);
+
+                Assert.That(childBuilder.Exists(typeof(ServiceA), findParentScopes: true), Is.True);
+                Assert.That(childBuilder.Exists(typeof(I4), findParentScopes: true), Is.False);
+                Assert.That(childBuilder.Exists(typeof(I4), findParentScopes: true, includeInterfaceTypes: true), Is.True);
+
+                Assert.That(childBuilder.Exists(typeof(ServiceB)), Is.True);
+            });
+       }
+    }
+}

Diff for: VContainer/Assets/Tests/ContainerBuilderTest.cs.meta

@@ -28,13 +28,13 @@ public interface IObjectResolver : IDisposable
         object Resolve(Registration registration);
         IScopedObjectResolver CreateScope(Action<IContainerBuilder> installation = null);
         void Inject(object instance);
+        bool TryGetRegistration(Type type, out Registration registration);
     }
 
     public interface IScopedObjectResolver : IObjectResolver
     {
         IObjectResolver Root { get; }
         IScopedObjectResolver Parent { get; }
-        bool TryGetRegistration(Type type, out Registration registration);
     }
 
     public enum Lifetime
@@ -224,6 +224,11 @@ public void Inject(object instance)
             injector.Inject(instance, this, null);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryGetRegistration(Type type, out Registration registration)
+            => registry.TryGet(type, out registration);
+
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose()
         {

Diff for: VContainer/Assets/VContainer/Runtime/Container.cs

@@ -18,7 +18,7 @@ public interface IContainerBuilder
 
         T Register<T>(T registrationBuilder) where T : RegistrationBuilder;
         void RegisterBuildCallback(Action<IObjectResolver> container);
-        bool Exists(Type type, bool includeInterfaceTypes = false);
+        bool Exists(Type type, bool includeInterfaceTypes = false, bool findParentScopes = false);
     }
 
     public sealed class ScopedContainerBuilder : ContainerBuilder
@@ -44,6 +44,31 @@ public IScopedObjectResolver BuildScope()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override IObjectResolver Build() => BuildScope();
+
+        public override bool Exists(Type type, bool includeInterfaceTypes = false, bool findParentScopes = false)
+        {
+            if (base.Exists(type, includeInterfaceTypes, findParentScopes))
+            {
+                return true;
+            }
+
+            if (findParentScopes)
+            {
+                var next = parent;
+                while (next != null)
+                {
+                    if (parent.TryGetRegistration(type, out var registration))
+                    {
+                        if (includeInterfaceTypes || registration.ImplementationType == type)
+                        {
+                            return true;
+                        }
+                    }
+                    next = next.Parent;
+                }
+            }
+            return false;
+        }
     }
 
     public class ContainerBuilder : IContainerBuilder
@@ -87,7 +112,7 @@ public void RegisterBuildCallback(Action<IObjectResolver> callback)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool Exists(Type type, bool includeInterfaceTypes = false)
+        public virtual bool Exists(Type type, bool includeInterfaceTypes = false, bool findParentScopes = false)
         {
             foreach (var registrationBuilder in registrationBuilders)
             {