Added overload for CanResolve which allows ignoring implicit bindings

ninject · Oct 12, 2011 · bcd77c5 · bcd77c5
1 parent 3478fe1
commit bcd77c5
Show file tree

Hide file tree

Showing 5 changed files with 71 additions and 2 deletions.
diff --git a/src/Ninject.Test/Integration/StandardKernelTests.cs b/src/Ninject.Test/Integration/StandardKernelTests.cs
@@ -1,19 +1,27 @@
 namespace Ninject.Tests.Integration.StandardKernelTests
 {
+    using System;
     using System.Collections.Generic;
     using System.Linq;
     using FluentAssertions;
+
+    using Ninject.Parameters;
     using Ninject.Tests.Fakes;
     using Xunit;
 
-    public class StandardKernelContext
+    public class StandardKernelContext : IDisposable
     {
         protected StandardKernel kernel;
 
         public StandardKernelContext()
         {
             this.kernel = new StandardKernel();
         }
+
+        public void Dispose()
+        {
+            this.kernel.Dispose();
+        }
     }
 
     public class WhenGetIsCalledForInterfaceBoundService : StandardKernelContext
@@ -423,6 +431,20 @@ public void RemovesAllBindingsForServiceAndReplacesWithSpecifiedBinding()
         }
     }
 
+    public class WhenCanResolveIsCalled : StandardKernelContext
+    {
+        [Fact]
+        public void ForImplicitBindings()
+        {
+            this.kernel.Get<Sword>();
+            var request = this.kernel.CreateRequest(typeof(Sword), null, Enumerable.Empty<IParameter>(), false, true);
+
+            this.kernel.CanResolve(request, true).Should().BeFalse();
+            this.kernel.CanResolve(request, false).Should().BeTrue();
+            this.kernel.CanResolve(request).Should().BeTrue();
+        }
+    }
+
     public class InitializableA : IInitializable
     {
         public static int Count = 0;

diff --git a/src/Ninject.Test/Unit/ActivationBlockTests.cs b/src/Ninject.Test/Unit/ActivationBlockTests.cs
@@ -30,6 +30,14 @@ public void DelegatesCallToParent()
             block.CanResolve(request);
             parentMock.Verify(x => x.CanResolve(request));
         }
+
+        [Fact]
+        public void DelegatesCallToParent2()
+        {
+            IRequest request = requestMock.Object;
+            block.CanResolve(request, true);
+            parentMock.Verify(x => x.CanResolve(request, true));
+        }
     }
 
     public class WhenResolveIsCalledWithRequestObject : ActivationBlockContext

diff --git a/src/Ninject/Activation/Blocks/ActivationBlock.cs b/src/Ninject/Activation/Blocks/ActivationBlock.cs
@@ -71,7 +71,21 @@ public override void Dispose(bool disposing)
         public bool CanResolve(IRequest request)
         {
             Ensure.ArgumentNotNull(request, "request");
-            return Parent.CanResolve(request);
+            return this.Parent.CanResolve(request);
+        }
+
+        /// <summary>
+        /// Determines whether the specified request can be resolved.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="ignoreImplicitBindings">if set to <c>true</c> implicit bindings are ignored.</param>
+        /// <returns>
+        ///     <c>True</c> if the request can be resolved; otherwise, <c>false</c>.
+        /// </returns>
+        public bool CanResolve(IRequest request, bool ignoreImplicitBindings)
+        {
+            Ensure.ArgumentNotNull(request, "request");
+            return this.Parent.CanResolve(request, ignoreImplicitBindings);
         }
 
         /// <summary>

diff --git a/src/Ninject/KernelBase.cs b/src/Ninject/KernelBase.cs
@@ -318,6 +318,21 @@ public virtual bool CanResolve(IRequest request)
             return this.GetBindings(request.Service).Any(this.SatifiesRequest(request));
         }
 
+        /// <summary>
+        /// Determines whether the specified request can be resolved.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="ignoreImplicitBindings">if set to <c>true</c> implicit bindings are ignored.</param>
+        /// <returns>
+        ///     <c>True</c> if the request can be resolved; otherwise, <c>false</c>.
+        /// </returns>
+        public virtual bool CanResolve(IRequest request, bool ignoreImplicitBindings)
+        {
+            Ensure.ArgumentNotNull(request, "request");
+            return this.GetBindings(request.Service)
+                .Any(binding => (!ignoreImplicitBindings || !binding.IsImplicit) && this.SatifiesRequest(request)(binding));
+        }
+
         /// <summary>
         /// Resolves instances for the specified request. The instances are not actually resolved
         /// until a consumer iterates over the enumerator.

diff --git a/src/Ninject/Syntax/IResolutionRoot.cs b/src/Ninject/Syntax/IResolutionRoot.cs
@@ -29,6 +29,16 @@ public interface IResolutionRoot
         /// <returns><c>True</c> if the request can be resolved; otherwise, <c>false</c>.</returns>
         bool CanResolve(IRequest request);
 
+        /// <summary>
+        /// Determines whether the specified request can be resolved.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="ignoreImplicitBindings">if set to <c>true</c> implicit bindings are ignored.</param>
+        /// <returns>
+        ///     <c>True</c> if the request can be resolved; otherwise, <c>false</c>.
+        /// </returns>
+        bool CanResolve(IRequest request, bool ignoreImplicitBindings);
+
         /// <summary>
         /// Resolves instances for the specified request. The instances are not actually resolved
         /// until a consumer iterates over the enumerator.