Obsolete CollectionExtensions class and methods (#684)

+semver:feature
nhibernate · May 7, 2024 · cee3136 · cee3136
1 parent 1b80020
commit cee3136
Show file tree

Hide file tree

Showing 21 changed files with 94 additions and 85 deletions.
diff --git a/src/FluentNHibernate.Specs/Visitors/BiDirectionalManyToManyPairingVisitorSpecs.cs b/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
     }
 }

diff --git a/src/FluentNHibernate.Testing/Visitors/ComponentColumnPrefixVisitorSpecs.cs b/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"));
     }
 }
 

diff --git a/src/FluentNHibernate/Automapping/AutoMapper.cs b/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;
     }
 }
diff --git a/src/FluentNHibernate/Automapping/AutoMapping.cs b/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;
     }

diff --git a/src/FluentNHibernate/Automapping/Steps/VersionStep.cs b/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);
         }
 

diff --git a/src/FluentNHibernate/Conventions/ConventionsCollection.cs b/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);
     }
 }
diff --git a/src/FluentNHibernate/Mapping/AnyPart.cs b/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)));
         }
 

diff --git a/src/FluentNHibernate/Mapping/CompositeIdentityPart.cs b/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;
     }

diff --git a/src/FluentNHibernate/Mapping/IndexManyToManyPart.cs b/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);

diff --git a/src/FluentNHibernate/Mapping/IndexPart.cs b/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);

diff --git a/src/FluentNHibernate/Mapping/JoinPart.cs b/src/FluentNHibernate/Mapping/JoinPart.cs
@@ -2,7 +2,6 @@
 using System.Diagnostics;
 using FluentNHibernate.Mapping.Providers;
 using FluentNHibernate.MappingModel;
-using FluentNHibernate.Utils;
 
 namespace FluentNHibernate.Mapping;
 
@@ -49,7 +48,7 @@ public JoinPart<T> KeyColumn(string column)
     public JoinPart<T> KeyColumn(params string[] columnNames)
     {
         columns.Clear(); // only one supported currently
-        columnNames.Each(columns.Add);
+        columns.AddRange(columnNames);
         return this;
     }
 

diff --git a/src/FluentNHibernate/Mapping/Member.cs b/src/FluentNHibernate/Mapping/Member.cs
@@ -355,12 +355,12 @@ public static IEnumerable<Member> GetInstanceMembers(this Type type)
     {
         var members = new HashSet<Member>(new MemberEqualityComparer());
 
-        type.GetInstanceProperties().Each(x => members.Add(x));
-        type.GetInstanceFields().Each(x => members.Add(x));
-        type.GetInstanceMethods().Each(x => members.Add(x));
+        members.UnionWith(type.GetInstanceProperties());
+        members.UnionWith(type.GetInstanceFields());
+        members.UnionWith(type.GetInstanceMethods());
 
         if (type.BaseType is not null && type.BaseType != typeof(object))
-            type.BaseType.GetInstanceMembers().Each(x => members.Add(x));
+            members.UnionWith(type.BaseType.GetInstanceMembers());
 
         return members;
     }

diff --git a/src/FluentNHibernate/Mapping/NaturalIdPart.cs b/src/FluentNHibernate/Mapping/NaturalIdPart.cs
@@ -114,8 +114,8 @@ NaturalIdMapping INaturalIdMappingProvider.GetNaturalIdMapping()
     {
         var mapping = new NaturalIdMapping(attributes.Clone());
 
-        properties.Each(p => mapping.AddProperty(((IPropertyMappingProvider)p).GetPropertyMapping()));
-        manyToOnes.Each(mapping.AddReference);
+        properties.ForEach(p => mapping.AddProperty(((IPropertyMappingProvider)p).GetPropertyMapping()));
+        manyToOnes.ForEach(mapping.AddReference);
 
         return mapping;
     }

diff --git a/src/FluentNHibernate/Mapping/SubClassPart.cs b/src/FluentNHibernate/Mapping/SubClassPart.cs
@@ -58,7 +58,7 @@ SubclassMapping ISubclassMappingProvider.GetSubclassMapping()
         foreach (var any in providers.Anys)
             mapping.AddAny(any.GetAnyMapping());
 
-        subclassMappings.Each(mapping.AddSubclass);
+        subclassMappings.ForEach(mapping.AddSubclass);
 
         return mapping;
     }

diff --git a/src/FluentNHibernate/MappingModel/DiscriminatorMapping.cs b/src/FluentNHibernate/MappingModel/DiscriminatorMapping.cs
@@ -16,7 +16,8 @@ public override void AcceptVisitor(IMappingModelVisitor visitor)
     {
         visitor.ProcessDiscriminator(this);
 
-        Columns.Each(visitor.Visit);
+        foreach (var column in Columns)
+            visitor.Visit(column);
     }
 
     public bool Force => attributes.GetOrDefault<bool>();

diff --git a/src/FluentNHibernate/MappingModel/VersionMapping.cs b/src/FluentNHibernate/MappingModel/VersionMapping.cs
@@ -16,7 +16,8 @@ public override void AcceptVisitor(IMappingModelVisitor visitor)
     {
         visitor.ProcessVersion(this);
 
-        Columns.Each(visitor.Visit);
+        foreach (var column in Columns)
+            visitor.Visit(column);
     }
 
     public string Name => attributes.GetOrDefault<string>();

diff --git a/src/FluentNHibernate/PersistenceModel.cs b/src/FluentNHibernate/PersistenceModel.cs
@@ -77,12 +77,14 @@ public void AddMappingsFromAssembly(Assembly assembly)
 
     public void AddMappingsFromSource(ITypeSource source)
     {
-        source.GetTypes()
+        var types = source.GetTypes()
             .Where(x => IsMappingOf<IMappingProvider>(x) ||
                         IsMappingOf<IIndeterminateSubclassMappingProvider>(x) ||
                         IsMappingOf<IExternalComponentMappingProvider>(x) ||
-                        IsMappingOf<IFilterDefinition>(x))
-            .Each(Add);
+                        IsMappingOf<IFilterDefinition>(x));
+
+        foreach (var type in types)
+            Add(type);
 
         log.LoadedFluentMappingsFromSource(source);
     }
@@ -312,23 +314,23 @@ public bool ValidationEnabled
 
     internal void ImportProviders(PersistenceModel model)
     {
-        model.classProviders.Each(x =>
+        foreach (var provider in model.classProviders)
         {
-            if (!classProviders.Contains(x))
-                classProviders.Add(x);
-        });
+            if (!classProviders.Contains(provider))
+                classProviders.Add(provider);
+        }
 
-        model.subclassProviders.Each(x =>
+        foreach (var provider in model.subclassProviders)
         {
-            if (!subclassProviders.Contains(x))
-                subclassProviders.Add(x);
-        });
+            if (!subclassProviders.Contains(provider)) 
+                subclassProviders.Add(provider);
+        }
 
-        model.componentProviders.Each(x =>
+        foreach (var provider in model.componentProviders)
         {
-            if (!componentProviders.Contains(x))
-                componentProviders.Add(x);
-        });
+            if (!componentProviders.Contains(provider))
+                componentProviders.Add(provider);
+        }
     }
 }
 

diff --git a/src/FluentNHibernate/Utils/CollectionExtensions.cs b/src/FluentNHibernate/Utils/CollectionExtensions.cs
@@ -5,16 +5,19 @@
 
 namespace FluentNHibernate.Utils;
 
+[Obsolete("This class is not used and will be removed in a future version")]
 public static class CollectionExtensions
 {
     [DebuggerStepThrough]
+    [Obsolete("This method is not used and will be removed in a future version")]
     public static void Each<T>(this IEnumerable<T> enumerable, Action<T> each)
     {
         foreach (var item in enumerable)
             each(item);
     }
 
     [DebuggerStepThrough]
+    [Obsolete("This method is not used and will be removed in a future version")]
     public static IEnumerable<T> Except<T>(this IEnumerable<T> enumerable, params T[] singles)
     {
         return enumerable.Except((IEnumerable<T>)singles);