Obsolete CollectionExtensions class and methods (#684)

+semver:feature

Author: hazzik

src/FluentNHibernate.Specs/Visitors/BiDirectionalManyToManyPairingVisitorSpecs.cs

@@ -282,7 +282,8 @@ protected static CollectionMapping collection<T>(Expression<Func<T, object>> exp
 
     protected static void Visit(params CollectionMapping[] mappings)
     {
-        mappings.Each(visitor.Visit);
+        foreach (var item in mappings)
+            visitor.Visit(item);
         visitor.Visit(Array.Empty<HibernateMapping>()); // simulate end of visit
     }
 }

src/FluentNHibernate.Testing/Visitors/ComponentColumnPrefixVisitorSpecs.cs

@@ -4,7 +4,6 @@
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.ClassBased;
 using FluentNHibernate.MappingModel.Collections;
-using FluentNHibernate.Utils;
 using FluentNHibernate.Visitors;
 using NUnit.Framework;
 
@@ -45,9 +44,9 @@ public override void because()
     [Test]
     public void should_prefix_property_columns()
     {
-        target_mapping.Components.Single()
-            .Properties.SelectMany(x => x.Columns)
-            .Each(x => x.Name.ShouldStartWith("Component_"));
+        var columns = target_mapping.Components.Single()
+            .Properties.SelectMany(x => x.Columns);
+        Assert.That(columns, Has.All.Property("Name").StartWith("Component_"));
     }
 }
 
@@ -94,11 +93,11 @@ public override void because()
     [Test]
     public void should_prefix_sub_component_columns_with_both_prefixes()
     {
-        target_mapping
+        var columns = target_mapping
             .Components.Single()
             .Components.Single()
-            .Properties.SelectMany(x => x.Columns)
-            .Each(x => x.Name.ShouldStartWith(first_prefix + second_prefix));
+            .Properties.SelectMany(x => x.Columns);
+        Assert.That(columns, Has.All.Property("Name").StartWith(first_prefix + second_prefix));
     }
 }
 
@@ -133,8 +132,8 @@ public override void because()
     [Test]
     public void shouldnt_use_the_original_prefix()
     {
-        reference_without_a_prefix.Properties.SelectMany(x => x.Columns)
-            .Each(x => x.Name.ShouldNotStartWith(column_prefix));
+        var columns = reference_without_a_prefix.Properties.SelectMany(x => x.Columns);
+        Assert.That(columns, Has.None.Property("Name").StartWith(column_prefix));
     }
 }
 
@@ -175,31 +174,31 @@ public override void because()
     [Test]
     public void should_prefix_collection_columns()
     {
-        target_mapping.Components.Single().Collections.ShouldHaveCount(1);
-        target_mapping.Components.Single().Collections
-            .SelectMany(x => x.Key.Columns)
-            .Each(x => x.Name.ShouldStartWith(column_prefix));
+        Assert.That(target_mapping.Components.Single().Collections.Count(), Is.EqualTo(1));
+        var keyColumns = target_mapping.Components.Single().Collections
+            .SelectMany(x => x.Key.Columns);
+        Assert.That(keyColumns, Has.All.Property("Name").StartWith(column_prefix));
     }
 
     [Test]
     public void should_prefix_columns_inside_an_inner_component()
     {
         target_mapping.Components.ShouldHaveCount(1);
         target_mapping.Components.SelectMany(x => x.Components).ShouldHaveCount(1);
-        target_mapping.Components
+        var columns = target_mapping.Components
             .SelectMany(x => x.Components)
             .SelectMany(x => x.Properties)
-            .SelectMany(x => x.Columns)
-            .Each(x => x.Name.ShouldStartWith(column_prefix));
+            .SelectMany(x => x.Columns);
+        Assert.That(columns, Has.All.Property("Name").StartWith(column_prefix));
     }
 
     [Test]
     public void should_prefix_property_columns()
     {
         target_mapping.Components.Single().Properties.ShouldHaveCount(1);
-        target_mapping.Components.Single()
-            .Properties.SelectMany(x => x.Columns)
-            .Each(x => x.Name.ShouldStartWith(column_prefix));
+        var columns = target_mapping.Components.Single()
+            .Properties.SelectMany(x => x.Columns);
+        Assert.That(columns, Has.All.Property("Name").StartWith(column_prefix));
     }
 }
 
@@ -236,9 +235,8 @@ public override void because()
     [Test]
     public void should_prefix_field_columns()
     {
-        targetMapping.Components.Single()
-            .Properties.SelectMany(x => x.Columns)
-            .Each(c => c.Name.ShouldStartWith("component"));
+        var columns = targetMapping.Components.Single().Properties.SelectMany(x => x.Columns);
+        Assert.That(columns, Has.All.Property("Name").StartWith("component"));
     }
 }
 

src/FluentNHibernate/Automapping/AutoMapper.cs

@@ -4,7 +4,6 @@
 using FluentNHibernate.Conventions;
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.ClassBased;
-using FluentNHibernate.Utils;
 using FluentNHibernate.Utils.Reflection;
 
 namespace FluentNHibernate.Automapping;
@@ -21,9 +20,9 @@ void ApplyOverrides(Type classType, IList<Member> mappedMembers, ClassMappingBas
         var autoMapType = ReflectionHelper.AutomappingTypeForEntityType(classType);
         var autoMap = Activator.CreateInstance(autoMapType, mappedMembers);
 
-        inlineOverrides
-            .Where(x => x.CanOverride(classType))
-            .Each(x => x.Apply(autoMap));
+        var overrides = inlineOverrides.Where(x => x.CanOverride(classType));
+        foreach (var @override in overrides)
+            @override.Apply(autoMap);
 
         ((IAutoClasslike)autoMap).AlterModel(mapping);
     }
@@ -147,9 +146,9 @@ void MapSubclass(IList<Member> mappedMembers, SubclassMapping subclass, AutoMapT
 
     public virtual void ProcessClass(ClassMappingBase mapping, Type entityType, IList<Member> mappedMembers)
     {
-        entityType.GetInstanceMembers()
-            .Where(cfg.ShouldMap)
-            .Each(x => TryMapProperty(mapping, x, mappedMembers));
+        var members = entityType.GetInstanceMembers().Where(cfg.ShouldMap);
+        foreach (var member in members)
+            TryMapProperty(mapping, member, mappedMembers);
     }
 
     void TryMapProperty(ClassMappingBase mapping, Member member, IList<Member> mappedMembers)
@@ -204,8 +203,8 @@ static string GetDefaultTableName(Type type)
     /// </summary>
     public void FlagAsMapped(Type type)
     {
-        mappingTypes
-            .Where(x => x.Type == type)
-            .Each(x => x.IsMapped = true);
+        var autoMapTypes = mappingTypes.Where(x => x.Type == type);
+        foreach (var autoMapType in autoMapTypes)
+            autoMapType.IsMapped = true;
     }
 }

src/FluentNHibernate/Automapping/AutoMapping.cs

@@ -118,10 +118,11 @@ IPropertyIgnorer IPropertyIgnorer.IgnoreProperties(string first, params string[]
 
     IPropertyIgnorer IPropertyIgnorer.IgnoreProperties(Func<Member, bool> predicate)
     {
-        typeof(T).GetProperties()
+        var members = typeof(T).GetProperties()
             .Select(x => x.ToMember())
-            .Where(predicate)
-            .Each(mappedMembers.Add);
+            .Where(predicate);
+        foreach (var member in members)
+            mappedMembers.Add(member);
 
         return this;
     }

src/FluentNHibernate/Automapping/Steps/VersionStep.cs

@@ -1,7 +1,6 @@
 using FluentNHibernate.Mapping;
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.ClassBased;
-using FluentNHibernate.Utils;
 
 namespace FluentNHibernate.Automapping.Steps;
 
@@ -30,11 +29,12 @@ public void Map(ClassMappingBase classMap, Member member)
 
         if (IsSqlTimestamp(member))
         {
-            version.Columns.Each(column =>
+            foreach (var column in version.Columns)
             {
                 column.Set(x => x.SqlType, Layer.Defaults, "timestamp");
                 column.Set(x => x.NotNull, Layer.Defaults, true);
-            });
+            }
+
             version.Set(x => x.UnsavedValue, Layer.Defaults, null);
         }
 

src/FluentNHibernate/Conventions/ConventionsCollection.cs

@@ -66,7 +66,7 @@ public IEnumerable<object> GetInstances()
 
     public void Merge(ConventionsCollection conventions)
     {
-        conventions.inner.Each(inner.Add);
-        conventions.types.Each(types.Add);
+        conventions.inner.ForEach(inner.Add);
+        conventions.types.ForEach(types.Add);
     }
 }

src/FluentNHibernate/Mapping/AnyPart.cs

@@ -170,9 +170,9 @@ AnyMapping IAnyMappingProvider.GetAnyMapping()
             mapping.Set(x => x.MetaType, Layer.Defaults, new TypeReference(member.PropertyType));
         }
 
-        if (metaValues.Count() > 0)
+        if (metaValues.Count > 0)
         {
-            metaValues.Each(mapping.AddMetaValue);
+            metaValues.ForEach(mapping.AddMetaValue);
             mapping.Set(x => x.MetaType, Layer.Defaults, new TypeReference(typeof(string)));
         }
 

src/FluentNHibernate/Mapping/CompositeIdentityPart.cs

@@ -252,7 +252,7 @@ CompositeIdMapping ICompositeIdMappingProvider.GetCompositeIdMapping()
             ContainingEntityType = typeof(T)
         };
 
-        keys.Each(mapping.AddKey);
+        keys.ForEach(mapping.AddKey);
 
         return mapping;
     }

src/FluentNHibernate/Mapping/IndexManyToManyPart.cs

@@ -47,7 +47,7 @@ public IndexManyToManyMapping GetIndexMapping()
             ContainingEntityType = entity
         };
 
-        columns.Each(name =>
+        columns.ForEach(name =>
         {
             var columnMapping = new ColumnMapping();
             columnMapping.Set(x => x.Name, Layer.Defaults, name);

src/FluentNHibernate/Mapping/IndexPart.cs

@@ -36,7 +36,7 @@ public IndexMapping GetIndexMapping()
 
         mapping.ContainingEntityType = entity;
 
-        columns.Each(name =>
+        columns.ForEach(name =>
         {
             var columnMapping = new ColumnMapping();
             columnMapping.Set(x => x.Name, Layer.Defaults, name);