Obsolete CollectionExtensions class and methods (#684)

hazzik · web-flow · commit cee31368889c · 2024-05-07T17:07:45.000+02:00
+semver:feature
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);
diff --git a/src/FluentNHibernate/Visitors/DefaultMappingModelVisitor.cs b/src/FluentNHibernate/Visitors/DefaultMappingModelVisitor.cs
diff --git a/src/FluentNHibernate/Visitors/RelationshipKeyPairingVisitor.cs b/src/FluentNHibernate/Visitors/RelationshipKeyPairingVisitor.cs
diff --git a/src/FluentNHibernate/Visitors/RelationshipPairingVisitor.cs b/src/FluentNHibernate/Visitors/RelationshipPairingVisitor.cs

Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,8 @@ protected static CollectionMapping collection<T>(Expression<Func<T, object>> exp`
`282`	`282`
`283`	`283`	`protected static void Visit(params CollectionMapping[] mappings)`
`284`	`284`	`{`
`285`		`- mappings.Each(visitor.Visit);`
	`285`	`+ foreach (var item in mappings)`
	`286`	`+ visitor.Visit(item);`
`286`	`287`	`visitor.Visit(Array.Empty<HibernateMapping>()); // simulate end of visit`
`287`	`288`	`}`
`288`	`289`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`	`using FluentNHibernate.MappingModel;`
`5`	`5`	`using FluentNHibernate.MappingModel.ClassBased;`
`6`	`6`	`using FluentNHibernate.MappingModel.Collections;`
`7`		`-using FluentNHibernate.Utils;`
`8`	`7`	`using FluentNHibernate.Visitors;`
`9`	`8`	`using NUnit.Framework;`
`10`	`9`
`@@ -45,9 +44,9 @@ public override void because()`
`45`	`44`	`[Test]`
`46`	`45`	`public void should_prefix_property_columns()`
`47`	`46`	`{`
`48`		`- target_mapping.Components.Single()`
`49`		`- .Properties.SelectMany(x => x.Columns)`
`50`		`- .Each(x => x.Name.ShouldStartWith("Component_"));`
	`47`	`+ var columns = target_mapping.Components.Single()`
	`48`	`+ .Properties.SelectMany(x => x.Columns);`
	`49`	`+ Assert.That(columns, Has.All.Property("Name").StartWith("Component_"));`
`51`	`50`	`}`
`52`	`51`	`}`
`53`	`52`
`@@ -94,11 +93,11 @@ public override void because()`
`94`	`93`	`[Test]`
`95`	`94`	`public void should_prefix_sub_component_columns_with_both_prefixes()`
`96`	`95`	`{`
`97`		`- target_mapping`
	`96`	`+ var columns = target_mapping`
`98`	`97`	`.Components.Single()`
`99`	`98`	`.Components.Single()`
`100`		`- .Properties.SelectMany(x => x.Columns)`
`101`		`- .Each(x => x.Name.ShouldStartWith(first_prefix + second_prefix));`
	`99`	`+ .Properties.SelectMany(x => x.Columns);`
	`100`	`+ Assert.That(columns, Has.All.Property("Name").StartWith(first_prefix + second_prefix));`
`102`	`101`	`}`
`103`	`102`	`}`
`104`	`103`
`@@ -133,8 +132,8 @@ public override void because()`
`133`	`132`	`[Test]`
`134`	`133`	`public void shouldnt_use_the_original_prefix()`
`135`	`134`	`{`
`136`		`- reference_without_a_prefix.Properties.SelectMany(x => x.Columns)`
`137`		`- .Each(x => x.Name.ShouldNotStartWith(column_prefix));`
	`135`	`+ var columns = reference_without_a_prefix.Properties.SelectMany(x => x.Columns);`
	`136`	`+ Assert.That(columns, Has.None.Property("Name").StartWith(column_prefix));`
`138`	`137`	`}`
`139`	`138`	`}`
`140`	`139`
`@@ -175,31 +174,31 @@ public override void because()`
`175`	`174`	`[Test]`
`176`	`175`	`public void should_prefix_collection_columns()`
`177`	`176`	`{`
`178`		`- target_mapping.Components.Single().Collections.ShouldHaveCount(1);`
`179`		`- target_mapping.Components.Single().Collections`
`180`		`- .SelectMany(x => x.Key.Columns)`
`181`		`- .Each(x => x.Name.ShouldStartWith(column_prefix));`
	`177`	`+ Assert.That(target_mapping.Components.Single().Collections.Count(), Is.EqualTo(1));`
	`178`	`+ var keyColumns = target_mapping.Components.Single().Collections`
	`179`	`+ .SelectMany(x => x.Key.Columns);`
	`180`	`+ Assert.That(keyColumns, Has.All.Property("Name").StartWith(column_prefix));`
`182`	`181`	`}`
`183`	`182`
`184`	`183`	`[Test]`
`185`	`184`	`public void should_prefix_columns_inside_an_inner_component()`
`186`	`185`	`{`
`187`	`186`	`target_mapping.Components.ShouldHaveCount(1);`
`188`	`187`	`target_mapping.Components.SelectMany(x => x.Components).ShouldHaveCount(1);`
`189`		`- target_mapping.Components`
	`188`	`+ var columns = target_mapping.Components`
`190`	`189`	`.SelectMany(x => x.Components)`
`191`	`190`	`.SelectMany(x => x.Properties)`
`192`		`- .SelectMany(x => x.Columns)`
`193`		`- .Each(x => x.Name.ShouldStartWith(column_prefix));`
	`191`	`+ .SelectMany(x => x.Columns);`
	`192`	`+ Assert.That(columns, Has.All.Property("Name").StartWith(column_prefix));`
`194`	`193`	`}`
`195`	`194`
`196`	`195`	`[Test]`
`197`	`196`	`public void should_prefix_property_columns()`
`198`	`197`	`{`
`199`	`198`	`target_mapping.Components.Single().Properties.ShouldHaveCount(1);`
`200`		`- target_mapping.Components.Single()`
`201`		`- .Properties.SelectMany(x => x.Columns)`
`202`		`- .Each(x => x.Name.ShouldStartWith(column_prefix));`
	`199`	`+ var columns = target_mapping.Components.Single()`
	`200`	`+ .Properties.SelectMany(x => x.Columns);`
	`201`	`+ Assert.That(columns, Has.All.Property("Name").StartWith(column_prefix));`
`203`	`202`	`}`
`204`	`203`	`}`
`205`	`204`
`@@ -236,9 +235,8 @@ public override void because()`
`236`	`235`	`[Test]`
`237`	`236`	`public void should_prefix_field_columns()`
`238`	`237`	`{`
`239`		`- targetMapping.Components.Single()`
`240`		`- .Properties.SelectMany(x => x.Columns)`
`241`		`- .Each(c => c.Name.ShouldStartWith("component"));`
	`238`	`+ var columns = targetMapping.Components.Single().Properties.SelectMany(x => x.Columns);`
	`239`	`+ Assert.That(columns, Has.All.Property("Name").StartWith("component"));`
`242`	`240`	`}`
`243`	`241`	`}`
`244`	`242`
Original file line number	Diff line number	Diff line change
`@@ -118,10 +118,11 @@ IPropertyIgnorer IPropertyIgnorer.IgnoreProperties(string first, params string[]`
`118`	`118`
`119`	`119`	`IPropertyIgnorer IPropertyIgnorer.IgnoreProperties(Func<Member, bool> predicate)`
`120`	`120`	`{`
`121`		`- typeof(T).GetProperties()`
	`121`	`+ var members = typeof(T).GetProperties()`
`122`	`122`	`.Select(x => x.ToMember())`
`123`		`- .Where(predicate)`
`124`		`- .Each(mappedMembers.Add);`
	`123`	`+ .Where(predicate);`
	`124`	`+ foreach (var member in members)`
	`125`	`+ mappedMembers.Add(member);`
`125`	`126`
`126`	`127`	`return this;`
`127`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`using FluentNHibernate.Mapping;`
`2`	`2`	`using FluentNHibernate.MappingModel;`
`3`	`3`	`using FluentNHibernate.MappingModel.ClassBased;`
`4`		`-using FluentNHibernate.Utils;`
`5`	`4`
`6`	`5`	`namespace FluentNHibernate.Automapping.Steps;`
`7`	`6`
`@@ -30,11 +29,12 @@ public void Map(ClassMappingBase classMap, Member member)`
`30`	`29`
`31`	`30`	`if (IsSqlTimestamp(member))`
`32`	`31`	`{`
`33`		`- version.Columns.Each(column =>`
	`32`	`+ foreach (var column in version.Columns)`
`34`	`33`	`{`
`35`	`34`	`column.Set(x => x.SqlType, Layer.Defaults, "timestamp");`
`36`	`35`	`column.Set(x => x.NotNull, Layer.Defaults, true);`
`37`		`- });`
	`36`	`+ }`
	`37`	`+`
`38`	`38`	`version.Set(x => x.UnsavedValue, Layer.Defaults, null);`
`39`	`39`	`}`
`40`	`40`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ public IEnumerable<object> GetInstances()`
`66`	`66`
`67`	`67`	`public void Merge(ConventionsCollection conventions)`
`68`	`68`	`{`
`69`		`- conventions.inner.Each(inner.Add);`
`70`		`- conventions.types.Each(types.Add);`
	`69`	`+ conventions.inner.ForEach(inner.Add);`
	`70`	`+ conventions.types.ForEach(types.Add);`
`71`	`71`	`}`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -170,9 +170,9 @@ AnyMapping IAnyMappingProvider.GetAnyMapping()`
`170`	`170`	`mapping.Set(x => x.MetaType, Layer.Defaults, new TypeReference(member.PropertyType));`
`171`	`171`	`}`
`172`	`172`
`173`		`- if (metaValues.Count() > 0)`
	`173`	`+ if (metaValues.Count > 0)`
`174`	`174`	`{`
`175`		`- metaValues.Each(mapping.AddMetaValue);`
	`175`	`+ metaValues.ForEach(mapping.AddMetaValue);`
`176`	`176`	`mapping.Set(x => x.MetaType, Layer.Defaults, new TypeReference(typeof(string)));`
`177`	`177`	`}`
`178`	`178`
Original file line number	Diff line number	Diff line change
`@@ -252,7 +252,7 @@ CompositeIdMapping ICompositeIdMappingProvider.GetCompositeIdMapping()`
`252`	`252`	`ContainingEntityType = typeof(T)`
`253`	`253`	`};`
`254`	`254`
`255`		`- keys.Each(mapping.AddKey);`
	`255`	`+ keys.ForEach(mapping.AddKey);`
`256`	`256`
`257`	`257`	`return mapping;`
`258`	`258`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public IndexManyToManyMapping GetIndexMapping()`
`47`	`47`	`ContainingEntityType = entity`
`48`	`48`	`};`
`49`	`49`
`50`		`- columns.Each(name =>`
	`50`	`+ columns.ForEach(name =>`
`51`	`51`	`{`
`52`	`52`	`var columnMapping = new ColumnMapping();`
`53`	`53`	`columnMapping.Set(x => x.Name, Layer.Defaults, name);`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public IndexMapping GetIndexMapping()`
`36`	`36`
`37`	`37`	`mapping.ContainingEntityType = entity;`
`38`	`38`
`39`		`- columns.Each(name =>`
	`39`	`+ columns.ForEach(name =>`
`40`	`40`	`{`
`41`	`41`	`var columnMapping = new ColumnMapping();`
`42`	`42`	`columnMapping.Set(x => x.Name, Layer.Defaults, name);`