Fixed wrong PutInstanceInScope behavior

z4kn4fein · May 10, 2017 · 120c03d · 120c03d
1 parent e69df38
commit 120c03d
Show file tree

Hide file tree

Showing 18 changed files with 67 additions and 39 deletions.
diff --git a/appveyor.yml b/appveyor.yml
@@ -17,7 +17,7 @@
     artifact: /.*\.nupkg/
 
   environment:
-    build_version: 2.4.6
+    build_version: 2.4.7
     COVERALLS_REPO_TOKEN:
       secure: Q9gcbZnzJ5a0YYF6mkr4QoQylIzeQmVytMnIe4WL7aPtb30SdNes7brLkvnXOirt
 
@@ -79,7 +79,7 @@
       secure: 2bITagXOj2s3bTJaGXh8/iyWtST8OQOFaMM+0GAKgZts9OjCVCiV7C+E/0SYsM6M
 
   environment:
-    build_version: 2.4.6
+    build_version: 2.4.7
     COVERALLS_REPO_TOKEN:
       secure: Q9gcbZnzJ5a0YYF6mkr4QoQylIzeQmVytMnIe4WL7aPtb30SdNes7brLkvnXOirt
 

diff --git a/src/stashbox.tests/ContainerTests.cs b/src/stashbox.tests/ContainerTests.cs
@@ -188,7 +188,7 @@ public class TestResolver : Resolver
         {
             public override bool SupportsMany => true;
 
-            public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo)
+            public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo)
             {
                 return typeInfo.Type == typeof(ITest1);
             }
@@ -203,7 +203,7 @@ public class TestResolver2 : Resolver
         {
             public override bool SupportsMany => true;
 
-            public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo)
+            public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo)
             {
                 return typeInfo.Type == typeof(ITest1);
             }

diff --git a/src/stashbox.tests/DisposeTests.cs b/src/stashbox.tests/DisposeTests.cs
@@ -237,8 +237,8 @@ public void DisposeTests_PutInScope_Scoped()
         {
             using (IStashboxContainer container = new StashboxContainer())
             {
-                container.RegisterType<ITest2, Test2>();
-                container.RegisterType<Test3>();
+                container.RegisterScoped<ITest2, Test2>();
+                container.RegisterScoped<Test3>();
 
                 var test = new Test1();
 
@@ -256,6 +256,27 @@ public void DisposeTests_PutInScope_Scoped()
                 }
 
                 Assert.IsTrue(test.Disposed);
+
+                var test4 = new Test1();
+
+                using (var child = container.BeginScope())
+                {
+                    child.PutInstanceInScope<ITest1>(test4);
+
+                    var test1 = child.Resolve<ITest1>();
+                    var test2 = child.Resolve<ITest2>();
+                    var test3 = child.Resolve<Test3>();
+
+                    Assert.AreSame(test4, test1);
+                    Assert.AreSame(test4, test2.Test1);
+                    Assert.AreSame(test4, test3.Test1);
+
+                    Assert.AreNotSame(test, test1);
+                    Assert.AreNotSame(test, test2.Test1);
+                    Assert.AreNotSame(test, test3.Test1);
+                }
+
+                Assert.IsTrue(test4.Disposed);
             }
         }
 

diff --git a/src/stashbox/BuildUp/Resolution/DefaultValueResolver.cs b/src/stashbox/BuildUp/Resolution/DefaultValueResolver.cs
@@ -23,7 +23,7 @@ public override Expression GetExpression(IContainerContext containerContext, Typ
             return null;
         }
 
-        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo) =>
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
             containerContext.ContainerConfigurator.ContainerConfiguration.OptionalAndDefaultValueInjectionEnabled &&
                  (typeInfo.HasDefaultValue || typeInfo.Type.GetTypeInfo().IsValueType || typeInfo.Type == typeof(string) || typeInfo.IsMember);
     }

diff --git a/src/stashbox/BuildUp/Resolution/EnumerableResolver.cs b/src/stashbox/BuildUp/Resolution/EnumerableResolver.cs
@@ -17,7 +17,7 @@ public override Expression GetExpression(IContainerContext containerContext, Typ
                     Expression.NewArrayInit(enumerableType.Type, expressions);
         }
 
-        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo) =>
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
             typeInfo.Type.GetEnumerableType() != null;
     }
 }
diff --git a/src/stashbox/BuildUp/Resolution/FuncResolver.cs b/src/stashbox/BuildUp/Resolution/FuncResolver.cs
@@ -56,7 +56,7 @@ public override Expression[] GetExpressions(IContainerContext containerContext,
             return funcExpressions;
         }
 
-        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo) =>
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
             typeInfo.Type.IsClosedGenericType() && this.supportedTypes.Contains(typeInfo.Type.GetGenericTypeDefinition());
 
         private ParameterExpression[] PrepareExtraParameters(Type wrappedType, ResolutionInfo resolutionInfo, Type[] args)

diff --git a/src/stashbox/BuildUp/Resolution/LazyResolver.cs b/src/stashbox/BuildUp/Resolution/LazyResolver.cs
@@ -86,7 +86,7 @@ private Expression CreateLazyExpressionCall(IServiceRegistration serviceRegistra
             return Expression.New(constructor, Expression.Lambda(convert));
         }
 
-        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo) =>
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
             typeInfo.Type.IsClosedGenericType() && typeInfo.Type.GetGenericTypeDefinition() == typeof(Lazy<>);
 
         private static readonly MethodInfo DelegateCacheMethod = typeof(DelegateCache).GetSingleMethod("CreateLazyDelegate");

diff --git a/src/stashbox/BuildUp/Resolution/ParentContainerResolver.cs b/src/stashbox/BuildUp/Resolution/ParentContainerResolver.cs
@@ -7,7 +7,7 @@ namespace Stashbox.BuildUp.Resolution
 {
     internal class ParentContainerResolver : Resolver
     {
-        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo) =>
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
             containerContext.Container.ParentContainer != null && containerContext.Container.ParentContainer.CanResolve(typeInfo.Type, typeInfo.DependencyName);
 
         public override Expression GetExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>

diff --git a/src/stashbox/BuildUp/Resolution/ScopedInstanceResolver.cs b/src/stashbox/BuildUp/Resolution/ScopedInstanceResolver.cs
@@ -0,0 +1,16 @@
+using System.Linq.Expressions;
+using Stashbox.Entity;
+using Stashbox.Infrastructure;
+using Stashbox.Infrastructure.Resolution;
+
+namespace Stashbox.BuildUp.Resolution
+{
+    internal class ScopedInstanceResolver : Resolver
+    {
+        public override Expression GetExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
+            Expression.Convert(Expression.Call(Constants.ScopeExpression, Constants.GetScopedInstanceMethod, Expression.Constant(typeInfo.Type)), typeInfo.Type);
+
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
+            resolutionInfo.ResolutionScope.HasScopedInstances && resolutionInfo.ResolutionScope.GetScopedInstanceOrDefault(typeInfo.Type) != null;
+    }
+}
diff --git a/src/stashbox/BuildUp/Resolution/TupleResolver.cs b/src/stashbox/BuildUp/Resolution/TupleResolver.cs
@@ -21,7 +21,7 @@ internal class TupleResolver : Resolver
             typeof(Tuple<,,,,,,,>)
         };
 
-        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo) =>
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
             typeInfo.Type.IsClosedGenericType() && this.supportedTypes.Contains(typeInfo.Type.GetGenericTypeDefinition());
 
         public override Expression GetExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo)

diff --git a/src/stashbox/BuildUp/Resolution/UnknownTypeResolver.cs b/src/stashbox/BuildUp/Resolution/UnknownTypeResolver.cs
@@ -8,7 +8,7 @@ namespace Stashbox.BuildUp.Resolution
 {
     internal class UnknownTypeResolver : Resolver
     {
-        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo) =>
+        public override bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo) =>
             containerContext.ContainerConfigurator.ContainerConfiguration.UnknownTypeResolutionEnabled &&
                        typeInfo.Type.IsValidForRegistration();
 

diff --git a/src/stashbox/Constants.cs b/src/stashbox/Constants.cs
@@ -24,6 +24,8 @@ public static class Constants
 
         internal static MethodInfo GetScopedValueMethod = typeof(ScopedLifetime).GetSingleMethod("GetScopedValue", true);
 
+        internal static MethodInfo GetScopedInstanceMethod = typeof(IResolutionScope).GetSingleMethod("GetScopedInstanceOrDefault");
+
         internal static Type DisposableType = typeof(IDisposable);
 
         internal static Type FuncType = typeof(Func<>);

diff --git a/src/stashbox/Infrastructure/Resolution/IResolverSelector.cs b/src/stashbox/Infrastructure/Resolution/IResolverSelector.cs
@@ -13,8 +13,9 @@ public interface IResolverSelector
         /// </summary>
         /// <param name="containerContext">The container context.</param>
         /// <param name="typeInfo">The type info.</param>
+        /// <param name="resolutionInfo">The resolution info.</param>
         /// <returns></returns>
-        bool CanResolve(IContainerContext containerContext, TypeInformation typeInfo);
+        bool CanResolve(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo);
 
         /// <summary>
         /// Gets an expression built by a selected <see cref="Resolver"/>.

diff --git a/src/stashbox/Infrastructure/Resolution/Resolver.cs b/src/stashbox/Infrastructure/Resolution/Resolver.cs
@@ -40,7 +40,8 @@ public virtual Expression[] GetExpressions(IContainerContext containerContext, T
         /// </summary>
         /// <param name="containerContext">The container context.</param>
         /// <param name="typeInfo">The type info.</param>
+        /// <param name="resolutionInfo">The info about the actual resolution.</param>
         /// <returns>Returns true, if the resolver can be used to activate the requested service, otherwise false.</returns>
-        public abstract bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo);
+        public abstract bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo);
     }
 }
diff --git a/src/stashbox/Resolution/ActivationContext.cs b/src/stashbox/Resolution/ActivationContext.cs
@@ -44,13 +44,6 @@ private object Activate(ResolutionInfo resolutionInfo, Type type, object name =
             if (type == Constants.ResolverType)
                 return resolutionInfo.ResolutionScope;
 
-            if (resolutionInfo.ResolutionScope.HasScopedInstances)
-            {
-                var instance = resolutionInfo.ResolutionScope.GetScopedInstanceOrDefault(type);
-                if (instance != null)
-                    return instance;
-            }
-
             var registration = this.containerContext.RegistrationRepository.GetRegistrationOrDefault(type, name);
             if (registration != null)
             {

diff --git a/src/stashbox/Resolution/ResolutionStrategy.cs b/src/stashbox/Resolution/ResolutionStrategy.cs
@@ -32,13 +32,6 @@ public Expression BuildResolutionExpression(IContainerContext containerContext,
             if (exprOverride != null)
                 return exprOverride;
 
-            if (resolutionInfo.ResolutionScope.HasScopedInstances)
-            {
-                var instance = resolutionInfo.ResolutionScope.GetScopedInstanceOrDefault(typeInformation.Type);
-                if (instance != null)
-                    return Expression.Constant(instance);
-            }
-
             var registration = containerContext.RegistrationRepository.GetRegistrationOrDefault(typeInformation, true);
             return registration != null ? registration.GetExpression(resolutionInfo, typeInformation.Type) :
                 this.resolverSelector.GetResolverExpression(containerContext, typeInformation, resolutionInfo);

diff --git a/src/stashbox/Resolution/ResolverSelector.cs b/src/stashbox/Resolution/ResolverSelector.cs
@@ -20,41 +20,41 @@ public ResolverSelector()
             this.parentContainerResolver = new ParentContainerResolver();
         }
 
-        public bool CanResolve(IContainerContext containerContext, TypeInformation typeInfo)
+        public bool CanResolve(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo)
         {
             for (var i = 0; i < this.resolverRepository.Lenght; i++)
-                if (this.resolverRepository.Get(i).CanUseForResolution(containerContext, typeInfo))
+                if (this.resolverRepository.Get(i).CanUseForResolution(containerContext, typeInfo, resolutionInfo))
                     return true;
 
-            return this.parentContainerResolver.CanUseForResolution(containerContext, typeInfo) ||
-                this.unknownTypeResolver.CanUseForResolution(containerContext, typeInfo);
+            return this.parentContainerResolver.CanUseForResolution(containerContext, typeInfo, resolutionInfo) ||
+                this.unknownTypeResolver.CanUseForResolution(containerContext, typeInfo, resolutionInfo);
         }
 
         public Expression GetResolverExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo)
         {
             for (var i = 0; i < this.resolverRepository.Lenght; i++)
             {
                 var item = this.resolverRepository.Get(i);
-                if (item.CanUseForResolution(containerContext, typeInfo))
+                if (item.CanUseForResolution(containerContext, typeInfo, resolutionInfo))
                     return item.GetExpression(containerContext, typeInfo, resolutionInfo);
             }
 
-            if (this.parentContainerResolver.CanUseForResolution(containerContext, typeInfo))
+            if (this.parentContainerResolver.CanUseForResolution(containerContext, typeInfo, resolutionInfo))
                 return this.parentContainerResolver.GetExpression(containerContext, typeInfo, resolutionInfo);
 
-            return this.unknownTypeResolver.CanUseForResolution(containerContext, typeInfo) ? this.unknownTypeResolver.GetExpression(containerContext, typeInfo, resolutionInfo) : null;
+            return this.unknownTypeResolver.CanUseForResolution(containerContext, typeInfo, resolutionInfo) ? this.unknownTypeResolver.GetExpression(containerContext, typeInfo, resolutionInfo) : null;
         }
 
         public Expression[] GetResolverExpressions(IContainerContext containerContext, TypeInformation typeInfo, ResolutionInfo resolutionInfo)
         {
             for (var i = 0; i < this.resolverRepository.Lenght; i++)
             {
                 var item = this.resolverRepository.Get(i);
-                if (item.SupportsMany && item.CanUseForResolution(containerContext, typeInfo))
+                if (item.SupportsMany && item.CanUseForResolution(containerContext, typeInfo, resolutionInfo))
                     return item.GetExpressions(containerContext, typeInfo, resolutionInfo);
             }
 
-            return this.parentContainerResolver.CanUseForResolution(containerContext, typeInfo) ? this.parentContainerResolver.GetExpressions(containerContext, typeInfo, resolutionInfo) : null;
+            return this.parentContainerResolver.CanUseForResolution(containerContext, typeInfo, resolutionInfo) ? this.parentContainerResolver.GetExpressions(containerContext, typeInfo, resolutionInfo) : null;
         }
 
         public void AddResolver(Resolver resolver) =>

diff --git a/src/stashbox/StashboxContainer.cs b/src/stashbox/StashboxContainer.cs
@@ -86,7 +86,7 @@ public bool CanResolve<TFrom>(object name = null) =>
         /// <inheritdoc />
         public bool CanResolve(Type typeFrom, object name = null) =>
             this.registrationRepository.ContainsRegistration(typeFrom, name) ||
-                this.resolverSelector.CanResolve(this.ContainerContext, new TypeInformation { Type = typeFrom, DependencyName = name });
+                this.resolverSelector.CanResolve(this.ContainerContext, new TypeInformation { Type = typeFrom, DependencyName = name }, ResolutionInfo.New(this, this));
 
         /// <inheritdoc />
         public void Validate()
@@ -122,6 +122,7 @@ private void RegisterResolvers()
             this.resolverSelector.AddResolver(new LazyResolver(this.resolverSelector));
             this.resolverSelector.AddResolver(new FuncResolver());
             this.resolverSelector.AddResolver(new TupleResolver());
+            this.resolverSelector.AddResolver(new ScopedInstanceResolver());
             this.resolverSelector.AddResolver(new DefaultValueResolver());
         }