wip: Defaults

Issue #301

src/BuiltIn/Selection/ArrayTypeSelector.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace Unity.BuiltIn
+{
+    public static class ArrayTypeSelector
+
+    {
+        #region Selection
+
+        public static Type Selector(UnityContainer container, Type argType)
+        {
+            Type? next;
+            Type? type = argType;
+
+            do
+            {
+                if (type.IsGenericType)
+                {
+                    if (container.Scope.Contains(type)) return type!;
+
+                    var definition = type.GetGenericTypeDefinition();
+                    if (container.Scope.Contains(definition)) return definition;
+
+                    next = type.GenericTypeArguments[0]!;
+                    if (container.Scope.Contains(next)) return next;
+                }
+                else if (type.IsArray)
+                {
+                    next = type.GetElementType()!;
+                    if (container.Scope.Contains(next)) return next;
+                }
+                else
+                {
+                    return type!;
+                }
+            }
+            while (null != (type = next));
+
+            return argType;
+        }
+
+        #endregion
+    }
+}

src/Container/Processors/Constructor/Constructor.Selection.cs → src/BuiltIn/Selection/ConstructorSelector.cs

@@ -3,20 +3,13 @@
 using System.Linq;
 using System.Reflection;
 
-namespace Unity.Container
+namespace Unity.BuiltIn
 {
-    public partial class ConstructorProcessor
+    public static class ConstructorSelector
     {
-        #region Fields
-
-        protected Func<UnityContainer, ConstructorInfo[], ConstructorInfo?> Select { get; set; }
-
-        #endregion
-
-
         #region Selection
 
-        public ConstructorInfo? DefaultSelector(UnityContainer container, ConstructorInfo[] constructors)
+        public static ConstructorInfo? Selector(UnityContainer container, ConstructorInfo[] constructors)
         {
             Array.Sort(constructors, SortPredicate);
 
@@ -37,7 +30,7 @@ public partial class ConstructorProcessor
 
         #region Implementation
 
-        protected bool CanResolve(UnityContainer container, ParameterInfo info)
+        private static bool CanResolve(UnityContainer container, ParameterInfo info)
         {
             // TODO: Add support for ImportMany
             var attribute = info.GetCustomAttribute<ImportAttribute>();
@@ -48,7 +41,7 @@ protected bool CanResolve(UnityContainer container, ParameterInfo info)
         }
 
         // Sort Predicate
-        private int SortPredicate(ConstructorInfo x, ConstructorInfo y)
+        private static int SortPredicate(ConstructorInfo x, ConstructorInfo y)
         {
             int match;
 
@@ -61,7 +54,7 @@ private int SortPredicate(ConstructorInfo x, ConstructorInfo y)
             return 0;
         }
 
-        private int RankByComplexity(ParameterInfo[] parameters)
+        private static int RankByComplexity(ParameterInfo[] parameters)
         {
             var sum = 0;
             foreach (var parameter in parameters)

src/BuiltIn/Selection/MembersSelector.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Reflection;
+
+namespace Unity.BuiltIn
+{
+    public static class MembersSelector
+    {
+        #region Default Get Members
+
+        /// <summary>
+        /// Determines constructors selected by default when 
+        /// <see cref="Type.GetConstructors"/> is called
+        /// </summary>
+        public static ConstructorInfo[] GetConstructors(Type type)
+            => type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+
+
+        /// <summary>
+        /// Determines methods selected by default when 
+        /// <see cref="Type.GetMethods"/> is called
+        /// </summary>
+        public static MethodInfo[] GetMethods(Type type)
+            => type.GetMethods(BindingFlags.Public |
+                               BindingFlags.Instance |
+                               BindingFlags.FlattenHierarchy |
+                               BindingFlags.DeclaredOnly);
+
+
+        /// <summary>
+        /// Determines fields selected by default when 
+        /// <see cref="Type.GetFields"/> is called
+        /// </summary>
+        public static FieldInfo[] GetFields(Type type)
+            => type.GetFields(BindingFlags.Public | BindingFlags.Instance);
+
+
+        /// <summary>
+        /// Determines properties selected by default when 
+        /// <see cref="Type.GetProperties"/> is called
+        /// </summary>
+        public static PropertyInfo[] GetProperties(Type type)
+            => type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+        #endregion
+    }
+}

src/Container/Defaults/Defaults.Pipelines.cs

@@ -52,8 +52,8 @@ public ResolveDelegate<PipelineContext> FactoryPipeline
         #region Arrays and Enumerable
 
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        public Func<UnityContainer, Type, Type> GerTargetType
-            => (Func<UnityContainer, Type, Type>)Data[GET_TARGET_TYPE].Value!;
+        public UnitySelector<Type, Type> ArrayTargetType
+            => (UnitySelector<Type, Type>)Data[GET_TARGET_TYPE].Value!;
 
         #endregion
     }

src/Container/Defaults/Defaults.cs

@@ -51,7 +51,7 @@ internal Defaults()
             BUILD_PIPELINE_INSTANCE = Allocate<CategoryInstance, ResolveDelegate<PipelineContext>>();
 
             // Collections
-            GET_TARGET_TYPE = Allocate<Array, Func<UnityContainer, Type, Type>>();
+            GET_TARGET_TYPE = Allocate<Array, UnitySelector<Type, Type>>();
         }
 
         #endregion

src/Container/Processors/Constructor/Constructor.BuildUp.cs

@@ -69,7 +69,7 @@ public override void PreBuildUp<TContext>(ref TContext context)
 
             ///////////////////////////////////////////////////////////////////
             // Select using algorithm
-            ConstructorInfo? info = Select(context.Container, members);
+            ConstructorInfo? info = SelectionHandler(context.Container, members);
             if (null != info)
             {
                 using var action = context.Start(info);

src/Container/Processors/Constructor/Constructor.Processor.cs

@@ -13,19 +13,25 @@ public partial class ConstructorProcessor : ParameterProcessor<ConstructorInfo>
         #endregion
 
 
+        #region Fields
+
+        protected UnitySelector<ConstructorInfo[], ConstructorInfo?> SelectionHandler { get; set; }
+
+        #endregion
+
+
         #region Constructors
 
         public ConstructorProcessor(IPolicyObservable policies)
             : base(policies)
         {
-            Select = DefaultSelector;
-            policies.Set<Func<UnityContainer, ConstructorInfo[], ConstructorInfo?>>(DefaultSelector, OnSelectorChanged);
+            SelectionHandler = policies.Get<ConstructorInfo, UnitySelector<ConstructorInfo[], ConstructorInfo?>>(OnSelectorChanged)!;
         }
 
         private void OnSelectorChanged(Type? target, Type type, object? policy)
         {
             if (policy is null) throw new ArgumentNullException(nameof(policy));
-            Select = (Func<UnityContainer, ConstructorInfo[], ConstructorInfo?>)policy;
+            SelectionHandler = (UnitySelector<ConstructorInfo[], ConstructorInfo?>)policy;
         }
 
         #endregion

src/Container/Processors/Member/Member.Processor.cs

@@ -17,7 +17,7 @@ public abstract partial class MemberProcessor<TMemberInfo, TDependency, TData> :
         /// This method returns an array of <see cref="MemberInfo"/> objects implemented
         /// by the <see cref="Type"/>
         /// </summary>
-        protected GetMembersDelegate<TMemberInfo> GetSupportedMembers;
+        protected MembersSelector<TMemberInfo> GetSupportedMembers;
 
         /// <summary>
         /// Function to load <see cref="ImportInfo{TMember}"/> with data from current <see cref="ParameterInfo"/>,
@@ -32,7 +32,7 @@ public abstract partial class MemberProcessor<TMemberInfo, TDependency, TData> :
 
         protected MemberProcessor(IPolicyObservable policies)
         {
-            GetSupportedMembers = policies.Get<GetMembersDelegate<TMemberInfo>>(OnMembersSelectorChanged)!;
+            GetSupportedMembers = policies.Get<TMemberInfo, MembersSelector<TMemberInfo>>(OnMembersSelectorChanged)!;
             LoadImportInfo = policies.Get<TDependency, ImportProvider<ImportInfo, ImportType>>(OnImportInfoLoaderChanged)!;
         }
 
@@ -142,7 +142,7 @@ protected MemberProcessor(IPolicyObservable policies)
         }
 
         private void OnMembersSelectorChanged(Type? target, Type type, object? policy)
-            => GetSupportedMembers = (GetMembersDelegate<TMemberInfo>)(policy ?? throw new ArgumentNullException(nameof(policy)));
+            => GetSupportedMembers = (MembersSelector<TMemberInfo>)(policy ?? throw new ArgumentNullException(nameof(policy)));
 
         private void OnImportInfoLoaderChanged(Type? target, Type type, object? policy)
             => LoadImportInfo = (ImportProvider<ImportInfo, ImportType>)(policy ?? throw new ArgumentNullException(nameof(policy)));

src/Container/Unity/Resolution/Unity.Array.cs

@@ -26,7 +26,7 @@ public partial class UnityContainer
                     return context.Error($"Invalid array {type}. Only arrays of rank 1 are supported");
 
                 var element = type.GetElementType()!;
-                var target = Policies.GerTargetType(this, element!);
+                var target = Policies.ArrayTargetType(this, element!);
                 var types = target.IsGenericType
                     ? new[] { target, target.GetGenericTypeDefinition() }
                     : new[] { target };
@@ -135,42 +135,5 @@ public partial class UnityContainer
         }
 
         #endregion
-
-
-        #region Target Type
-
-        private static Type GetArrayTargetType(UnityContainer container, Type argType)
-        {
-            Type? next;
-            Type? type = argType;
-
-            do
-            {
-                if (type.IsGenericType)
-                {
-                    if (container.Scope.Contains(type)) return type!;
-
-                    var definition = type.GetGenericTypeDefinition();
-                    if (container.Scope.Contains(definition)) return definition;
-
-                    next = type.GenericTypeArguments[0]!;
-                    if (container.Scope.Contains(next)) return next;
-                }
-                else if (type.IsArray)
-                {
-                    next = type.GetElementType()!;
-                    if (container.Scope.Contains(next)) return next;
-                }
-                else
-                {
-                    return type!;
-                }
-            }
-            while (null != (type = next));
-
-            return argType;
-        }
-
-        #endregion
     }
 }

src/Container/Unity/Unity.cs

@@ -32,7 +32,6 @@ public UnityContainer(string name, int capacity)
             Policies = new Defaults();
 
             // TODO: Setup extension points
-            Policies.Set<Func<UnityContainer, Type, Type>>(typeof(Array), GetArrayTargetType);
             Policies.Set<ResolverFactory<PipelineContext>>(typeof(IEnumerable<>), ResolveUnregisteredEnumerable);
 
             // Setup Scope

src/Extension/Delegates/GetMembersDelegate.cs → src/Extension/Delegates/MembersSelector.cs

@@ -20,5 +20,5 @@ namespace Unity.Extension
     /// </code>
     /// </example>
     /// <returns>Array of supported members</returns>
-    public delegate TMemberInfo[] GetMembersDelegate<TMemberInfo>(Type type);
+    public delegate TMemberInfo[] MembersSelector<TMemberInfo>(Type type);
 }

src/Extension/Delegates/UnitySelector.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Unity.Extension
+{
+    /// <summary>
+    /// The delegate to define selection handler that depends on the container's configuration
+    /// </summary>
+    /// <typeparam name="TInput"><see cref="Type"/> of the input</typeparam>
+    /// <typeparam name="TOutput"><see cref="Type"/> of the output</typeparam>
+    /// <param name="container">Instance of the container</param>
+    /// <param name="input">Value[s] to select from</param>
+    /// <returns>Selected value</returns>
+    public delegate TOutput UnitySelector<in TInput, out TOutput>(UnityContainer container, TInput input);
+}
+