Collections usage improvements

Author: alex-kulakov

Orm/Xtensive.Orm/Collections/Deque.cs

@@ -610,7 +610,7 @@ public Deque(int initialCapacity, float growFactor)
     /// <param name="source">The initial contents of the <see cref="Deque{T}"/>.</param>
     public Deque(IEnumerable<T> source)
     {
-      items = new List<T>(source).ToArray();
+      items = source.ToArray();
       headPos = -1;
       tailPos = items.Length;
       count = items.Length;

Orm/Xtensive.Orm/Linq/ConstantExtractor.cs

@@ -49,7 +49,7 @@ public LambdaExpression Process()
       if (constantValues != null)
         throw new InvalidOperationException();
       constantValues = new List<object>();
-      var parameters = EnumerableUtils.One(ConstantParameter).Concat(lambda.Parameters).ToArray();
+      var parameters = EnumerableUtils.One(ConstantParameter).Concat(lambda.Parameters).ToArray(lambda.Parameters.Count + 1);
       var body = Visit(lambda.Body);
       // Preserve original delegate type because it may differ from types of parameters / return value
       return FastExpression.Lambda(FixDelegateType(lambda.Type), body, parameters);

Orm/Xtensive.Orm/Linq/SerializableExpressions/Internals/ExpressionToSerializableExpressionConverter.cs

@@ -192,56 +192,48 @@ protected override SerializableInvocationExpression VisitInvocation(InvocationEx
 
     #region Private / internal methods
 
-    private SerializableMemberBinding[] VisitMemberBindingSequence(IEnumerable<MemberBinding> bindings)
-    {
-      var result = new List<SerializableMemberBinding>();
-      foreach (var binding in bindings)
-        switch (binding.BindingType) {
-        case MemberBindingType.Assignment:
-          result.Add(new SerializableMemberAssignment
-            {
-              BindingType = MemberBindingType.Assignment,
-              Member = binding.Member,
-              Expression = Visit(((MemberAssignment) binding).Expression)
-            });
-          break;
-        case MemberBindingType.ListBinding:
-          result.Add(new SerializableMemberListBinding
-            {
-              BindingType = MemberBindingType.ListBinding,
-              Member = binding.Member,
-              Initializers = VisitElementInitSequence(((MemberListBinding) binding).Initializers)
-            });
-          break;
-        case MemberBindingType.MemberBinding:
-          result.Add(new SerializableMemberMemberBinding
-            {
-              BindingType = MemberBindingType.MemberBinding,
-              Member = binding.Member,
-              Bindings = VisitMemberBindingSequence(((MemberMemberBinding) binding).Bindings)
-            });
-          break;
-        default:
-          throw new ArgumentOutOfRangeException();
-        }
-      return result.ToArray();
-    }
-
-    private SerializableElementInit[] VisitElementInitSequence(IEnumerable<ElementInit> initializers)
+    private SerializableMemberBinding[] VisitMemberBindingSequence(IReadOnlyList<MemberBinding> bindings)
+    {
+      var arrayResult = new SerializableMemberBinding[bindings.Count];
+      for (int i = 0, count = bindings.Count; i < count; i++) {
+        var binding = bindings[i];
+        arrayResult[i] = binding.BindingType switch {
+          MemberBindingType.Assignment => new SerializableMemberAssignment() {
+            BindingType = MemberBindingType.Assignment,
+            Member = binding.Member,
+            Expression = Visit(((MemberAssignment) binding).Expression)
+          },
+          MemberBindingType.ListBinding => new SerializableMemberListBinding {
+            BindingType = MemberBindingType.ListBinding,
+            Member = binding.Member,
+            Initializers = VisitElementInitSequence(((MemberListBinding) binding).Initializers)
+          },
+          MemberBindingType.MemberBinding => new SerializableMemberMemberBinding {
+            BindingType = MemberBindingType.MemberBinding,
+            Member = binding.Member,
+            Bindings = VisitMemberBindingSequence(((MemberMemberBinding) binding).Bindings)
+          },
+          _ => throw new ArgumentOutOfRangeException()
+
+        };
+      }
+      return arrayResult;
+    }
+
+    private SerializableElementInit[] VisitElementInitSequence(IList<ElementInit> initializers)
     {
       return initializers
-        .Select(initializer => new SerializableElementInit
+        .SelectToArray(initializer => new SerializableElementInit
           {
             AddMethod = initializer.AddMethod,
             Arguments = VisitExpressionSequence(initializer.Arguments)
-          })
-        .ToArray();
+          });
     }
 
-    private SerializableExpression[] VisitExpressionSequence<T>(IEnumerable<T> expressions)
+    private SerializableExpression[] VisitExpressionSequence<T>(IList<T> expressions)
       where T : Expression
     {
-      return expressions.Select(e => Visit(e)).ToArray();
+      return expressions.SelectToArray(e => Visit(e));
     }
 
     #endregion

Orm/Xtensive.Orm/Linq/SerializableExpressions/Internals/SerializableExpressionToExpressionConverter.cs

@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using Xtensive.Core;
 
 namespace Xtensive.Linq.SerializableExpressions.Internals
 {
@@ -177,7 +178,7 @@ private Expression VisitMethodCall(SerializableMethodCallExpression mc)
 
     private Expression VisitLambda(SerializableLambdaExpression l)
     {
-      var parameters = l.Parameters.Select(p => (ParameterExpression) Visit(p)).ToList();
+      var parameters = l.Parameters.SelectToArray(p => (ParameterExpression) Visit(p));
       using (CreateParameterScope(parameters)) {
         return FastExpression.Lambda(l.Type, Visit(l.Body), parameters);
       }

Orm/Xtensive.Orm/Orm/Building/FixupActionProcessor.cs

@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Xtensive.Core;
 using Xtensive.Orm.Building.Builders;
 using Xtensive.Orm.Building.Definitions;
 using Xtensive.Orm.Building.DependencyGraph;
@@ -92,9 +93,8 @@ public void Process(BuildGenericTypeInstancesAction action)
       var typeSubstitutions = new Type[arguments.Length][];
       for (var i = 0; i < arguments.Length; i++) {
         var argument = arguments[i];
-        var constraints = argument.GetGenericParameterConstraints()
-          .ToList();
-        if (constraints.Count==0 || !constraints.Any(c => WellKnownOrmInterfaces.Entity.IsAssignableFrom(c)))
+        var constraints = argument.GetGenericParameterConstraints();
+        if (constraints.Length==0 || !constraints.Any(c => WellKnownOrmInterfaces.Entity.IsAssignableFrom(c)))
           return; // No IEntity / Entity constraints
         var queue = new Queue<Type>(
           from hierarchy in hierarchies

Orm/Xtensive.Orm/Orm/Building/PrefetchActionContainer.cs

@@ -25,7 +25,7 @@ internal sealed class PrefetchActionContainer
     public Action<SessionHandler, IEnumerable<Key>> BuildPrefetchAction(IEnumerable<AssociationInfo> associations)
     {
       fields = associations.Select(static association => new PrefetchFieldDescriptor(association.OwnerField, true, false))
-        .ToList();
+        .ToArray();
       return fields.Count > 0 ? Prefetch : null;
     }
 

Orm/Xtensive.Orm/Orm/Linq/Expressions/ConstructorExpression.cs

@@ -35,10 +35,10 @@ public Expression BindParameter(ParameterExpression parameter, Dictionary<Expres
         e => GenericExpressionVisitor<IMappedExpression>.Process(e, mapped => mapped.BindParameter(parameter, processedExpressions));
       return new ConstructorExpression(
         Type,
-        Bindings.ToDictionary(kvp => kvp.Key, kvp => genericBinder(kvp.Value)),
-        NativeBindings.ToDictionary(kvp=>kvp.Key, kvp => genericBinder(kvp.Value)),
+        Bindings.ToDictionary(kvp => kvp.Key, kvp => genericBinder(kvp.Value), Bindings.Count),
+        NativeBindings.ToDictionary(kvp=>kvp.Key, kvp => genericBinder(kvp.Value), NativeBindings.Count),
         Constructor,
-        ConstructorArguments.Select(genericBinder).ToList());
+        ConstructorArguments.Select(genericBinder).ToArray());
     }
 
     public Expression RemoveOuterParameter(Dictionary<Expression, Expression> processedExpressions)
@@ -50,7 +50,7 @@ public Expression RemoveOuterParameter(Dictionary<Expression, Expression> proces
         Bindings.ToDictionary(kvp => kvp.Key, kvp => genericRemover(kvp.Value)),
         NativeBindings = NativeBindings.ToDictionary(kvp => kvp.Key, kvp => genericRemover(kvp.Value)),
         Constructor,
-        ConstructorArguments.Select(genericRemover).ToList());
+        ConstructorArguments.Select(genericRemover).ToArray());
       return result;
     }
 

Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/MemberCompilerProvider.cs

@@ -174,7 +174,7 @@ private static (MemberInfo targetMember, Delegate compilerInvoker) ProcessCompil
       bool isGenericMethod = attribute.NumberOfGenericArguments > 0;
       bool isGenericType = targetType.IsGenericType;
       bool isGeneric = isGenericType || isGenericMethod;
-      
+
       string memberName = attribute.TargetMember;
 
       if (memberName.IsNullOrEmpty())
@@ -191,18 +191,21 @@ private static (MemberInfo targetMember, Delegate compilerInvoker) ProcessCompil
 
       if (isCtor)
         bindingFlags |= BindingFlags.Instance;
-      else
+      else {
         if (!isStatic) {
-          if (parameterTypes.Length==0)
+          if (parameterTypes.Length == 0)
             throw new InvalidOperationException(string.Format(
               Strings.ExCompilerXShouldHaveThisParameter,
               compiler.GetFullName(true)));
 
-          parameterTypes = parameterTypes.Skip(1).ToArray();
+          var noInstanceParameter = new Type[parameterTypes.Length - 1];
+          Array.Copy(parameterTypes, 1, noInstanceParameter, 0, noInstanceParameter.Length);
+          parameterTypes = noInstanceParameter;
           bindingFlags |= BindingFlags.Instance;
         }
         else
           bindingFlags |= BindingFlags.Static;
+      }
 
       if (isPropertyGetter) {
         bindingFlags |= BindingFlags.GetProperty;

Orm/Xtensive.Orm/Orm/Upgrade/Internals/CatalogCloner.cs

@@ -31,7 +31,7 @@ public Catalog Clone(Catalog source, MappingResolver mappingResolver, string new
 
     private Dictionary<string, string> CloneSchemas(Catalog newCatalog, Catalog sourceCatalog, MappingResolver mappingResolver)
     {
-      var schemaMap = new Dictionary<string, string>();
+      var schemaMap = new Dictionary<string, string>(sourceCatalog.Schemas.Count);
       foreach (var schema in sourceCatalog.Schemas) {
         var complexName = mappingResolver.GetNodeName(newCatalog.Name, schema.Name, "Dummy");
         var names = complexName.Split(NameElementSeparator);
@@ -336,16 +336,14 @@ private void CloneTableConstraint(Table newTable, TableConstraint sourceConstrai
         return;
       }
 
-      var uniqueConstraint = sourceConstraint as UniqueConstraint;
-      if (uniqueConstraint!=null) {
-        var primaryKey = sourceConstraint as PrimaryKey;
-        if (primaryKey!=null) {
-          var columns = primaryKey.Columns.Select(c => newTable.TableColumns[c.Name]).ToArray();
-          var pk =newTable.CreatePrimaryKey(primaryKey.Name, columns);
+      if (sourceConstraint is UniqueConstraint uniqueConstraint) {
+        if (sourceConstraint is PrimaryKey primaryKey) {
+          var columns = primaryKey.Columns.SelectToArray(c => newTable.TableColumns[c.Name]);
+          var pk = newTable.CreatePrimaryKey(primaryKey.Name, columns);
           CopyDbName(pk, primaryKey);
         }
         else {
-          var columns = uniqueConstraint.Columns.Select(c => newTable.TableColumns[c.Name]).ToArray();
+          var columns = uniqueConstraint.Columns.SelectToArray(c => newTable.TableColumns[c.Name]);
           var uc = newTable.CreateUniqueConstraint(uniqueConstraint.Name, columns);
           CopyDbName(uc, uniqueConstraint);
         }

Orm/Xtensive.Orm/Orm/Upgrade/Internals/DomainModelConverter.cs

@@ -113,17 +113,17 @@ protected override StorageModel VisitDomainModel(DomainModel domainModel)
       // Build hierarchy foreign keys
       var indexPairs = new Dictionary<Pair<IndexInfo>, object>();
       foreach (var type in domainModel.Types.Entities) {
-        if (type.Hierarchy==null || type.Hierarchy.InheritanceSchema==InheritanceSchema.ConcreteTable)
+        if (type.Hierarchy is null || type.Hierarchy.InheritanceSchema==InheritanceSchema.ConcreteTable)
           continue;
         if (type.Indexes.PrimaryIndex.IsVirtual) {
-          Dictionary<TypeInfo, int> typeOrder = type.Ancestors
+          var typeOrder = type.Ancestors
             .Append(type)
-            .Select((t, i) => (Type: t, Index: i))
-            .ToDictionary(a => a.Type, a => a.Index);
-          List<IndexInfo> realPrimaryIndexes = type.Indexes.RealPrimaryIndexes
+            .Select(static (t, i) => (Type: t, Index: i))
+            .ToDictionary(static a => a.Type, static a => a.Index, capacity: type.Ancestors.Count);
+          var realPrimaryIndexes = type.Indexes.RealPrimaryIndexes
             .OrderBy(index => typeOrder[index.ReflectedType])
-            .ToList();
-          for (int i = 0; i < realPrimaryIndexes.Count - 1; i++) {
+            .ToArray(type.Indexes.RealPrimaryIndexes.Count);
+          for (int i = 0, edge = realPrimaryIndexes.Length - 1; i < edge; i++) {
             if (realPrimaryIndexes[i]!=realPrimaryIndexes[i + 1]) {
               var pair = new Pair<IndexInfo>(realPrimaryIndexes[i], realPrimaryIndexes[i + 1]);
               indexPairs[pair] = null;
@@ -137,7 +137,7 @@ protected override StorageModel VisitDomainModel(DomainModel domainModel)
         var referencingTable = targetModel.Tables[resolver.GetNodeName(referencingIndex.ReflectedType)];
         var referencedTable = targetModel.Tables[resolver.GetNodeName(referencedIndex.ReflectedType)];
         var storageReferencingIndex = FindIndex(
-          referencingTable, referencingIndex.KeyColumns.Select(ci => ci.Key.Name).ToList());
+          referencingTable, referencingIndex.KeyColumns.Select(static ci => ci.Key.Name).ToArray());
 
         string foreignKeyName = nameBuilder.BuildHierarchyForeignKeyName(referencingIndex.ReflectedType, referencedIndex.ReflectedType);
         CreateHierarchyForeignKey(referencingTable, referencedTable, storageReferencingIndex, foreignKeyName);
@@ -320,19 +320,19 @@ private PrimaryIndexInfo VisitPrimaryIndexInfo(IndexInfo index)
       return primaryIndex;
     }
 
-    private IEnumerable<TableInfo> CreateTables(IndexInfo index)
+    private IReadOnlyList<TableInfo> CreateTables(IndexInfo index)
     {
-      var result = new List<TableInfo>();
       var type = index.ReflectedType;
-      if (configuration.IsMultidatabase && type.UnderlyingType.Namespace==MetadataNamespace) {
+      if (configuration.IsMultidatabase && type.UnderlyingType.Namespace == MetadataNamespace) {
+        var parts = new List<TableInfo>(sourceModel.Databases.Count);
         foreach (var db in sourceModel.Databases) {
           var name = resolver.GetNodeName(db.Name, type.MappingSchema, type.MappingName);
-          result.Add(new TableInfo(targetModel, name));
+          parts.Add(new TableInfo(targetModel, name));
         }
+        return parts;
       }
       else
-        result.Add(new TableInfo(targetModel, resolver.GetNodeName(type)));
-      return result;
+        return new[] { new TableInfo(targetModel, resolver.GetNodeName(type)) };
     }
 
     #region Not supported
@@ -401,17 +401,24 @@ private string GetColumnDefaultSqlExpression(ColumnInfo column)
 
     private static StorageIndexInfo FindIndex(TableInfo table, ICollection<string> keyColumns)
     {
-      var primaryKeyColumns = table.PrimaryIndex.KeyColumns.Select(cr => cr.Value.Name).ToList();
+      var primaryIndex = table.PrimaryIndex;
+      var primaryKeyColumns = primaryIndex.KeyColumns.Select(ColumnNameSelector).ToList(primaryIndex.KeyColumns.Count);
 
       if (!primaryKeyColumns.Except(keyColumns).Union(keyColumns.Except(primaryKeyColumns)).Any())
         return table.PrimaryIndex;
 
       foreach (SecondaryIndexInfo index in table.SecondaryIndexes) {
-        var secondaryKeyColumns = index.KeyColumns.Select(cr => cr.Value.Name).ToList();
+        var secondaryKeyColumns = index.KeyColumns.Select(ColumnNameSelector).ToList(index.KeyColumns.Count);
         if (!secondaryKeyColumns.Except(keyColumns).Union(keyColumns.Except(secondaryKeyColumns)).Any())
           return index;
       }
       return null;
+
+
+      static string ColumnNameSelector(KeyColumnRef cr)
+      {
+        return cr.Value.Name;
+      }
     }
 
     private TableInfo GetTable(TypeInfo type)
@@ -440,7 +447,7 @@ private static string GetPrimaryIndexColumnName(IndexInfo primaryIndex, ColumnIn
 
     private static void CreateReferenceForeignKey(TableInfo referencingTable, TableInfo referencedTable, FieldInfo referencingField, string foreignKeyName)
     {
-      var foreignColumns = referencingField.Columns.Select(column => referencingTable.Columns[column.Name]).ToList();
+      var foreignColumns = referencingField.Columns.SelectToArray(column => referencingTable.Columns[column.Name]);
       var foreignKey = new ForeignKeyInfo(referencingTable, foreignKeyName) {
         PrimaryKey = referencedTable.PrimaryIndex,
         OnRemoveAction = ReferentialAction.None,