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

ENikS · ENikS · commit 123d4bccb10b · 2019-04-11T23:09:26.000-04:00
diff --git a/src/Processors/Abstracts/MemberExpression.cs b/src/Processors/Abstracts/MemberExpression.cs
@@ -25,7 +25,7 @@ protected virtual IEnumerable<Expression> ExpressionsFromSelection(Type type, IE
                             var attribute = GetCustomAttribute(info, node.Type);
                             if (null == attribute) continue;
 
-                            value = null == node.Factory ? (object)attribute : node.Factory(attribute, info);
+                            value = null == node.Factory ? (object)attribute : node.Factory(attribute, info, null);
                             break;
                         }
 
diff --git a/src/Processors/Abstracts/MemberProcessor.cs b/src/Processors/Abstracts/MemberProcessor.cs
@@ -77,8 +77,6 @@ public abstract class MemberProcessor
         #endregion
     }
 
-    public delegate ResolveDelegate<BuilderContext> AttributeResolverFactory(Attribute attribute, object info, object value = null);
-
     public abstract partial class MemberProcessor<TMemberInfo, TData> : MemberProcessor,
                                                                         ISelect<TMemberInfo>
                                                     where TMemberInfo : MemberInfo
@@ -98,8 +96,8 @@ protected MemberProcessor(IPolicySet policySet)
             // Add Unity attribute factories
             AttributeFactories = new[]
             {
-                new AttributeFactoryNode(typeof(DependencyAttribute),         DependencyResolverFactory),
-                new AttributeFactoryNode(typeof(OptionalDependencyAttribute), OptionalDependencyResolverFactory),
+                new AttributeFactoryNode(typeof(DependencyAttribute),         (a)=>((DependencyResolutionAttribute)a).Name, DependencyResolverFactory),
+                new AttributeFactoryNode(typeof(OptionalDependencyAttribute), (a)=>((DependencyResolutionAttribute)a).Name, OptionalDependencyResolverFactory),
             };
 
             _policySet = policySet;
@@ -110,9 +108,9 @@ protected MemberProcessor(IPolicySet policySet, Type attribute)
             // Add Unity attribute factories
             AttributeFactories = new[]
             {
-                new AttributeFactoryNode(attribute,                           null),
-                new AttributeFactoryNode(typeof(DependencyAttribute),         DependencyResolverFactory),
-                new AttributeFactoryNode(typeof(OptionalDependencyAttribute), OptionalDependencyResolverFactory),
+                new AttributeFactoryNode(attribute, (a)=>(a as DependencyResolutionAttribute)?.Name, null),
+                new AttributeFactoryNode(typeof(DependencyAttribute),         (a)=>((DependencyResolutionAttribute)a).Name, DependencyResolverFactory),
+                new AttributeFactoryNode(typeof(OptionalDependencyAttribute), (a)=>((DependencyResolutionAttribute)a).Name, OptionalDependencyResolverFactory),
             };
             _policySet = policySet;
         }
@@ -122,7 +120,7 @@ protected MemberProcessor(IPolicySet policySet, Type attribute)
 
         #region Public Methods
 
-        public void Add(Type type, AttributeResolverFactory resolutionFactory)
+        public void Add(Type type, Func<Attribute, string> getName, Func<Attribute, object, object, ResolveDelegate<BuilderContext>> resolutionFactory)
         {
             for (var i = 0; i < AttributeFactories.Length; i++)
             {
@@ -134,7 +132,7 @@ public void Add(Type type, AttributeResolverFactory resolutionFactory)
 
             var factories = new AttributeFactoryNode[AttributeFactories.Length + 1];
             Array.Copy(AttributeFactories, factories, AttributeFactories.Length);
-            factories[AttributeFactories.Length] = new AttributeFactoryNode(type, resolutionFactory);
+            factories[AttributeFactories.Length] = new AttributeFactoryNode(type, getName, resolutionFactory);
             AttributeFactories = factories;
         }
 
@@ -296,11 +294,13 @@ protected virtual ResolveDelegate<BuilderContext> OptionalDependencyResolverFact
         public struct AttributeFactoryNode
         {
             public readonly Type Type;
-            public AttributeResolverFactory Factory;
+            public Func<Attribute, object, object, ResolveDelegate<BuilderContext>> Factory;
+            public Func<Attribute, string> Name;
 
-            public AttributeFactoryNode(Type type, AttributeResolverFactory factory)
+            public AttributeFactoryNode(Type type, Func<Attribute, string> getName, Func<Attribute, object, object, ResolveDelegate<BuilderContext>> factory)
             {
                 Type = type;
+                Name = getName;
                 Factory = factory;
             }
         }
diff --git a/src/Processors/Abstracts/MemberResolution.cs b/src/Processors/Abstracts/MemberResolution.cs
@@ -26,7 +26,7 @@ protected virtual IEnumerable<ResolveDelegate<BuilderContext>> ResolversFromSele
                             var attribute = GetCustomAttribute(info, node.Type);
                             if (null == attribute) continue;
 
-                            value = null == node.Factory ? (object)attribute : node.Factory(attribute, info);
+                            value = null == node.Factory ? (object)attribute : node.Factory(attribute, info, null);
                             break;
                         }
                         yield return GetResolverDelegate(info, value);
diff --git a/src/Processors/Constructor/ConstructorDiagnostic.cs b/src/Processors/Constructor/ConstructorDiagnostic.cs
@@ -68,8 +68,8 @@ public class ConstructorDiagnostic : ConstructorProcessor
 
         #region Constructors
 
-        public ConstructorDiagnostic(IPolicySet policySet, Func<Type, bool> isTypeRegistered) 
-            : base(policySet, isTypeRegistered)
+        public ConstructorDiagnostic(IPolicySet policySet, UnityContainer container) 
+            : base(policySet, container)
         {
         }
 
@@ -177,9 +177,9 @@ protected override object SmartSelector(Type type, ConstructorInfo[] constructor
                 parametersCount = parameters.Length;
 
 #if NET40
-                if (parameters.All(p => (null != p.DefaultValue && !(p.DefaultValue is DBNull)) || CanResolve(p.ParameterType)))
+                if (parameters.All(p => (null != p.DefaultValue && !(p.DefaultValue is DBNull)) || CanResolve(p)))
 #else
-                if (parameters.All(p => p.HasDefaultValue || CanResolve(p.ParameterType)))
+                if (parameters.All(p => p.HasDefaultValue || CanResolve(p)))
 #endif
                 {
                     if (bestCtor == null)
diff --git a/src/Processors/Constructor/ConstructorProcessor.cs b/src/Processors/Constructor/ConstructorProcessor.cs
@@ -12,20 +12,11 @@ namespace Unity.Processors
 {
     public partial class ConstructorProcessor : ParametersProcessor<ConstructorInfo>
     {
-        #region Fields
-
-        private readonly Func<Type, bool> _isTypeRegistered;
-        private static readonly TypeInfo DelegateType = typeof(Delegate).GetTypeInfo();
-
-        #endregion
-
-
         #region Constructors
 
-        public ConstructorProcessor(IPolicySet policySet, Func<Type, bool> isTypeRegistered)
-            : base(policySet, typeof(InjectionConstructorAttribute))
+        public ConstructorProcessor(IPolicySet policySet, UnityContainer container)
+            : base(policySet, typeof(InjectionConstructorAttribute), container)
         {
-            _isTypeRegistered = isTypeRegistered;
             SelectMethod = SmartSelector;
         }
 
@@ -148,9 +139,9 @@ protected virtual object SmartSelector(Type type, ConstructorInfo[] constructors
             {
                 var parameters = ctorInfo.GetParameters();
 #if NET40
-                if (parameters.All(p => (null != p.DefaultValue && !(p.DefaultValue is DBNull)) || CanResolve(p.ParameterType)))
+                if (parameters.All(p => (null != p.DefaultValue && !(p.DefaultValue is DBNull)) || CanResolve(p)))
 #else
-                if (parameters.All(p => p.HasDefaultValue || CanResolve(p.ParameterType)))
+                if (parameters.All(p => p.HasDefaultValue || CanResolve(p)))
 #endif
                 {
                     return ctorInfo;
@@ -161,55 +152,6 @@ protected virtual object SmartSelector(Type type, ConstructorInfo[] constructors
                 $"Failed to select a constructor for {type.FullName}", new InvalidRegistrationException());
         }
 
-        protected bool CanResolve(Type type)
-        {
-#if NETSTANDARD1_0 || NETCOREAPP1_0
-            var info = type.GetTypeInfo();
-#else
-            var info = type;
-#endif
-            if (info.IsClass)
-            {
-                // Array could be either registered or Type can be resolved
-                if (type.IsArray)
-                {
-                    return _isTypeRegistered(type) || CanResolve(type.GetElementType());
-                }
-
-                // Type must be registered if:
-                // - String
-                // - Enumeration
-                // - Primitive
-                // - Abstract
-                // - Interface
-                // - No accessible constructor
-                if (DelegateType.IsAssignableFrom(info) ||
-                    typeof(string) == type || info.IsEnum || info.IsPrimitive || info.IsAbstract
-#if NETSTANDARD1_0 || NETCOREAPP1_0
-                    || !info.DeclaredConstructors.Any(c => !c.IsFamily && !c.IsPrivate))
-#else
-                    || !type.GetTypeInfo().DeclaredConstructors.Any(c => !c.IsFamily && !c.IsPrivate))
-#endif
-                    return _isTypeRegistered(type);
-
-                return true;
-            }
-
-            // Can resolve if IEnumerable or factory is registered
-            if (info.IsGenericType)
-            {
-                var genericType = type.GetGenericTypeDefinition();
-
-                if (genericType == typeof(IEnumerable<>) || _isTypeRegistered(genericType))
-                {
-                    return true;
-                }
-            }
-
-            // Check if Type is registered
-            return _isTypeRegistered(type);
-        }
-
         #endregion
     }
 }
diff --git a/src/Processors/Methods/MethodDiagnostic.cs b/src/Processors/Methods/MethodDiagnostic.cs
@@ -1,11 +1,9 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using Unity.Builder;
-using Unity.Exceptions;
 using Unity.Injection;
 using Unity.Policy;
 using Unity.Registration;
@@ -17,8 +15,8 @@ public class MethodDiagnostic : MethodProcessor
     {
         #region Constructors
 
-        public MethodDiagnostic(IPolicySet policySet) 
-            : base(policySet)
+        public MethodDiagnostic(IPolicySet policySet, UnityContainer container) 
+            : base(policySet, container)
         {
         }
 
diff --git a/src/Processors/Methods/MethodProcessor.cs b/src/Processors/Methods/MethodProcessor.cs
@@ -13,8 +13,8 @@ public class MethodProcessor : ParametersProcessor<MethodInfo>
     {
         #region Constructors
 
-        public MethodProcessor(IPolicySet policySet)
-            : base(policySet, typeof(InjectionMethodAttribute))
+        public MethodProcessor(IPolicySet policySet, UnityContainer container)
+            : base(policySet, typeof(InjectionMethodAttribute), container)
         {
         }
 
diff --git a/src/Processors/Parameters/ParametersProcessor.cs b/src/Processors/Parameters/ParametersProcessor.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using Unity.Builder;
@@ -12,11 +13,21 @@ namespace Unity.Processors
     public abstract partial class ParametersProcessor<TMemberInfo> : MemberProcessor<TMemberInfo, object[]>
                                                  where TMemberInfo : MethodBase
     {
+        #region Fields
+
+        protected readonly UnityContainer Container;
+        private static readonly TypeInfo DelegateType = typeof(Delegate).GetTypeInfo();
+
+        #endregion
+
+
+
         #region Constructors
 
-        protected ParametersProcessor(IPolicySet policySet, Type attribute)
+        protected ParametersProcessor(IPolicySet policySet, Type attribute, UnityContainer container)
             : base(policySet, attribute)
         {
+            Container = container;
         }
 
         #endregion
@@ -184,6 +195,71 @@ private object FromAttribute(ParameterInfo info)
             return info;
         }
 
+        protected bool CanResolve(ParameterInfo info)
+        {
+            foreach (var node in AttributeFactories)
+            {
+                if (null == node.Factory) continue;
+                var attribute = info.GetCustomAttribute(node.Type);
+                if (null == attribute) continue;
+
+                // If found match, use provided factory to create expression
+                return CanResolve(info.ParameterType, node.Name(attribute));
+            }
+
+            return CanResolve(info.ParameterType, null);
+        }
+
+        protected bool CanResolve(Type type, string name)
+        {
+#if NETSTANDARD1_0 || NETCOREAPP1_0
+            var info = type.GetTypeInfo();
+#else
+            var info = type;
+#endif
+            if (info.IsClass)
+            {
+                // Array could be either registered or Type can be resolved
+                if (type.IsArray)
+                {
+                    return Container._isExplicitlyRegistered(type, name) || CanResolve(type.GetElementType(), name);
+                }
+
+                // Type must be registered if:
+                // - String
+                // - Enumeration
+                // - Primitive
+                // - Abstract
+                // - Interface
+                // - No accessible constructor
+                if (DelegateType.IsAssignableFrom(info) ||
+                    typeof(string) == type || info.IsEnum || info.IsPrimitive || info.IsAbstract
+#if NETSTANDARD1_0 || NETCOREAPP1_0
+                    || !info.DeclaredConstructors.Any(c => !c.IsFamily && !c.IsPrivate))
+#else
+                    || !type.GetTypeInfo().DeclaredConstructors.Any(c => !c.IsFamily && !c.IsPrivate))
+#endif
+                    return Container._isExplicitlyRegistered(type, name);
+
+                return true;
+            }
+
+            // Can resolve if IEnumerable or factory is registered
+            if (info.IsGenericType)
+            {
+                var genericType = type.GetGenericTypeDefinition();
+
+                if (genericType == typeof(IEnumerable<>) || Container._isExplicitlyRegistered(genericType, name))
+                {
+                    return true;
+                }
+            }
+
+            // Check if Type is registered
+            return Container._isExplicitlyRegistered(type, name);
+        }
+
+
         #endregion
 
 
diff --git a/src/UnityContainer.Implementation.cs b/src/UnityContainer.Implementation.cs
@@ -70,7 +70,7 @@ public partial class UnityContainer
         internal ClearPolicyDelegate ClearPolicy;
 
         [DebuggerBrowsable(DebuggerBrowsableState.Never)] private Func<Type, string, IPolicySet> _get;
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)] private Func<Type, string, bool> _isExplicitlyRegistered;
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)] internal Func<Type, string, bool> _isExplicitlyRegistered;
         [DebuggerBrowsable(DebuggerBrowsableState.Never)] private Func<Type, string, Type, IPolicySet> _getGenericRegistration;
         [DebuggerBrowsable(DebuggerBrowsableState.Never)] internal Func<Type, bool> IsTypeExplicitlyRegistered;
 
@@ -131,9 +131,9 @@ private UnityContainer(UnityContainer parent)
 
             // Processors
             var fieldsProcessor = new FieldProcessor(container.Defaults);
-            var methodsProcessor = new MethodProcessor(container.Defaults);
+            var methodsProcessor = new MethodProcessor(container.Defaults, container);
             var propertiesProcessor = new PropertyProcessor(container.Defaults);
-            var constructorProcessor = new ConstructorProcessor(container.Defaults, container.IsTypeTypeExplicitlyRegisteredRecurcive);
+            var constructorProcessor = new ConstructorProcessor(container.Defaults, container);
 
             // Processors chain
             container._processors = new StagedStrategyChain<MemberProcessor, BuilderStage>
@@ -168,9 +168,9 @@ internal static void SetDiagnosticPolicies(UnityContainer container)
 
             // Processors
             var fieldsProcessor = new FieldDiagnostic(container.Defaults);
-            var methodsProcessor = new MethodDiagnostic(container.Defaults);
+            var methodsProcessor = new MethodDiagnostic(container.Defaults, container);
             var propertiesProcessor = new PropertyDiagnostic(container.Defaults);
-            var constructorProcessor = new ConstructorDiagnostic(container.Defaults, container.IsTypeTypeExplicitlyRegisteredRecurcive);
+            var constructorProcessor = new ConstructorDiagnostic(container.Defaults, container);
 
             // Processors chain
             container._processors = new StagedStrategyChain<MemberProcessor, BuilderStage>
diff --git a/src/UnityContainer.Registration.cs b/src/UnityContainer.Registration.cs

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ protected virtual IEnumerable<Expression> ExpressionsFromSelection(Type type, IE`
`25`	`25`	`var attribute = GetCustomAttribute(info, node.Type);`
`26`	`26`	`if (null == attribute) continue;`
`27`	`27`
`28`		`- value = null == node.Factory ? (object)attribute : node.Factory(attribute, info);`
	`28`	`+ value = null == node.Factory ? (object)attribute : node.Factory(attribute, info, null);`
`29`	`29`	`break;`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -77,8 +77,6 @@ public abstract class MemberProcessor`
`77`	`77`	`#endregion`
`78`	`78`	`}`
`79`	`79`
`80`		`- public delegate ResolveDelegate<BuilderContext> AttributeResolverFactory(Attribute attribute, object info, object value = null);`
`81`		`-`
`82`	`80`	`public abstract partial class MemberProcessor<TMemberInfo, TData> : MemberProcessor,`
`83`	`81`	`ISelect<TMemberInfo>`
`84`	`82`	`where TMemberInfo : MemberInfo`
`@@ -98,8 +96,8 @@ protected MemberProcessor(IPolicySet policySet)`
`98`	`96`	`// Add Unity attribute factories`
`99`	`97`	`AttributeFactories = new[]`
`100`	`98`	`{`
`101`		`- new AttributeFactoryNode(typeof(DependencyAttribute), DependencyResolverFactory),`
`102`		`- new AttributeFactoryNode(typeof(OptionalDependencyAttribute), OptionalDependencyResolverFactory),`
	`99`	`+ new AttributeFactoryNode(typeof(DependencyAttribute), (a)=>((DependencyResolutionAttribute)a).Name, DependencyResolverFactory),`
	`100`	`+ new AttributeFactoryNode(typeof(OptionalDependencyAttribute), (a)=>((DependencyResolutionAttribute)a).Name, OptionalDependencyResolverFactory),`
`103`	`101`	`};`
`104`	`102`
`105`	`103`	`_policySet = policySet;`
`@@ -110,9 +108,9 @@ protected MemberProcessor(IPolicySet policySet, Type attribute)`
`110`	`108`	`// Add Unity attribute factories`
`111`	`109`	`AttributeFactories = new[]`
`112`	`110`	`{`
`113`		`- new AttributeFactoryNode(attribute, null),`
`114`		`- new AttributeFactoryNode(typeof(DependencyAttribute), DependencyResolverFactory),`
`115`		`- new AttributeFactoryNode(typeof(OptionalDependencyAttribute), OptionalDependencyResolverFactory),`
	`111`	`+ new AttributeFactoryNode(attribute, (a)=>(a as DependencyResolutionAttribute)?.Name, null),`
	`112`	`+ new AttributeFactoryNode(typeof(DependencyAttribute), (a)=>((DependencyResolutionAttribute)a).Name, DependencyResolverFactory),`
	`113`	`+ new AttributeFactoryNode(typeof(OptionalDependencyAttribute), (a)=>((DependencyResolutionAttribute)a).Name, OptionalDependencyResolverFactory),`
`116`	`114`	`};`
`117`	`115`	`_policySet = policySet;`
`118`	`116`	`}`
`@@ -122,7 +120,7 @@ protected MemberProcessor(IPolicySet policySet, Type attribute)`
`122`	`120`
`123`	`121`	`#region Public Methods`
`124`	`122`
`125`		`- public void Add(Type type, AttributeResolverFactory resolutionFactory)`
	`123`	`+ public void Add(Type type, Func<Attribute, string> getName, Func<Attribute, object, object, ResolveDelegate<BuilderContext>> resolutionFactory)`
`126`	`124`	`{`
`127`	`125`	`for (var i = 0; i < AttributeFactories.Length; i++)`
`128`	`126`	`{`
`@@ -134,7 +132,7 @@ public void Add(Type type, AttributeResolverFactory resolutionFactory)`
`134`	`132`
`135`	`133`	`var factories = new AttributeFactoryNode[AttributeFactories.Length + 1];`
`136`	`134`	`Array.Copy(AttributeFactories, factories, AttributeFactories.Length);`
`137`		`- factories[AttributeFactories.Length] = new AttributeFactoryNode(type, resolutionFactory);`
	`135`	`+ factories[AttributeFactories.Length] = new AttributeFactoryNode(type, getName, resolutionFactory);`
`138`	`136`	`AttributeFactories = factories;`
`139`	`137`	`}`
`140`	`138`
`@@ -296,11 +294,13 @@ protected virtual ResolveDelegate<BuilderContext> OptionalDependencyResolverFact`
`296`	`294`	`public struct AttributeFactoryNode`
`297`	`295`	`{`
`298`	`296`	`public readonly Type Type;`
`299`		`- public AttributeResolverFactory Factory;`
	`297`	`+ public Func<Attribute, object, object, ResolveDelegate<BuilderContext>> Factory;`
	`298`	`+ public Func<Attribute, string> Name;`
`300`	`299`
`301`		`- public AttributeFactoryNode(Type type, AttributeResolverFactory factory)`
	`300`	`+ public AttributeFactoryNode(Type type, Func<Attribute, string> getName, Func<Attribute, object, object, ResolveDelegate<BuilderContext>> factory)`
`302`	`301`	`{`
`303`	`302`	`Type = type;`
	`303`	`+ Name = getName;`
`304`	`304`	`Factory = factory;`
`305`	`305`	`}`
`306`	`306`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ protected virtual IEnumerable<ResolveDelegate<BuilderContext>> ResolversFromSele`
`26`	`26`	`var attribute = GetCustomAttribute(info, node.Type);`
`27`	`27`	`if (null == attribute) continue;`
`28`	`28`
`29`		`- value = null == node.Factory ? (object)attribute : node.Factory(attribute, info);`
	`29`	`+ value = null == node.Factory ? (object)attribute : node.Factory(attribute, info, null);`
`30`	`30`	`break;`
`31`	`31`	`}`
`32`	`32`	`yield return GetResolverDelegate(info, value);`
Original file line number	Diff line number	Diff line change
`@@ -68,8 +68,8 @@ public class ConstructorDiagnostic : ConstructorProcessor`
`68`	`68`
`69`	`69`	`#region Constructors`
`70`	`70`
`71`		`- public ConstructorDiagnostic(IPolicySet policySet, Func<Type, bool> isTypeRegistered)`
`72`		`- : base(policySet, isTypeRegistered)`
	`71`	`+ public ConstructorDiagnostic(IPolicySet policySet, UnityContainer container)`
	`72`	`+ : base(policySet, container)`
`73`	`73`	`{`
`74`	`74`	`}`
`75`	`75`
`@@ -177,9 +177,9 @@ protected override object SmartSelector(Type type, ConstructorInfo[] constructor`
`177`	`177`	`parametersCount = parameters.Length;`
`178`	`178`
`179`	`179`	`#if NET40`
`180`		`- if (parameters.All(p => (null != p.DefaultValue && !(p.DefaultValue is DBNull)) \|\| CanResolve(p.ParameterType)))`
	`180`	`+ if (parameters.All(p => (null != p.DefaultValue && !(p.DefaultValue is DBNull)) \|\| CanResolve(p)))`
`181`	`181`	`#else`
`182`		`- if (parameters.All(p => p.HasDefaultValue \|\| CanResolve(p.ParameterType)))`
	`182`	`+ if (parameters.All(p => p.HasDefaultValue \|\| CanResolve(p)))`
`183`	`183`	`#endif`
`184`	`184`	`{`
`185`	`185`	`if (bestCtor == null)`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ public class MethodProcessor : ParametersProcessor<MethodInfo>`
`13`	`13`	`{`
`14`	`14`	`#region Constructors`
`15`	`15`
`16`		`- public MethodProcessor(IPolicySet policySet)`
`17`		`- : base(policySet, typeof(InjectionMethodAttribute))`
	`16`	`+ public MethodProcessor(IPolicySet policySet, UnityContainer container)`
	`17`	`+ : base(policySet, typeof(InjectionMethodAttribute), container)`
`18`	`18`	`{`
`19`	`19`	`}`
`20`	`20`