Performance improvements

SteveWilkes · SteveWilkes · commit 45bb654ec287 · 2018-11-19T20:22:35.000Z
diff --git a/AgileMapper.PerformanceTesting/PerformanceTestRunner.cs b/AgileMapper.PerformanceTesting/PerformanceTestRunner.cs
@@ -42,7 +42,7 @@ private static ICollection<IObjectMapperTest> GetMapperTestsFor(Type exampleMapp
                 .GetTypes()
                 .Filter(t => (t.Namespace == exampleMapperTestType.Namespace) && typeof(IObjectMapperTest).IsAssignableFrom(t))
                 .Project(CreateTest)
-                .ToList();
+                .ToArray();
         }
 
         private static IObjectMapperTest CreateTest(Type testType)
diff --git a/AgileMapper/Configuration/ConfiguredLambdaInfo.cs b/AgileMapper/Configuration/ConfiguredLambdaInfo.cs
@@ -40,7 +40,7 @@ private ConfiguredLambdaInfo(
 
         public static ConfiguredLambdaInfo For(LambdaExpression lambda)
         {
-            var funcArguments = lambda.Parameters.Project(p => p.Type).ToArray();
+            var funcArguments = lambda.Parameters.ProjectToArray(p => p.Type);
             var contextTypes = GetContextTypes(funcArguments);
             var parameterSwapper = ParametersSwapper.For(contextTypes, funcArguments);
 
@@ -120,7 +120,7 @@ private static ConfiguredLambdaInfo For<T>(
                 return null;
             }
 
-            var parameters = funcArguments.Project(Parameters.Create).ToArray();
+            var parameters = funcArguments.ProjectToArray(Parameters.Create);
             var valueFactory = func.ToConstantExpression();
             var valueFactoryInvocation = Expression.Invoke(valueFactory, parameters.Cast<Expression>());
             var valueFactoryLambda = Expression.Lambda(funcType, valueFactoryInvocation, parameters);
diff --git a/AgileMapper/Configuration/DerivedTypePairSet.cs b/AgileMapper/Configuration/DerivedTypePairSet.cs
@@ -135,13 +135,11 @@ private void LookForDerivedTypePairs(ITypePair mapperData, MapperContext mapperC
                     return;
                 }
 
-                var candidatePairsData = derivedSourceTypes
-                    .Project(t => new
-                    {
-                        DerivedSourceType = t,
-                        DerivedTargetTypeName = derivedTargetTypeNameFactory.Invoke(t)
-                    })
-                    .ToArray();
+                var candidatePairsData = derivedSourceTypes.ProjectToArray(t => new
+                {
+                    DerivedSourceType = t,
+                    DerivedTargetTypeName = derivedTargetTypeNameFactory.Invoke(t)
+                });
 
                 foreach (var candidatePairData in candidatePairsData)
                 {
diff --git a/AgileMapper/Configuration/Inline/InlineMapperContextSet.cs b/AgileMapper/Configuration/Inline/InlineMapperContextSet.cs
@@ -59,7 +59,7 @@ private MapperContext GetContextFor<TSource, TTarget, TConfigurator>(
         {
             var key = new InlineMapperKey<TSource, TTarget, TConfigurator>(
 #if NET35
-                configurations.Project(c => c.ToDlrExpression()).ToArray(),
+                configurations.ProjectToArray(c => c.ToDlrExpression()),
 #else
                 configurations,
 #endif
diff --git a/AgileMapper/Configuration/ParametersSwapper.cs b/AgileMapper/Configuration/ParametersSwapper.cs
@@ -165,7 +165,7 @@ private static Expression ReplaceParameters(
         {
             var contextInfo = GetAppropriateMappingContext(swapArgs);
 
-            return swapArgs.Lambda.ReplaceParametersWith(parameterFactories.Project(f => f.Invoke(contextInfo)).ToArray());
+            return swapArgs.Lambda.ReplaceParametersWith(parameterFactories.ProjectToArray(f => f.Invoke(contextInfo)));
         }
 
         private static MappingContextInfo GetAppropriateMappingContext(SwapArgs swapArgs)
diff --git a/AgileMapper/DerivedTypesCache.cs b/AgileMapper/DerivedTypesCache.cs
@@ -15,13 +15,13 @@ internal class DerivedTypesCache
 
         private readonly List<Assembly> _assemblies;
         private readonly ICache<Assembly, IEnumerable<Type>> _typesByAssembly;
-        private readonly ICache<Type, ICollection<Type>> _derivedTypesByType;
+        private readonly ICache<Type, IList<Type>> _derivedTypesByType;
 
         public DerivedTypesCache(CacheSet cacheSet)
         {
             _assemblies = new List<Assembly>();
             _typesByAssembly = cacheSet.CreateScoped<Assembly, IEnumerable<Type>>(default(HashCodeComparer<Assembly>));
-            _derivedTypesByType = cacheSet.CreateScoped<Type, ICollection<Type>>(default(HashCodeComparer<Type>));
+            _derivedTypesByType = cacheSet.CreateScoped<Type, IList<Type>>(default(HashCodeComparer<Type>));
         }
 
         public void AddAssemblies(Assembly[] assemblies)
@@ -32,7 +32,7 @@ public void AddAssemblies(Assembly[] assemblies)
             }
         }
 
-        public ICollection<Type> GetTypesDerivedFrom(Type type)
+        public IList<Type> GetTypesDerivedFrom(Type type)
         {
             if (type.IsSealed() || type.IsFromBcl())
             {
@@ -42,7 +42,7 @@ public ICollection<Type> GetTypesDerivedFrom(Type type)
             return _derivedTypesByType.GetOrAdd(type, GetDerivedTypesForType);
         }
 
-        private ICollection<Type> GetDerivedTypesForType(Type type)
+        private IList<Type> GetDerivedTypesForType(Type type)
         {
             var typeAssemblies = new[] { type.GetAssembly() };
 
diff --git a/AgileMapper/Extensions/Internal/EnumerableExtensions.cs b/AgileMapper/Extensions/Internal/EnumerableExtensions.cs
@@ -123,6 +123,30 @@ public static bool All<T>(this IList<T> items, Func<T, bool> predicate)
         [DebuggerStepThrough]
         public static bool HasOne<T>(this ICollection<T> items) => items.Count == 1;
 
+        public static TResult[] ProjectToArray<TItem, TResult>(this IList<TItem> items, Func<TItem, TResult> projector)
+        {
+            var itemCount = items.Count;
+
+            if (itemCount == 0)
+            {
+                return Enumerable<TResult>.EmptyArray;
+            }
+
+            var result = new TResult[items.Count];
+
+            for (var i = 0; ;)
+            {
+                result[i] = projector.Invoke(items[i]);
+
+                if (++i == itemCount)
+                {
+                    break;
+                }
+            }
+
+            return result;
+        }
+
         public static Expression ReverseChain<T>(this IList<T> items)
             where T : IConditionallyChainable
         {
diff --git a/AgileMapper/Extensions/Internal/ExpressionExtensions.Replace.cs b/AgileMapper/Extensions/Internal/ExpressionExtensions.Replace.cs
@@ -236,7 +236,7 @@ private Expression ReplaceIn(BlockExpression block)
             {
                 return ReplaceIn(
                     block,
-                    b => b.Update(b.Variables.Project(ReplaceIn), b.Expressions.Project(Replace)));
+                    b => b.Update(b.Variables.ProjectToArray(ReplaceIn), b.Expressions.ProjectToArray(Replace)));
             }
 
             private Expression ReplaceIn(MethodCallExpression call)
@@ -247,29 +247,29 @@ private Expression ReplaceIn(MethodCallExpression call)
             private Expression ReplaceIn(GotoExpression @goto) => ReplaceIn(@goto, gt => gt.Update(gt.Target, Replace(gt.Value)));
 
             private Expression ReplaceIn(IndexExpression indexAccess)
-                => ReplaceIn(indexAccess, idx => idx.Update(Replace(idx.Object), idx.Arguments.Project(Replace)));
+                => ReplaceIn(indexAccess, idx => idx.Update(Replace(idx.Object), idx.Arguments.ProjectToArray(Replace)));
 
             private Expression ReplaceIn(InvocationExpression invocation)
                 => ReplaceIn(invocation, inv => ReplaceInCall(inv.Expression, inv.Arguments, inv.Update));
 
             private Expression ReplaceInCall(
                 Expression subject,
-                IEnumerable<Expression> arguments,
+                IList<Expression> arguments,
                 Func<Expression, IEnumerable<Expression>, Expression> replacer)
             {
-                return replacer.Invoke(Replace(subject), arguments.Project(Replace).ToArray());
+                return replacer.Invoke(Replace(subject), arguments.ProjectToArray(Replace));
             }
 
             private Expression ReplaceIn(LabelExpression label)
                 => ReplaceIn(label, l => l.Update(l.Target, Replace(l.DefaultValue)));
 
             private Expression ReplaceIn(LambdaExpression lambda)
-                => ReplaceIn(lambda, l => Expression.Lambda(l.Type, Replace(l.Body), l.Parameters.Project(ReplaceIn)));
+                => ReplaceIn(lambda, l => Expression.Lambda(l.Type, Replace(l.Body), l.Parameters.ProjectToArray(ReplaceIn)));
 
             private Expression ReplaceIn(MemberExpression memberAccess) => ReplaceIn(memberAccess, ma => ma.Update(Replace(ma.Expression)));
 
             private Expression ReplaceIn(MemberInitExpression memberInit)
-                => ReplaceIn(memberInit, mi => mi.Update(ReplaceInNew(mi.NewExpression), mi.Bindings.Project(ReplaceIn)));
+                => ReplaceIn(memberInit, mi => mi.Update(ReplaceInNew(mi.NewExpression), mi.Bindings.ProjectToArray(ReplaceIn)));
 
             private Expression ReplaceIn(ListInitExpression listInit)
                 => ReplaceIn(listInit, li => li.Update(ReplaceInNew(li.NewExpression), ReplaceIn(li.Initializers)));
@@ -290,25 +290,25 @@ private MemberBinding ReplaceIn(MemberBinding binding)
 
                     case MemberBindingType.MemberBinding:
                         var memberBinding = (MemberMemberBinding)binding;
-                        return memberBinding.Update(memberBinding.Bindings.Project(ReplaceIn));
+                        return memberBinding.Update(memberBinding.Bindings.ProjectToArray(ReplaceIn));
                 }
 
                 throw new ArgumentOutOfRangeException();
             }
 
-            private IEnumerable<ElementInit> ReplaceIn(IEnumerable<ElementInit> initializers)
-                => initializers.Project(init => init.Update(init.Arguments.Project(Replace)));
+            private IEnumerable<ElementInit> ReplaceIn(IList<ElementInit> initializers)
+                => initializers.ProjectToArray(init => init.Update(init.Arguments.ProjectToArray(Replace)));
 
             private Expression ReplaceIn(NewExpression newing) => ReplaceIn(newing, ReplaceInNew);
 
             private NewExpression ReplaceInNew(NewExpression newing)
             {
                 return newing.Arguments.None()
                     ? newing
-                    : newing.Update(newing.Arguments.Project(Replace));
+                    : newing.Update(newing.Arguments.ProjectToArray(Replace));
             }
 
-            private Expression ReplaceIn(NewArrayExpression newArray) => ReplaceIn(newArray, na => na.Update(na.Expressions.Project(Replace)));
+            private Expression ReplaceIn(NewArrayExpression newArray) => ReplaceIn(newArray, na => na.Update(na.Expressions.ProjectToArray(Replace)));
 
             private ParameterExpression ReplaceIn(ParameterExpression parameter) => (ParameterExpression)ReplaceIn(parameter, p => p);
 
@@ -320,7 +320,7 @@ private Expression ReplaceIn(TryExpression @try)
             {
                 return ReplaceIn(
                     @try,
-                    t => t.Update(Replace(t.Body), t.Handlers.Project(ReplaceIn), Replace(t.Finally), Replace(t.Fault)));
+                    t => t.Update(Replace(t.Body), t.Handlers.ProjectToArray(ReplaceIn), Replace(t.Finally), Replace(t.Fault)));
             }
 
             private CatchBlock ReplaceIn(CatchBlock @catch)
diff --git a/AgileMapper/Extensions/Internal/TypeExtensions.cs b/AgileMapper/Extensions/Internal/TypeExtensions.cs
@@ -189,11 +189,29 @@ private static double GetValueFor(
         {
             type = type.GetNonNullableType();
 
-            return type.IsEnum() ? enumValueFactory.Invoke(GetEnumValues(type)) : cache[type];
+            return type.IsEnum() ? enumValueFactory.Invoke(GetEnumValuesArray(type, Convert.ToInt64)) : cache[type];
         }
 
-        private static IEnumerable<long> GetEnumValues(Type enumType)
-            => Enum.GetValues(enumType).Cast<object>().Project(Convert.ToInt64);
+        public static TResult[] GetEnumValuesArray<TResult>(this Type enumType, Func<object, TResult> resultFactory)
+        {
+            var values = Enum.GetValues(enumType);
+            var valueCount = values.Length;
+
+            if (valueCount == 0)
+            {
+                return Enumerable<TResult>.EmptyArray;
+            }
+
+            var resultValues = new TResult[valueCount];
+            var i = 0;
+
+            foreach (var value in values)
+            {
+                resultValues[i++] = resultFactory.Invoke(value);
+            }
+
+            return resultValues;
+        }
 
         public static bool StartsWith(this string value, char character) => value[0] == character;
 
diff --git a/AgileMapper/Members/Dictionaries/DictionaryTargetMember.cs b/AgileMapper/Members/Dictionaries/DictionaryTargetMember.cs
@@ -336,7 +336,7 @@ private static Expression GetCheckedTryCatch(
 
             var updatedCatchHandlers = tryCatchValue
                 .Handlers
-                .Project(handler => handler.Update(
+                .ProjectToArray(handler => handler.Update(
                     handler.Variable,
                     handler.Filter.Replace(replacements),
                     handler.Body.Replace(replacements)));
diff --git a/AgileMapper/Members/MemberCache.cs b/AgileMapper/Members/MemberCache.cs
@@ -52,7 +52,7 @@ public IList<Member> GetTargetMembers(Type targetType)
 
                 var constructorParameterNames = key.Type
                     .GetPublicInstanceConstructors()
-                    .SelectMany(ctor => ctor.GetParameters().Project(p => p.Name))
+                    .SelectMany(ctor => ctor.GetParameters().ProjectToArray(p => p.Name))
                     .Distinct()
                     .ToArray();
 
diff --git a/AgileMapper/Members/NamingSettings.cs b/AgileMapper/Members/NamingSettings.cs
@@ -54,11 +54,11 @@ private static string GetGetOrSetMethodName(Member member)
             return null;
         }
 
-        public void AddNamePrefixes(IEnumerable<string> prefixes)
-            => AddNameMatchers(prefixes.Project(p => "^" + p + "(.+)$").ToArray());
+        public void AddNamePrefixes(IList<string> prefixes)
+            => AddNameMatchers(prefixes.ProjectToArray(p => "^" + p + "(.+)$"));
 
-        public void AddNameSuffixes(IEnumerable<string> suffixes)
-            => AddNameMatchers(suffixes.Project(s => "^(.+)" + s + "$").ToArray());
+        public void AddNameSuffixes(IList<string> suffixes)
+            => AddNameMatchers(suffixes.ProjectToArray(s => "^(.+)" + s + "$"));
 
         public void AddNameMatchers(IList<string> patterns)
         {
diff --git a/AgileMapper/Members/Population/MemberPopulatorFactory.cs b/AgileMapper/Members/Population/MemberPopulatorFactory.cs
@@ -20,7 +20,7 @@ internal class MemberPopulatorFactory
             GlobalContext.Instance
                 .MemberCache
                 .GetTargetMembers(mapperData.TargetType)
-                .Project(tm => mapperData.TargetMember.Append(tm)));
+                .ProjectToArray(tm => mapperData.TargetMember.Append(tm)));
 
         private readonly Func<ObjectMapperData, IEnumerable<QualifiedMember>> _targetMembersFactory;
 
diff --git a/AgileMapper/Members/QualifiedMember.cs b/AgileMapper/Members/QualifiedMember.cs
@@ -128,8 +128,7 @@ public static QualifiedMember From(Member member, MapperContext mapperContext)
         public static QualifiedMember From(Member[] memberChain, MapperContext mapperContext)
         {
             var matchingNameSets = memberChain
-                .Project(mapperContext.Naming.GetMatchingNamesFor)
-                .ToArray();
+                .ProjectToArray(mapperContext.Naming.GetMatchingNamesFor);
 
             var joinedNames = mapperContext.Naming.GetJoinedNamesFor(matchingNameSets);
 
diff --git a/AgileMapper/ObjectPopulation/ComplexTypes/ComplexTypeConstructionFactory.cs b/AgileMapper/ObjectPopulation/ComplexTypes/ComplexTypeConstructionFactory.cs
@@ -315,7 +315,7 @@ private static Tuple<QualifiedMember, DataSourceSet>[] GetArgumentDataSources(TI
             {
                 return invokable
                     .GetParameters()
-                    .Project(p =>
+                    .ProjectToArray(p =>
                     {
                         var parameterMapperData = new ChildMemberMapperData(
                             key.MappingData.MapperData.TargetMember.Append(Member.ConstructorParameter(p)),
@@ -325,8 +325,7 @@ private static Tuple<QualifiedMember, DataSourceSet>[] GetArgumentDataSources(TI
                         var dataSources = DataSourceFinder.FindFor(memberMappingData);
 
                         return Tuple.Create(memberMappingData.MapperData.TargetMember, dataSources);
-                    })
-                    .ToArray();
+                    });
             }
 
             private static Expression BuildConditions(DataSourceSet dataSources)
diff --git a/AgileMapper/TypeConversion/ToEnumConverter.cs b/AgileMapper/TypeConversion/ToEnumConverter.cs
@@ -518,11 +518,8 @@ private static Expression GetNumericStringToEnumConversion(
             Type nonNullableTargetEnumType,
             Type underlyingEnumType)
         {
-            var validEnumValues = Enum
-                .GetValues(nonNullableTargetEnumType)
-                .Cast<object>()
-                .Project(v => Convert.ChangeType(v, underlyingEnumType).ToString())
-                .ToArray()
+            var validEnumValues = nonNullableTargetEnumType
+                .GetEnumValuesArray(v => Convert.ChangeType(v, underlyingEnumType).ToString())
                 .ToConstantExpression(typeof(ICollection<string>));
 
             var parsedString = GetStringParseCall(sourceValue, underlyingEnumType);
diff --git a/AgileMapper/Validation/EnumMappingMismatchSet.cs b/AgileMapper/Validation/EnumMappingMismatchSet.cs
@@ -187,8 +187,7 @@ private static string[] GetMappingMismatches(
                 }
 
                 var mismatches = unmatchedSourceValues
-                    .Project(value => $" - {sourceEnumType.Name}.{value} matches no {targetEnumType.Name}")
-                    .ToArray();
+                    .ProjectToArray(value => $" - {sourceEnumType.Name}.{value} matches no {targetEnumType.Name}");
 
                 return mismatches;
             }

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ private static ICollection<IObjectMapperTest> GetMapperTestsFor(Type exampleMapp`
`42`	`42`	`.GetTypes()`
`43`	`43`	`.Filter(t => (t.Namespace == exampleMapperTestType.Namespace) && typeof(IObjectMapperTest).IsAssignableFrom(t))`
`44`	`44`	`.Project(CreateTest)`
`45`		`- .ToList();`
	`45`	`+ .ToArray();`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`private static IObjectMapperTest CreateTest(Type testType)`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ private ConfiguredLambdaInfo(`
`40`	`40`
`41`	`41`	`public static ConfiguredLambdaInfo For(LambdaExpression lambda)`
`42`	`42`	`{`
`43`		`- var funcArguments = lambda.Parameters.Project(p => p.Type).ToArray();`
	`43`	`+ var funcArguments = lambda.Parameters.ProjectToArray(p => p.Type);`
`44`	`44`	`var contextTypes = GetContextTypes(funcArguments);`
`45`	`45`	`var parameterSwapper = ParametersSwapper.For(contextTypes, funcArguments);`
`46`	`46`
`@@ -120,7 +120,7 @@ private static ConfiguredLambdaInfo For<T>(`
`120`	`120`	`return null;`
`121`	`121`	`}`
`122`	`122`
`123`		`- var parameters = funcArguments.Project(Parameters.Create).ToArray();`
	`123`	`+ var parameters = funcArguments.ProjectToArray(Parameters.Create);`
`124`	`124`	`var valueFactory = func.ToConstantExpression();`
`125`	`125`	`var valueFactoryInvocation = Expression.Invoke(valueFactory, parameters.Cast<Expression>());`
`126`	`126`	`var valueFactoryLambda = Expression.Lambda(funcType, valueFactoryInvocation, parameters);`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ private MapperContext GetContextFor<TSource, TTarget, TConfigurator>(`
`59`	`59`	`{`
`60`	`60`	`var key = new InlineMapperKey<TSource, TTarget, TConfigurator>(`
`61`	`61`	`#if NET35`
`62`		`- configurations.Project(c => c.ToDlrExpression()).ToArray(),`
	`62`	`+ configurations.ProjectToArray(c => c.ToDlrExpression()),`
`63`	`63`	`#else`
`64`	`64`	`configurations,`
`65`	`65`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ private static Expression ReplaceParameters(`
`165`	`165`	`{`
`166`	`166`	`var contextInfo = GetAppropriateMappingContext(swapArgs);`
`167`	`167`
`168`		`- return swapArgs.Lambda.ReplaceParametersWith(parameterFactories.Project(f => f.Invoke(contextInfo)).ToArray());`
	`168`	`+ return swapArgs.Lambda.ReplaceParametersWith(parameterFactories.ProjectToArray(f => f.Invoke(contextInfo)));`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`private static MappingContextInfo GetAppropriateMappingContext(SwapArgs swapArgs)`
Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,13 @@ internal class DerivedTypesCache`
`15`	`15`
`16`	`16`	`private readonly List<Assembly> _assemblies;`
`17`	`17`	`private readonly ICache<Assembly, IEnumerable<Type>> _typesByAssembly;`
`18`		`- private readonly ICache<Type, ICollection<Type>> _derivedTypesByType;`
	`18`	`+ private readonly ICache<Type, IList<Type>> _derivedTypesByType;`
`19`	`19`
`20`	`20`	`public DerivedTypesCache(CacheSet cacheSet)`
`21`	`21`	`{`
`22`	`22`	`_assemblies = new List<Assembly>();`
`23`	`23`	`_typesByAssembly = cacheSet.CreateScoped<Assembly, IEnumerable<Type>>(default(HashCodeComparer<Assembly>));`
`24`		`- _derivedTypesByType = cacheSet.CreateScoped<Type, ICollection<Type>>(default(HashCodeComparer<Type>));`
	`24`	`+ _derivedTypesByType = cacheSet.CreateScoped<Type, IList<Type>>(default(HashCodeComparer<Type>));`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`public void AddAssemblies(Assembly[] assemblies)`
`@@ -32,7 +32,7 @@ public void AddAssemblies(Assembly[] assemblies)`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`		`- public ICollection<Type> GetTypesDerivedFrom(Type type)`
	`35`	`+ public IList<Type> GetTypesDerivedFrom(Type type)`
`36`	`36`	`{`
`37`	`37`	`if (type.IsSealed() \|\| type.IsFromBcl())`
`38`	`38`	`{`
`@@ -42,7 +42,7 @@ public ICollection<Type> GetTypesDerivedFrom(Type type)`
`42`	`42`	`return _derivedTypesByType.GetOrAdd(type, GetDerivedTypesForType);`
`43`	`43`	`}`
`44`	`44`
`45`		`- private ICollection<Type> GetDerivedTypesForType(Type type)`
	`45`	`+ private IList<Type> GetDerivedTypesForType(Type type)`
`46`	`46`	`{`
`47`	`47`	`var typeAssemblies = new[] { type.GetAssembly() };`
`48`	`48`