Fixing resolving of T[][]

Author: ENikS

src/Injection/GenericResolvedArrayParameter.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
 
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Reflection;
@@ -74,13 +75,8 @@ public override IResolverPolicy GetResolverPolicy(Type typeToBuild)
             GuardTypeToBuildHasMatchingGenericParameter(typeToBuild);
 
             Type typeToResolve = typeToBuild.GetNamedGenericParameter(_genericParameterName);
-
-            var resolverPolicies = new List<IResolverPolicy>();
-            foreach (InjectionParameterValue pv in _elementValues)
-            {
-                resolverPolicies.Add(pv.GetResolverPolicy(typeToBuild));
-            }
-            return new ResolvedArrayWithElementsResolverPolicy(typeToResolve, resolverPolicies.ToArray());
+            var elementPolicies = _elementValues.Select(pv => pv.GetResolverPolicy(typeToBuild)).ToArray();
+            return new ResolvedArrayWithElementsResolverPolicy(typeToResolve, elementPolicies);
         }
 
         private void GuardTypeToBuildIsGeneric(Type typeToBuild)

src/Injection/ResolvedArrayParameter.cs

@@ -3,8 +3,10 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using Unity.Policy;
 using Unity.ResolverPolicy;
+using Unity.Utility;
 
 namespace Unity.Injection
 {
@@ -26,7 +28,7 @@ public class ResolvedArrayParameter : TypedInjectionValue
         /// <param name="elementValues">The values for the elements, that will
         /// be converted to <see cref="InjectionParameterValue"/> objects.</param>
         public ResolvedArrayParameter(Type elementType, params object[] elementValues)
-            : this(GetArrayType(elementType), elementType, elementValues)
+            : this(elementType.MakeArrayType(), elementType, elementValues)
         {
         }
 
@@ -66,17 +68,13 @@ protected ResolvedArrayParameter(Type arrayParameterType, Type elementType, para
         /// <returns>The <see cref="IResolverPolicy"/>.</returns>
         public override IResolverPolicy GetResolverPolicy(Type typeToBuild)
         {
-            List<IResolverPolicy> resolverPolicies = new List<IResolverPolicy>();
-            foreach (InjectionParameterValue pv in _elementValues)
-            {
-                resolverPolicies.Add(pv.GetResolverPolicy(_elementType));
-            }
-            return new ResolvedArrayWithElementsResolverPolicy(_elementType, resolverPolicies.ToArray());
-        }
+            var elementType = !_elementType.IsArray ? _elementType 
+                : _elementType.GetArrayParameterType(typeToBuild.GenericTypeArguments);
 
-        private static Type GetArrayType(Type elementType)
-        {
-            return (elementType ?? throw new ArgumentNullException(nameof(elementType))).MakeArrayType();
+            var elementPolicies = _elementValues.Select(pv => pv.GetResolverPolicy(typeToBuild))
+                                                .ToArray();
+
+            return new ResolvedArrayWithElementsResolverPolicy(elementType, elementPolicies);
         }
     }
 

src/Utility/TypeReflectionExtensions.cs

@@ -104,29 +104,31 @@ public static Type GetClosedParameterType(this Type typeToReflect, Type[] generi
                 return typeToReflect.GetGenericTypeDefinition().MakeGenericType(typeArgs);
             }
 
-            if (info.IsGenericParameter)
+            if (typeToReflect.IsArray)
             {
-                return genericArguments[typeToReflect.GenericParameterPosition];
+                return typeToReflect.GetArrayParameterType(genericArguments);
             }
 
-            if (typeToReflect.IsArray && typeToReflect.GetElementType().GetTypeInfo().IsGenericParameter)
+            if (info.IsGenericParameter)
             {
-                int rank;
-                if ((rank = typeToReflect.GetArrayRank()) == 1)
-                {
-                    // work around to the fact that Type.MakeArrayType() != Type.MakeArrayType(1)
-                    return genericArguments[typeToReflect.GetElementType().GenericParameterPosition]
-                        .MakeArrayType();
-                }
-
-                return genericArguments[typeToReflect.GetElementType().GenericParameterPosition]
-                    .MakeArrayType(rank);
+                return genericArguments[typeToReflect.GenericParameterPosition];
             }
 
             return typeToReflect;
         }
 
 
+        public static Type GetArrayParameterType(this Type typeToReflect, Type[] genericArguments)
+        {
+            var rank = typeToReflect.GetArrayRank();
+            var element = typeToReflect.GetElementType();
+            var type = element.IsArray ? element.GetArrayParameterType(genericArguments)
+                                       : genericArguments[element.GenericParameterPosition];
+
+            return 1 == rank ? type.MakeArrayType() : type.MakeArrayType(rank);
+        }
+
+
         /// <summary>
         /// Given a generic argument name, return the corresponding type for this
         /// closed type. For example, if the current type is SomeType&lt;User&gt;, and the
@@ -189,6 +191,5 @@ public static bool Matches(this IEnumerable<InjectionParameterValue> parametersT
 
             return !toMatch.Where((t, i) => !t.MatchesType(candidateTypes[i])).Any();
         }
-
     }
 }