Merge branch 'master' of https://github.com/unitycontainer/container into v5.x

ENikS · ENikS · commit 5f015336145d · 2019-03-19T19:04:14.000-04:00
diff --git a/src/Builder/Context/BuilderContext.cs b/src/Builder/Context/BuilderContext.cs
@@ -3,6 +3,7 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Security;
+using Unity.Exceptions;
 using Unity.Lifetime;
 using Unity.Policy;
 using Unity.Registration;
@@ -24,6 +25,7 @@ public struct BuilderContext : IResolveContext
         public IPolicyList List;
 
         public delegate object ExecutePlanDelegate(BuilderStrategy[] chain, ref BuilderContext context);
+        public delegate object ResolvePlanDelegate(ref BuilderContext context, ResolveDelegate<BuilderContext> resolver);
 
         #endregion
 
@@ -57,7 +59,7 @@ public object Resolve(Type type, string name)
                     {
                         var context = this;
 
-                        return resolverPolicy.Resolve(ref context);
+                        return ResolvePlan(ref context, resolverPolicy.Resolve);
                     }
                 }
             }
@@ -127,6 +129,8 @@ public void Clear(Type type, string name, Type policyInterface)
 #endif
         public ExecutePlanDelegate ExecutePlan;
 
+        public ResolvePlanDelegate ResolvePlan;
+
         #endregion
 
 
@@ -145,6 +149,7 @@ public object Resolve(Type type, string name, InternalRegistration registration)
                     Name = name,
                     Type = registration is ContainerRegistration containerRegistration ? containerRegistration.Type : type,
                     ExecutePlan = ExecutePlan,
+                    ResolvePlan = ResolvePlan,
                     List = List,
                     Overrides = Overrides,
                     DeclaringType = Type,
@@ -175,14 +180,14 @@ public object Resolve(ParameterInfo parameter, object value)
                         // Check if itself is a value 
                         if (resolverOverride is IResolve resolverPolicy)
                         {
-                            return resolverPolicy.Resolve(ref context);
+                            return ResolvePlan(ref context, resolverPolicy.Resolve);
                         }
 
                         // Try to create value
                         var resolveDelegate = resolverOverride.GetResolver<BuilderContext>(parameter.ParameterType);
                         if (null != resolveDelegate)
                         {
-                            return resolveDelegate(ref context);
+                            return ResolvePlan(ref context, resolveDelegate);
                         }
                     }
                 }
@@ -220,14 +225,14 @@ public object Resolve(PropertyInfo property, object value)
                         // Check if itself is a value 
                         if (resolverOverride is IResolve resolverPolicy)
                         {
-                            return resolverPolicy.Resolve(ref context);
+                            return ResolvePlan(ref context, resolverPolicy.Resolve);
                         }
 
                         // Try to create value
                         var resolveDelegate = resolverOverride.GetResolver<BuilderContext>(property.PropertyType);
                         if (null != resolveDelegate)
                         {
-                            return resolveDelegate(ref context);
+                            return ResolvePlan(ref context, resolveDelegate);
                         }
                     }
                 }
@@ -240,8 +245,15 @@ public object Resolve(PropertyInfo property, object value)
                     return Resolve(property.PropertyType, dependencyAttribute.Name);
 
                 case OptionalDependencyAttribute optionalAttribute:
-                    try { return Resolve(property.PropertyType, optionalAttribute.Name); }
-                    catch { return null; }
+                    try
+                    {
+                        return Resolve(property.PropertyType, optionalAttribute.Name);
+                    }
+                    catch (Exception ex) 
+                    when (!(ex.InnerException is CircularDependencyException))
+                    {
+                        return null;
+                    }
 
                 case ResolveDelegate<BuilderContext> resolver:
                     return resolver(ref context);
@@ -268,14 +280,14 @@ public object Resolve(FieldInfo field, object value)
                         // Check if itself is a value 
                         if (resolverOverride is IResolve resolverPolicy)
                         {
-                            return resolverPolicy.Resolve(ref context);
+                            return ResolvePlan(ref context, resolverPolicy.Resolve);
                         }
 
                         // Try to create value
                         var resolveDelegate = resolverOverride.GetResolver<BuilderContext>(field.FieldType);
                         if (null != resolveDelegate)
                         {
-                            return resolveDelegate(ref context);
+                            return ResolvePlan(ref context, resolveDelegate);
                         }
                     }
                 }
@@ -288,8 +300,15 @@ public object Resolve(FieldInfo field, object value)
                     return Resolve(field.FieldType, dependencyAttribute.Name);
 
                 case OptionalDependencyAttribute optionalAttribute:
-                    try { return Resolve(field.FieldType, optionalAttribute.Name); }
-                    catch { return null; }
+                    try
+                    {
+                        return Resolve(field.FieldType, optionalAttribute.Name);
+                    }
+                    catch (Exception ex) 
+                    when (!(ex.InnerException is CircularDependencyException))
+                    {
+                        return null;
+                    }
 
                 case ResolveDelegate<BuilderContext> resolver:
                     return resolver(ref context);
diff --git a/src/Processors/Abstracts/MemberProcessor.cs b/src/Processors/Abstracts/MemberProcessor.cs
@@ -263,7 +263,7 @@ public TPolicyInterface GetPolicy<TPolicyInterface>(IPolicySet registration)
         #endregion
 
 
-        #region Parameter Resolver Factories
+        #region Attribute Resolver Factories
 
         protected virtual ResolveDelegate<BuilderContext> DependencyResolverFactory(Attribute attribute, object info, object value = null)
         {
@@ -276,8 +276,15 @@ protected virtual ResolveDelegate<BuilderContext> OptionalDependencyResolverFact
             var type = MemberType((TMemberInfo)info);
             return (ref BuilderContext context) =>
             {
-                try { return context.Resolve(type, ((DependencyResolutionAttribute)attribute).Name); }
-                catch { return value; }
+                try
+                {
+                    return context.Resolve(type, ((DependencyResolutionAttribute)attribute).Name);
+                }
+                catch (Exception ex) 
+                when (!(ex.InnerException is CircularDependencyException))
+                {
+                    return value;
+                }
             };
         }
 
diff --git a/src/Processors/Parameters/ParametersProcessor.cs b/src/Processors/Parameters/ParametersProcessor.cs
@@ -3,6 +3,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using Unity.Builder;
+using Unity.Exceptions;
 using Unity.Policy;
 using Unity.Resolution;
 
@@ -201,7 +202,8 @@ protected override ResolveDelegate<BuilderContext> OptionalDependencyResolverFac
                 {
                     return context.Resolve(((ParameterInfo)info).ParameterType, ((DependencyResolutionAttribute)attribute).Name);
                 }
-                catch
+                catch (Exception ex) 
+                when (!(ex.InnerException is CircularDependencyException))
                 {
                     return value;
                 }
diff --git a/src/UnityContainer.IUnityContainer.cs b/src/UnityContainer.IUnityContainer.cs
@@ -244,6 +244,7 @@ object IUnityContainer.Resolve(Type type, string name, params ResolverOverride[]
                 RegistrationType = type,
                 Name = name,
                 ExecutePlan = ContextExecutePlan,
+                ResolvePlan = ContextResolvePlan,
                 Type = registration is ContainerRegistration containerRegistration
                                      ? containerRegistration.Type : type,
             };
@@ -276,6 +277,7 @@ object IUnityContainer.BuildUp(Type type, object existing, string name, params R
                 RegistrationType = type,
                 Name = name,
                 ExecutePlan = ContextExecutePlan,
+                ResolvePlan = ContextResolvePlan,
                 Type = registration is ContainerRegistration containerRegistration
                                      ? containerRegistration.Type : type
             };
diff --git a/src/UnityContainer.Implementation.cs b/src/UnityContainer.Implementation.cs
@@ -160,7 +160,8 @@ private UnityContainer(UnityContainer parent)
         internal static void SetDiagnosticPolicies(UnityContainer container)
         {
             // Default policies
-            container.ContextExecutePlan = UnityContainer.ContextValidatingPlan;
+            container.ContextExecutePlan = UnityContainer.ContextValidatingExecutePlan;
+            container.ContextResolvePlan = UnityContainer.ContextValidatingResolvePlan;
             container.ExecutePlan = container.ExecuteValidatingPlan;
             container.Defaults = new InternalRegistration(typeof(BuilderContext.ExecutePlanDelegate), container.ContextExecutePlan);
             if (null != container._registrations) container.Set(null, null, container.Defaults);
diff --git a/src/UnityContainer.Resolution.cs b/src/UnityContainer.Resolution.cs
@@ -274,7 +274,6 @@ private ResolveDelegate<BuilderContext> ResolvingFactory(ref BuilderContext cont
                 return context.Existing;
             };
 
-
         private object ExecuteValidatingPlan(ref BuilderContext context)
         {
             var i = -1;
@@ -363,6 +362,11 @@ string CreateErrorMessage(object value)
             }
         }
 
+        #endregion
+
+
+        #region BuilderContext
+
         internal BuilderContext.ExecutePlanDelegate ContextExecutePlan { get; set; } =
             (BuilderStrategy[] chain, ref BuilderContext context) =>
             {
@@ -389,7 +393,7 @@ string CreateErrorMessage(object value)
                 return context.Existing;
             };
 
-        internal static object ContextValidatingPlan(BuilderStrategy[] chain, ref BuilderContext context)
+        internal static object ContextValidatingExecutePlan(BuilderStrategy[] chain, ref BuilderContext context)
         {
             var i = -1;
 #if !NET40
@@ -430,20 +434,64 @@ object GetPerResolveValue(IntPtr parent, Type registrationType, string name)
 
                 unsafe
                 {
-                    var c = Unsafe.AsRef<BuilderContext>(parent.ToPointer());
-                    if (registrationType != c.RegistrationType || name != c.Name)
-                        return GetPerResolveValue(c.Parent, registrationType, name);
+                    var parentRef = Unsafe.AsRef<BuilderContext>(parent.ToPointer());
+                    if (registrationType != parentRef.RegistrationType || name != parentRef.Name)
+                        return GetPerResolveValue(parentRef.Parent, registrationType, name);
 
-                    var lifetimeManager = (LifetimeManager)c.Get(typeof(LifetimeManager));
+                    var lifetimeManager = (LifetimeManager)parentRef.Get(typeof(LifetimeManager));
                     var result = lifetimeManager?.GetValue();
                     if (null != result) return result;
 
-                    throw new InvalidOperationException($"Circular reference for type: {c.Type}");
+                    throw new InvalidOperationException($"Circular reference for Type: {parentRef.Type}, Name: {parentRef.Name}",
+                            new CircularDependencyException());
                 }
             }
 #endif
         }
 
+        internal BuilderContext.ResolvePlanDelegate ContextResolvePlan { get; set; } =
+            (ref BuilderContext context, ResolveDelegate<BuilderContext> resolver) => resolver(ref context);
+
+        internal static object ContextValidatingResolvePlan(ref BuilderContext thisContext, ResolveDelegate<BuilderContext> resolver)
+        {
+            if (null == resolver) throw new ArgumentNullException(nameof(resolver));
+
+#if NET40
+            return resolver(ref thisContext);
+#else
+            unsafe
+            {
+                var parent = thisContext.Parent;
+                while(IntPtr.Zero != parent)
+                {
+                    var parentRef = Unsafe.AsRef<BuilderContext>(parent.ToPointer());
+                    if (thisContext.RegistrationType == parentRef.RegistrationType && thisContext.Name == parentRef.Name)
+                        throw new InvalidOperationException($"Circular reference for Type: {thisContext.Type}, Name: {thisContext.Name}",
+                            new CircularDependencyException());
+
+                    parent = parentRef.Parent;
+                }
+
+                var context = new BuilderContext
+                {
+                    Lifetime = thisContext.Lifetime,
+                    Registration = thisContext.Registration,
+                    RegistrationType = thisContext.Type,
+                    Name = thisContext.Name,
+                    Type = thisContext.Type,
+                    ExecutePlan = thisContext.ExecutePlan,
+                    ResolvePlan = thisContext.ResolvePlan,
+                    List = thisContext.List,
+                    Overrides = thisContext.Overrides,
+                    DeclaringType = thisContext.Type,
+                    Parent = new IntPtr(Unsafe.AsPointer(ref thisContext))
+                };
+
+                return resolver(ref context);
+            }
+#endif
+        }
+
         #endregion
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Reflection;`
`4`	`4`	`using System.Runtime.CompilerServices;`
`5`	`5`	`using System.Security;`
	`6`	`+using Unity.Exceptions;`
`6`	`7`	`using Unity.Lifetime;`
`7`	`8`	`using Unity.Policy;`
`8`	`9`	`using Unity.Registration;`
`@@ -24,6 +25,7 @@ public struct BuilderContext : IResolveContext`
`24`	`25`	`public IPolicyList List;`
`25`	`26`
`26`	`27`	`public delegate object ExecutePlanDelegate(BuilderStrategy[] chain, ref BuilderContext context);`
	`28`	`+ public delegate object ResolvePlanDelegate(ref BuilderContext context, ResolveDelegate<BuilderContext> resolver);`
`27`	`29`
`28`	`30`	`#endregion`
`29`	`31`
`@@ -57,7 +59,7 @@ public object Resolve(Type type, string name)`
`57`	`59`	`{`
`58`	`60`	`var context = this;`
`59`	`61`
`60`		`- return resolverPolicy.Resolve(ref context);`
	`62`	`+ return ResolvePlan(ref context, resolverPolicy.Resolve);`
`61`	`63`	`}`
`62`	`64`	`}`
`63`	`65`	`}`
`@@ -127,6 +129,8 @@ public void Clear(Type type, string name, Type policyInterface)`
`127`	`129`	`#endif`
`128`	`130`	`public ExecutePlanDelegate ExecutePlan;`
`129`	`131`
	`132`	`+ public ResolvePlanDelegate ResolvePlan;`
	`133`	`+`
`130`	`134`	`#endregion`
`131`	`135`
`132`	`136`
`@@ -145,6 +149,7 @@ public object Resolve(Type type, string name, InternalRegistration registration)`
`145`	`149`	`Name = name,`
`146`	`150`	`Type = registration is ContainerRegistration containerRegistration ? containerRegistration.Type : type,`
`147`	`151`	`ExecutePlan = ExecutePlan,`
	`152`	`+ ResolvePlan = ResolvePlan,`
`148`	`153`	`List = List,`
`149`	`154`	`Overrides = Overrides,`
`150`	`155`	`DeclaringType = Type,`
`@@ -175,14 +180,14 @@ public object Resolve(ParameterInfo parameter, object value)`
`175`	`180`	`// Check if itself is a value`
`176`	`181`	`if (resolverOverride is IResolve resolverPolicy)`
`177`	`182`	`{`
`178`		`- return resolverPolicy.Resolve(ref context);`
	`183`	`+ return ResolvePlan(ref context, resolverPolicy.Resolve);`
`179`	`184`	`}`
`180`	`185`
`181`	`186`	`// Try to create value`
`182`	`187`	`var resolveDelegate = resolverOverride.GetResolver<BuilderContext>(parameter.ParameterType);`
`183`	`188`	`if (null != resolveDelegate)`
`184`	`189`	`{`
`185`		`- return resolveDelegate(ref context);`
	`190`	`+ return ResolvePlan(ref context, resolveDelegate);`
`186`	`191`	`}`
`187`	`192`	`}`
`188`	`193`	`}`
`@@ -220,14 +225,14 @@ public object Resolve(PropertyInfo property, object value)`
`220`	`225`	`// Check if itself is a value`
`221`	`226`	`if (resolverOverride is IResolve resolverPolicy)`
`222`	`227`	`{`
`223`		`- return resolverPolicy.Resolve(ref context);`
	`228`	`+ return ResolvePlan(ref context, resolverPolicy.Resolve);`
`224`	`229`	`}`
`225`	`230`
`226`	`231`	`// Try to create value`
`227`	`232`	`var resolveDelegate = resolverOverride.GetResolver<BuilderContext>(property.PropertyType);`
`228`	`233`	`if (null != resolveDelegate)`
`229`	`234`	`{`
`230`		`- return resolveDelegate(ref context);`
	`235`	`+ return ResolvePlan(ref context, resolveDelegate);`
`231`	`236`	`}`
`232`	`237`	`}`
`233`	`238`	`}`
`@@ -240,8 +245,15 @@ public object Resolve(PropertyInfo property, object value)`
`240`	`245`	`return Resolve(property.PropertyType, dependencyAttribute.Name);`
`241`	`246`
`242`	`247`	`case OptionalDependencyAttribute optionalAttribute:`
`243`		`- try { return Resolve(property.PropertyType, optionalAttribute.Name); }`
`244`		`- catch { return null; }`
	`248`	`+ try`
	`249`	`+ {`
	`250`	`+ return Resolve(property.PropertyType, optionalAttribute.Name);`
	`251`	`+ }`
	`252`	`+ catch (Exception ex)`
	`253`	`+ when (!(ex.InnerException is CircularDependencyException))`
	`254`	`+ {`
	`255`	`+ return null;`
	`256`	`+ }`
`245`	`257`
`246`	`258`	`case ResolveDelegate<BuilderContext> resolver:`
`247`	`259`	`return resolver(ref context);`
`@@ -268,14 +280,14 @@ public object Resolve(FieldInfo field, object value)`
`268`	`280`	`// Check if itself is a value`
`269`	`281`	`if (resolverOverride is IResolve resolverPolicy)`
`270`	`282`	`{`
`271`		`- return resolverPolicy.Resolve(ref context);`
	`283`	`+ return ResolvePlan(ref context, resolverPolicy.Resolve);`
`272`	`284`	`}`
`273`	`285`
`274`	`286`	`// Try to create value`
`275`	`287`	`var resolveDelegate = resolverOverride.GetResolver<BuilderContext>(field.FieldType);`
`276`	`288`	`if (null != resolveDelegate)`
`277`	`289`	`{`
`278`		`- return resolveDelegate(ref context);`
	`290`	`+ return ResolvePlan(ref context, resolveDelegate);`
`279`	`291`	`}`
`280`	`292`	`}`
`281`	`293`	`}`
`@@ -288,8 +300,15 @@ public object Resolve(FieldInfo field, object value)`
`288`	`300`	`return Resolve(field.FieldType, dependencyAttribute.Name);`
`289`	`301`
`290`	`302`	`case OptionalDependencyAttribute optionalAttribute:`
`291`		`- try { return Resolve(field.FieldType, optionalAttribute.Name); }`
`292`		`- catch { return null; }`
	`303`	`+ try`
	`304`	`+ {`
	`305`	`+ return Resolve(field.FieldType, optionalAttribute.Name);`
	`306`	`+ }`
	`307`	`+ catch (Exception ex)`
	`308`	`+ when (!(ex.InnerException is CircularDependencyException))`
	`309`	`+ {`
	`310`	`+ return null;`
	`311`	`+ }`
`293`	`312`
`294`	`313`	`case ResolveDelegate<BuilderContext> resolver:`
`295`	`314`	`return resolver(ref context);`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Linq.Expressions;`
`4`	`4`	`using System.Reflection;`
`5`	`5`	`using Unity.Builder;`
	`6`	`+using Unity.Exceptions;`
`6`	`7`	`using Unity.Policy;`
`7`	`8`	`using Unity.Resolution;`
`8`	`9`
`@@ -201,7 +202,8 @@ protected override ResolveDelegate<BuilderContext> OptionalDependencyResolverFac`
`201`	`202`	`{`
`202`	`203`	`return context.Resolve(((ParameterInfo)info).ParameterType, ((DependencyResolutionAttribute)attribute).Name);`
`203`	`204`	`}`
`204`		`- catch`
	`205`	`+ catch (Exception ex)`
	`206`	`+ when (!(ex.InnerException is CircularDependencyException))`
`205`	`207`	`{`
`206`	`208`	`return value;`
`207`	`209`	`}`