Swapping uses of Linq .First() for more performant IList.First() method

Author: SteveWilkes

AgileMapper/Extensions/EnumerableExtensions.cs

@@ -16,6 +16,27 @@ public static void AddUnlessNullOrEmpty(this ICollection<Expression> items, Expr
             }
         }
 
+        [DebuggerStepThrough]
+        public static T First<T>(this IList<T> items) => items[0];
+
+        public static T First<T>(this IList<T> items, Func<T, bool> predicate)
+        {
+            for (int i = 0, n = items.Count; i < n; i++)
+            {
+                var item = items[i];
+
+                if (predicate.Invoke(item))
+                {
+                    return item;
+                }
+            }
+
+            throw new InvalidOperationException("Sequence contains no matching element");
+        }
+
+        [DebuggerStepThrough]
+        public static T Last<T>(this IList<T> items) => items[items.Count - 1];
+
         [DebuggerStepThrough]
         public static bool Any<T>(this ICollection<T> items) => items.Count > 0;
 
@@ -41,7 +62,7 @@ public static bool None<T>(this IEnumerable<T> items, Func<T, bool> predicate)
         [DebuggerStepThrough]
         public static bool HasOne<T>(this ICollection<T> items) => items.Count == 1;
 
-        public static Expression ReverseChain<T>(this ICollection<T> items)
+        public static Expression ReverseChain<T>(this IList<T> items)
             where T : IConditionallyChainable
         {
             return ReverseChain(
@@ -66,27 +87,27 @@ private static Expression AddPreConditionIfNecessary(IConditionallyChainable ite
         }
 
         public static Expression ReverseChain<TItem>(
-            this ICollection<TItem> items,
+            this IList<TItem> items,
             Func<TItem, Expression> seedValueFactory,
             Func<Expression, TItem, Expression> itemValueFactory)
         {
             return Chain(items, i => i.Last(), seedValueFactory, itemValueFactory, i => i.Reverse());
         }
 
         public static Expression Chain<TItem>(
-            this ICollection<TItem> items,
+            this IList<TItem> items,
             Func<TItem, Expression> seedValueFactory,
             Func<Expression, TItem, Expression> itemValueFactory)
         {
             return Chain(items, i => i.First(), seedValueFactory, itemValueFactory, i => i);
         }
 
         private static Expression Chain<TItem>(
-            ICollection<TItem> items,
-            Func<ICollection<TItem>, TItem> seedFactory,
+            IList<TItem> items,
+            Func<IList<TItem>, TItem> seedFactory,
             Func<TItem, Expression> seedValueFactory,
             Func<Expression, TItem, Expression> itemValueFactory,
-            Func<ICollection<TItem>, IEnumerable<TItem>> initialOperation)
+            Func<IList<TItem>, IEnumerable<TItem>> initialOperation)
         {
             if (items.None())
             {

AgileMapper/Extensions/ExpressionExtensions.cs

@@ -43,7 +43,7 @@ public static ConstantExpression ToConstantExpression<TItem>(this TItem item, Ty
         [DebuggerStepThrough]
         public static DefaultExpression ToDefaultExpression(this Type type) => Expression.Default(type);
 
-        public static Expression AndTogether(this ICollection<Expression> expressions)
+        public static Expression AndTogether(this IList<Expression> expressions)
         {
             if (expressions.None())
             {

AgileMapper/MappingRuleSetCollection.cs

@@ -1,7 +1,7 @@
 namespace AgileObjects.AgileMapper
 {
     using System.Collections.Generic;
-    using System.Linq;
+    using Extensions;
     using Members.Population;
     using ObjectPopulation;
     using ObjectPopulation.Enumerables;

AgileMapper/Members/MemberFinder.cs

@@ -11,12 +11,12 @@
     internal class MemberFinder
     {
         private readonly ICache<TypeKey, Member> _idMemberCache;
-        private readonly ICache<TypeKey, IEnumerable<Member>> _membersCache;
+        private readonly ICache<TypeKey, IList<Member>> _membersCache;
 
         public MemberFinder()
         {
             _idMemberCache = GlobalContext.Instance.Cache.CreateScoped<TypeKey, Member>();
-            _membersCache = GlobalContext.Instance.Cache.CreateScoped<TypeKey, IEnumerable<Member>>();
+            _membersCache = GlobalContext.Instance.Cache.CreateScoped<TypeKey, IList<Member>>();
         }
 
         public Member GetIdentifierOrNull(TypeKey typeIdKey)
@@ -29,7 +29,7 @@ public Member GetIdentifierOrNull(TypeKey typeIdKey)
             });
         }
 
-        public IEnumerable<Member> GetSourceMembers(Type sourceType)
+        public IList<Member> GetSourceMembers(Type sourceType)
         {
             return _membersCache.GetOrAdd(TypeKey.ForSourceMembers(sourceType), key =>
             {
@@ -46,7 +46,7 @@ public IEnumerable<Member> GetSourceMembers(Type sourceType)
             });
         }
 
-        public IEnumerable<Member> GetTargetMembers(Type targetType)
+        public IList<Member> GetTargetMembers(Type targetType)
         {
             return _membersCache.GetOrAdd(TypeKey.ForTargetMembers(targetType), key =>
             {
@@ -158,7 +158,7 @@ private static bool OnlyCallableSetters(MethodInfo method)
 
         #endregion
 
-        private static IEnumerable<Member> GetMembers(params IEnumerable<Member>[] members)
+        private static IList<Member> GetMembers(params IEnumerable<Member>[] members)
         {
             var allMembers = members
                 .SelectMany(m => m)

AgileMapper/ObjectPopulation/ComplexTypes/ComplexTypeConstructionFactory.cs

@@ -233,7 +233,7 @@ private class Construction : IConditionallyChainable
             private readonly Expression _construction;
             private readonly ParameterExpression _mappingDataObject;
 
-            public Construction(ICollection<Construction> constructions, ConstructionKey key)
+            public Construction(IList<Construction> constructions, ConstructionKey key)
                 : this(constructions.ReverseChain())
             {
                 UsesMappingDataObjectParameter = constructions.Any(c => c.UsesMappingDataObjectParameter);

AgileMapper/ObjectPopulation/ComplexTypes/ComplexTypeMappingExpressionFactory.cs

@@ -246,7 +246,7 @@ private static Expression GetPopulationCallbackOrNull(
         }
 
         private static void CreateSourceMemberTypeTesterIfRequired(
-            ICollection<Expression> typeTests,
+            IList<Expression> typeTests,
             IObjectMappingData mappingData)
         {
             if (typeTests.None())

AgileMapper/ObjectPopulation/ObjectMapper.cs

@@ -1,7 +1,6 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation
 {
     using System;
-    using System.Linq;
     using System.Linq.Expressions;
 #if NET_STANDARD
     using System.Reflection;
@@ -48,7 +47,7 @@ private ICache<ObjectMapperKeyBase, IObjectMapperFunc> CreateRecursionMapperFunc
             foreach (var mappingLambdaAndKey in MapperData.RequiredMapperFuncsByKey)
             {
                 var mappingLambda = mappingLambdaAndKey.Value;
-                var mappingDataObject = mappingLambda.Parameters.First();
+                var mappingDataObject = mappingLambda.Parameters[0];
                 var mappingDataTypes = mappingDataObject.Type.GetGenericArguments();
 
                 var typesKey = new SourceAndTargetTypesKey(mappingDataTypes[0], mappingDataTypes[1]);

AgileMapper/ObjectPopulation/ObjectMapperData.cs

@@ -330,7 +330,7 @@ public static ObjectMapperData For<TSource, TTarget>(IObjectMappingData mappingD
 
         public ObjectMapperData DeclaredTypeMapperData { get; }
 
-        public ICollection<ObjectMapperData> ChildMapperDatas => _childMapperDatas;
+        public IList<ObjectMapperData> ChildMapperDatas => _childMapperDatas;
 
         public int DataSourceIndex { get; set; }
 

AgileMapper/ObjectPopulation/ObjectMapperFactory.cs

@@ -1,15 +1,15 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation
 {
     using System.Collections.Generic;
-    using System.Linq;
     using System.Linq.Expressions;
     using Caching;
     using ComplexTypes;
     using Enumerables;
+    using Extensions;
 
     internal class ObjectMapperFactory
     {
-        private readonly IEnumerable<MappingExpressionFactoryBase> _mappingExpressionFactories;
+        private readonly IList<MappingExpressionFactoryBase> _mappingExpressionFactories;
         private readonly List<ICacheEmptier> _rootCacheEmptiers;
 
         public ObjectMapperFactory(MapperContext mapperContext)

AgileMapper/Plans/MappingPlanData.cs

@@ -5,6 +5,7 @@
 #if NET_STANDARD
     using System.Reflection;
 #endif
+    using Extensions;
     using Members;
     using ObjectPopulation;
     using ReadableExpressions;