NH-3807 - Replace use of Array.ForEach with EnumerableExtensions.ForEach.

ngbrown · ngbrown · commit 1eeecd33e4f7 · 2016-08-21T14:47:51.000-07:00
Array.ForEach has been removed from CoreClr.
diff --git a/src/NHibernate/Cfg/XmlHbmBinding/ColumnsBinder.cs b/src/NHibernate/Cfg/XmlHbmBinding/ColumnsBinder.cs
@@ -76,7 +76,7 @@ private static void BindIndex(string indexAttribute, Table table, Column column)
 			if (indexAttribute != null && table != null)
 			{
 				var tokens = indexAttribute.Split(',');
-				System.Array.ForEach(tokens, t => table.GetOrCreateIndex(t.Trim()).AddColumn(column));
+				tokens.ForEach(t => table.GetOrCreateIndex(t.Trim()).AddColumn(column));
 			}
 		}
 
@@ -85,8 +85,8 @@ private static void BindUniqueKey(string uniqueKeyAttribute, Table table, Column
 			if (uniqueKeyAttribute != null && table != null)
 			{
 				var tokens = uniqueKeyAttribute.Split(',');
-				System.Array.ForEach(tokens, t => table.GetOrCreateUniqueKey(t.Trim()).AddColumn(column));
+				tokens.ForEach(t => table.GetOrCreateUniqueKey(t.Trim()).AddColumn(column));
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Cfg/XmlHbmBinding/MappingRootBinder.cs b/src/NHibernate/Cfg/XmlHbmBinding/MappingRootBinder.cs
@@ -109,13 +109,13 @@ private void AddSubclasses(HbmSubclass subClass, IDictionary<string, MetaAttribu
 		private void AddQueries(HbmMapping mappingSchema)
 		{
 			var binder = new NamedQueryBinder(Mappings);
-			System.Array.ForEach(mappingSchema.HqlQueries, binder.AddQuery);
+			mappingSchema.HqlQueries.ForEach(binder.AddQuery);
 		}
 
 		private void AddSqlQueries(HbmMapping mappingSchema)
 		{
 			var binder = new NamedSQLQueryBinder(Mappings);
-			System.Array.ForEach(mappingSchema.SqlQueries, binder.AddSqlQuery);
+			mappingSchema.SqlQueries.ForEach(binder.AddSqlQuery);
 		}
 
 		public void AddImports(HbmMapping mappingSchema)
@@ -172,4 +172,4 @@ private void AddResultSetMappingDefinitions(HbmMapping mappingSchema)
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Cfg/XmlHbmBinding/PropertiesBinder.cs b/src/NHibernate/Cfg/XmlHbmBinding/PropertiesBinder.cs
@@ -365,12 +365,13 @@ private void BindComponentProperty(HbmComponent componentMapping, Property prope
 			HbmTuplizer[] tuplizers = componentMapping.tuplizer;
 			if (tuplizers != null)
 			{
-				Array.ForEach(tuplizers.Select(tuplizer => new
-				                                           	{
-				                                           		TuplizerClassName = FullQualifiedClassName(tuplizer.@class, mappings),
-				                                           		Mode = tuplizer.entitymode.ToEntityMode()
-				                                           	}).ToArray(),
-				              x => model.AddTuplizer(x.Mode, x.TuplizerClassName));
+				tuplizers.Select(
+					         tuplizer => new
+					         {
+						         TuplizerClassName = FullQualifiedClassName(tuplizer.@class, mappings),
+						         Mode = tuplizer.entitymode.ToEntityMode()
+					         })
+							 .ForEach(x => model.AddTuplizer(x.Mode, x.TuplizerClassName));
 			}
 		}
 
diff --git a/src/NHibernate/Cfg/XmlHbmBinding/TypeBinder.cs b/src/NHibernate/Cfg/XmlHbmBinding/TypeBinder.cs
@@ -44,7 +44,7 @@ public void Bind(HbmType typeMapping)
 			var parameters = new Dictionary<string, string>();
 			if(typeMapping.param != null)
 			{
-				System.Array.ForEach(typeMapping.param, p => parameters[p.name] = p.Text.LinesToString());
+				typeMapping.param.ForEach(p => parameters[p.name] = p.Text.LinesToString());
 			}
 
 			BindThroughTypeDefOrType(originalTypeName, parameters);
@@ -83,4 +83,4 @@ private void BindThroughTypeDefOrType(string originalTypeName, IDictionary<strin
 			value.TypeName = typeToMap;
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Event/Default/DefaultLoadEventListener.cs b/src/NHibernate/Event/Default/DefaultLoadEventListener.cs
@@ -9,6 +9,7 @@
 using NHibernate.Persister.Entity;
 using NHibernate.Proxy;
 using NHibernate.Type;
+using NHibernate.Util;
 
 namespace NHibernate.Event.Default
 {
@@ -546,7 +547,7 @@ protected virtual IEntityPersister GetEntityPersister(ISessionFactoryImplementor
 				var messageBuilder = new StringBuilder(512);
 				messageBuilder.AppendLine(string.Format("Ambiguous persister for {0} implemented by more than one hierarchy: ",
 				                                        entityName));
-				Array.ForEach(implementors, s=> messageBuilder.AppendLine(s));
+				implementors.ForEach(s => messageBuilder.AppendLine(s));
 
 				throw new HibernateException(messageBuilder.ToString());
 			}
diff --git a/src/NHibernate/Linq/ReWriters/RemoveUnnecessaryBodyOperators.cs b/src/NHibernate/Linq/ReWriters/RemoveUnnecessaryBodyOperators.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Linq;
+using NHibernate.Util;
 using Remotion.Linq;
 using Remotion.Linq.Clauses;
 using Remotion.Linq.Clauses.ResultOperators;
@@ -31,14 +32,14 @@ public override void VisitResultOperator(ResultOperatorBase resultOperator, Quer
 			}
 			if (resultOperator is CastResultOperator)
 			{
-				Array.ForEach(queryModel.ResultOperators.OfType<CastResultOperator>().ToArray(), castOperator=> queryModel.ResultOperators.Remove(castOperator));
+				queryModel.ResultOperators.OfType<CastResultOperator>().ToArray().ForEach(castOperator => queryModel.ResultOperators.Remove(castOperator));
 			}
 			if (resultOperator is AnyResultOperator)
 			{
-				Array.ForEach(queryModel.ResultOperators.OfType<FetchOneRequest>().ToArray(), op => queryModel.ResultOperators.Remove(op));
-				Array.ForEach(queryModel.ResultOperators.OfType<FetchManyRequest>().ToArray(), op => queryModel.ResultOperators.Remove(op));
+				queryModel.ResultOperators.OfType<FetchOneRequest>().ToArray().ForEach(op => queryModel.ResultOperators.Remove(op));
+				queryModel.ResultOperators.OfType<FetchManyRequest>().ToArray().ForEach(op => queryModel.ResultOperators.Remove(op));
 			}
 			base.VisitResultOperator(resultOperator, queryModel, index);
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ByCode/AbstractExplicitlyDeclaredModel.cs b/src/NHibernate/Mapping/ByCode/AbstractExplicitlyDeclaredModel.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode
 {
@@ -228,7 +229,7 @@ protected virtual void AddAsTablePerClassEntity(System.Type type, bool rootEntit
 		{
 			if(!rootEntityMustExists)
 			{
-				delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitiesOf(type).ToArray(), root=> tablePerClassEntities.Add(root)));
+				delayedRootEntityRegistrations.Enqueue(() => GetRootEntitiesOf(type).ForEach(root => tablePerClassEntities.Add(root)));
 				EnlistTypeRegistration(type, t => AddAsTablePerClassEntity(t, true));
 				return;
 			}
@@ -263,7 +264,7 @@ protected virtual void AddAsTablePerClassHierarchyEntity(System.Type type, bool
 		{
 			if (!rootEntityMustExists)
 			{
-				delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitiesOf(type).ToArray(), root => tablePerClassHierarchyEntities.Add(root)));
+				delayedRootEntityRegistrations.Enqueue(() => GetRootEntitiesOf(type).ForEach(root => tablePerClassHierarchyEntities.Add(root)));
 				EnlistTypeRegistration(type, t => AddAsTablePerClassHierarchyEntity(t, true));
 				return;
 			}
@@ -299,7 +300,7 @@ protected virtual void AddAsTablePerConcreteClassEntity(System.Type type, bool r
 		{
 			if (!rootEntityMustExists)
 			{
-				delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitiesOf(type).ToArray(), root => tablePerConcreteClassEntities.Add(root)));
+				delayedRootEntityRegistrations.Enqueue(() => GetRootEntitiesOf(type).ForEach(root => tablePerConcreteClassEntities.Add(root)));
 				EnlistTypeRegistration(type, t => AddAsTablePerConcreteClassEntity(t, true));
 				return;
 			}
@@ -592,4 +593,4 @@ protected bool HasDelayedEntityRegistration(System.Type type)
 			return delayedEntityRegistrations.ContainsKey(type);
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ByCode/Impl/ClassMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/ClassMapper.cs
@@ -4,6 +4,7 @@
 using System.Reflection;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Persister.Entity;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -335,8 +336,10 @@ public void Synchronize(params string[] table)
 				return;
 			}
 			var existingSyncs = new HashSet<string>(classMapping.synchronize != null ? classMapping.synchronize.Select(x => x.table) : Enumerable.Empty<string>());
-			System.Array.ForEach(table.Where(x => x != null).Select(tableName => tableName.Trim()).Where(cleanedName => !"".Equals(cleanedName)).ToArray(),
-			                     x => existingSyncs.Add(x.Trim()));
+			table.Where(x => x != null)
+			     .Select(tableName => tableName.Trim())
+			     .Where(cleanedName => !"".Equals(cleanedName))
+			     .ForEach(x => existingSyncs.Add(x.Trim()));
 			classMapping.synchronize = existingSyncs.Select(x => new HbmSynchronize {table = x}).ToArray();
 		}
 
@@ -391,4 +394,4 @@ public void Subselect(string sql)
 
 		#endregion
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ByCode/Impl/JoinedSubclassMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/JoinedSubclassMapper.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Persister.Entity;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -92,8 +93,10 @@ public void Synchronize(params string[] table)
 				return;
 			}
 			var existingSyncs = new HashSet<string>(classMapping.synchronize != null ? classMapping.synchronize.Select(x => x.table) : Enumerable.Empty<string>());
-			System.Array.ForEach(table.Where(x => x != null).Select(tableName => tableName.Trim()).Where(cleanedName => !"".Equals(cleanedName)).ToArray(),
-													 x => existingSyncs.Add(x.Trim()));
+			table.Where(x => x != null)
+			     .Select(tableName => tableName.Trim())
+			     .Where(cleanedName => !"".Equals(cleanedName))
+			     .ForEach(x => existingSyncs.Add(x.Trim()));
 			classMapping.synchronize = existingSyncs.Select(x => new HbmSynchronize { table = x }).ToArray();
 		}
 
@@ -209,4 +212,4 @@ public void Filter(string filterName, Action<IFilterMapper> filterMapping)
 		}
 		#endregion
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ByCode/Impl/SubclassMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/SubclassMapper.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Persister.Entity;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -135,8 +136,10 @@ public void Synchronize(params string[] table)
 				return;
 			}
 			var existingSyncs = new HashSet<string>(classMapping.synchronize != null ? classMapping.synchronize.Select(x => x.table) : Enumerable.Empty<string>());
-			System.Array.ForEach(table.Where(x => x != null).Select(tableName => tableName.Trim()).Where(cleanedName => !"".Equals(cleanedName)).ToArray(),
-													 x => existingSyncs.Add(x.Trim()));
+			table.Where(x => x != null)
+			     .Select(tableName => tableName.Trim())
+			     .Where(cleanedName => !"".Equals(cleanedName))
+			     .ForEach(x => existingSyncs.Add(x.Trim()));
 			classMapping.synchronize = existingSyncs.Select(x => new HbmSynchronize { table = x }).ToArray();
 		}
 
@@ -197,4 +200,4 @@ public void Filter(string filterName, Action<IFilterMapper> filterMapping)
 		}
 		#endregion
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ByCode/Impl/UnionSubclassMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/UnionSubclassMapper.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Persister.Entity;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -93,8 +94,10 @@ public void Synchronize(params string[] table)
 				return;
 			}
 			var existingSyncs = new HashSet<string>(classMapping.synchronize != null ? classMapping.synchronize.Select(x => x.table) : Enumerable.Empty<string>());
-			System.Array.ForEach(table.Where(x => x != null).Select(tableName => tableName.Trim()).Where(cleanedName => !"".Equals(cleanedName)).ToArray(),
-													 x => existingSyncs.Add(x.Trim()));
+			table.Where(x => x != null)
+			     .Select(tableName => tableName.Trim())
+			     .Where(cleanedName => !"".Equals(cleanedName))
+			     .ForEach(x => existingSyncs.Add(x.Trim()));
 			classMapping.synchronize = existingSyncs.Select(x => new HbmSynchronize { table = x }).ToArray();
 		}
 
@@ -187,4 +190,4 @@ public void Extends(System.Type baseType)
 
 		#endregion
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ByCode/MappingsExtensions.cs b/src/NHibernate/Mapping/ByCode/MappingsExtensions.cs
@@ -5,6 +5,7 @@
 using System.Xml;
 using System.Xml.Serialization;
 using NHibernate.Cfg.MappingSchema;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode
 {
@@ -50,7 +51,7 @@ private static string ArrangeMappingsFolderPath()
 			}
 			else
 			{
-				System.Array.ForEach(Directory.GetFiles(mappingsFolderPath), File.Delete);
+				Directory.GetFiles(mappingsFolderPath).ForEach(File.Delete);
 			}
 			return mappingsFolderPath;
 		}
@@ -101,4 +102,4 @@ private static string Serialize(HbmMapping hbmElement)
 			return result;
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ByCode/ModelExplicitDeclarationsHolderExtensions.cs b/src/NHibernate/Mapping/ByCode/ModelExplicitDeclarationsHolderExtensions.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode
 {
@@ -11,39 +12,39 @@ public static void Merge(this IModelExplicitDeclarationsHolder destination, IMod
 				return;
 			}
 
-			System.Array.ForEach(source.RootEntities.ToArray(), destination.AddAsRootEntity);
-			System.Array.ForEach(source.Components.ToArray(), destination.AddAsComponent);
-			System.Array.ForEach(source.TablePerClassEntities.ToArray(), destination.AddAsTablePerClassEntity);
-			System.Array.ForEach(source.TablePerClassHierarchyEntities.ToArray(), destination.AddAsTablePerClassHierarchyEntity);
-			System.Array.ForEach(source.TablePerConcreteClassEntities.ToArray(), destination.AddAsTablePerConcreteClassEntity);
+			source.RootEntities.ForEach(destination.AddAsRootEntity);
+			source.Components.ForEach(destination.AddAsComponent);
+			source.TablePerClassEntities.ForEach(destination.AddAsTablePerClassEntity);
+			source.TablePerClassHierarchyEntities.ForEach(destination.AddAsTablePerClassHierarchyEntity);
+			source.TablePerConcreteClassEntities.ForEach(destination.AddAsTablePerConcreteClassEntity);
 
-			System.Array.ForEach(source.OneToOneRelations.ToArray(), destination.AddAsOneToOneRelation);
-			System.Array.ForEach(source.ManyToOneRelations.ToArray(), destination.AddAsManyToOneRelation);
-			System.Array.ForEach(source.KeyManyToManyRelations.ToArray(), destination.AddAsManyToManyKeyRelation);
-			System.Array.ForEach(source.ItemManyToManyRelations.ToArray(), destination.AddAsManyToManyItemRelation);
-			System.Array.ForEach(source.ManyToAnyRelations.ToArray(), destination.AddAsManyToAnyRelation);
-			System.Array.ForEach(source.OneToManyRelations.ToArray(), destination.AddAsOneToManyRelation);
-			System.Array.ForEach(source.Any.ToArray(), destination.AddAsAny);
+			source.OneToOneRelations.ForEach(destination.AddAsOneToOneRelation);
+			source.ManyToOneRelations.ForEach(destination.AddAsManyToOneRelation);
+			source.KeyManyToManyRelations.ForEach(destination.AddAsManyToManyKeyRelation);
+			source.ItemManyToManyRelations.ForEach(destination.AddAsManyToManyItemRelation);
+			source.ManyToAnyRelations.ForEach(destination.AddAsManyToAnyRelation);
+			source.OneToManyRelations.ForEach(destination.AddAsOneToManyRelation);
+			source.Any.ForEach(destination.AddAsAny);
 
-			System.Array.ForEach(source.Poids.ToArray(), destination.AddAsPoid);
-			System.Array.ForEach(source.ComposedIds.ToArray(), destination.AddAsPartOfComposedId);
-			System.Array.ForEach(source.VersionProperties.ToArray(), destination.AddAsVersionProperty);
-			System.Array.ForEach(source.NaturalIds.ToArray(), destination.AddAsNaturalId);
+			source.Poids.ForEach(destination.AddAsPoid);
+			source.ComposedIds.ForEach(destination.AddAsPartOfComposedId);
+			source.VersionProperties.ForEach(destination.AddAsVersionProperty);
+			source.NaturalIds.ForEach(destination.AddAsNaturalId);
 
-			System.Array.ForEach(source.Sets.ToArray(), destination.AddAsSet);
-			System.Array.ForEach(source.Bags.ToArray(), destination.AddAsBag);
-			System.Array.ForEach(source.IdBags.ToArray(), destination.AddAsIdBag);
-			System.Array.ForEach(source.Lists.ToArray(), destination.AddAsList);
-			System.Array.ForEach(source.Arrays.ToArray(), destination.AddAsArray);
-			System.Array.ForEach(source.Dictionaries.ToArray(), destination.AddAsMap);
-			System.Array.ForEach(source.Properties.ToArray(), destination.AddAsProperty);
-			System.Array.ForEach(source.PersistentMembers.ToArray(), destination.AddAsPersistentMember);
-			System.Array.ForEach(source.SplitDefinitions.ToArray(), destination.AddAsPropertySplit);
+			source.Sets.ForEach(destination.AddAsSet);
+			source.Bags.ForEach(destination.AddAsBag);
+			source.IdBags.ForEach(destination.AddAsIdBag);
+			source.Lists.ForEach(destination.AddAsList);
+			source.Arrays.ForEach(destination.AddAsArray);
+			source.Dictionaries.ForEach(destination.AddAsMap);
+			source.Properties.ForEach(destination.AddAsProperty);
+			source.PersistentMembers.ForEach(destination.AddAsPersistentMember);
+			source.SplitDefinitions.ForEach(destination.AddAsPropertySplit);
 			foreach (var dynamicComponent in source.DynamicComponents)
 			{
 				var template = source.GetDynamicComponentTemplate(dynamicComponent);
 				destination.AddAsDynamicComponent(dynamicComponent, template);
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Persister/PersisterFactory.cs b/src/NHibernate/Persister/PersisterFactory.cs
@@ -7,6 +7,7 @@
 using NHibernate.Mapping;
 using NHibernate.Persister.Collection;
 using NHibernate.Persister.Entity;
+using NHibernate.Util;
 
 namespace NHibernate.Persister
 {
@@ -149,10 +150,10 @@ public static ICollectionPersister Create(System.Type persisterClass, Mapping.Co
 				var messageBuilder = new StringBuilder();
 				messageBuilder.AppendLine("Could not find a public constructor for " + persisterClass.Name +";");
 				messageBuilder.AppendLine("- The ctor may have " + CollectionPersisterConstructorArgs.Length + " parameters of types (in order):");
-				System.Array.ForEach(CollectionPersisterConstructorArgs, t=> messageBuilder.AppendLine(t.FullName));
+				CollectionPersisterConstructorArgs.ForEach(t => messageBuilder.AppendLine(t.FullName));
 				messageBuilder.AppendLine();
 				messageBuilder.AppendLine("- The ctor may have " + CollectionPersisterConstructor2Args.Length + " parameters of types (in order):");
-				System.Array.ForEach(CollectionPersisterConstructor2Args, t => messageBuilder.AppendLine(t.FullName));
+				CollectionPersisterConstructor2Args.ForEach(t => messageBuilder.AppendLine(t.FullName));
 				throw new MappingException(messageBuilder.ToString());
 			}
 			try
diff --git a/src/NHibernate/Util/StringHelper.cs b/src/NHibernate/Util/StringHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ private static void BindIndex(string indexAttribute, Table table, Column column)`
`76`	`76`	`if (indexAttribute != null && table != null)`
`77`	`77`	`{`
`78`	`78`	`var tokens = indexAttribute.Split(',');`
`79`		`- System.Array.ForEach(tokens, t => table.GetOrCreateIndex(t.Trim()).AddColumn(column));`
	`79`	`+ tokens.ForEach(t => table.GetOrCreateIndex(t.Trim()).AddColumn(column));`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`@@ -85,8 +85,8 @@ private static void BindUniqueKey(string uniqueKeyAttribute, Table table, Column`
`85`	`85`	`if (uniqueKeyAttribute != null && table != null)`
`86`	`86`	`{`
`87`	`87`	`var tokens = uniqueKeyAttribute.Split(',');`
`88`		`- System.Array.ForEach(tokens, t => table.GetOrCreateUniqueKey(t.Trim()).AddColumn(column));`
	`88`	`+ tokens.ForEach(t => table.GetOrCreateUniqueKey(t.Trim()).AddColumn(column));`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`}`
`92`		`-}`
	`92`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -109,13 +109,13 @@ private void AddSubclasses(HbmSubclass subClass, IDictionary<string, MetaAttribu`
`109`	`109`	`private void AddQueries(HbmMapping mappingSchema)`
`110`	`110`	`{`
`111`	`111`	`var binder = new NamedQueryBinder(Mappings);`
`112`		`- System.Array.ForEach(mappingSchema.HqlQueries, binder.AddQuery);`
	`112`	`+ mappingSchema.HqlQueries.ForEach(binder.AddQuery);`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`private void AddSqlQueries(HbmMapping mappingSchema)`
`116`	`116`	`{`
`117`	`117`	`var binder = new NamedSQLQueryBinder(Mappings);`
`118`		`- System.Array.ForEach(mappingSchema.SqlQueries, binder.AddSqlQuery);`
	`118`	`+ mappingSchema.SqlQueries.ForEach(binder.AddSqlQuery);`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`public void AddImports(HbmMapping mappingSchema)`
`@@ -172,4 +172,4 @@ private void AddResultSetMappingDefinitions(HbmMapping mappingSchema)`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`	`}`
`175`		`-}`
	`175`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -365,12 +365,13 @@ private void BindComponentProperty(HbmComponent componentMapping, Property prope`
`365`	`365`	`HbmTuplizer[] tuplizers = componentMapping.tuplizer;`
`366`	`366`	`if (tuplizers != null)`
`367`	`367`	`{`
`368`		`- Array.ForEach(tuplizers.Select(tuplizer => new`
`369`		`- {`
`370`		`- TuplizerClassName = FullQualifiedClassName(tuplizer.@class, mappings),`
`371`		`- Mode = tuplizer.entitymode.ToEntityMode()`
`372`		`- }).ToArray(),`
`373`		`- x => model.AddTuplizer(x.Mode, x.TuplizerClassName));`
	`368`	`+ tuplizers.Select(`
	`369`	`+ tuplizer => new`
	`370`	`+ {`
	`371`	`+ TuplizerClassName = FullQualifiedClassName(tuplizer.@class, mappings),`
	`372`	`+ Mode = tuplizer.entitymode.ToEntityMode()`
	`373`	`+ })`
	`374`	`+ .ForEach(x => model.AddTuplizer(x.Mode, x.TuplizerClassName));`
`374`	`375`	`}`
`375`	`376`	`}`
`376`	`377`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public void Bind(HbmType typeMapping)`
`44`	`44`	`var parameters = new Dictionary<string, string>();`
`45`	`45`	`if(typeMapping.param != null)`
`46`	`46`	`{`
`47`		`- System.Array.ForEach(typeMapping.param, p => parameters[p.name] = p.Text.LinesToString());`
	`47`	`+ typeMapping.param.ForEach(p => parameters[p.name] = p.Text.LinesToString());`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`BindThroughTypeDefOrType(originalTypeName, parameters);`
`@@ -83,4 +83,4 @@ private void BindThroughTypeDefOrType(string originalTypeName, IDictionary<strin`
`83`	`83`	`value.TypeName = typeToMap;`
`84`	`84`	`}`
`85`	`85`	`}`
`86`		`-}`
	`86`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using NHibernate.Persister.Entity;`
`10`	`10`	`using NHibernate.Proxy;`
`11`	`11`	`using NHibernate.Type;`
	`12`	`+using NHibernate.Util;`
`12`	`13`
`13`	`14`	`namespace NHibernate.Event.Default`
`14`	`15`	`{`
`@@ -546,7 +547,7 @@ protected virtual IEntityPersister GetEntityPersister(ISessionFactoryImplementor`
`546`	`547`	`var messageBuilder = new StringBuilder(512);`
`547`	`548`	`messageBuilder.AppendLine(string.Format("Ambiguous persister for {0} implemented by more than one hierarchy: ",`
`548`	`549`	`entityName));`
`549`		`- Array.ForEach(implementors, s=> messageBuilder.AppendLine(s));`
	`550`	`+ implementors.ForEach(s => messageBuilder.AppendLine(s));`
`550`	`551`
`551`	`552`	`throw new HibernateException(messageBuilder.ToString());`
`552`	`553`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Linq;`
	`3`	`+using NHibernate.Util;`
`3`	`4`	`using Remotion.Linq;`
`4`	`5`	`using Remotion.Linq.Clauses;`
`5`	`6`	`using Remotion.Linq.Clauses.ResultOperators;`
`@@ -31,14 +32,14 @@ public override void VisitResultOperator(ResultOperatorBase resultOperator, Quer`
`31`	`32`	`}`
`32`	`33`	`if (resultOperator is CastResultOperator)`
`33`	`34`	`{`
`34`		`- Array.ForEach(queryModel.ResultOperators.OfType<CastResultOperator>().ToArray(), castOperator=> queryModel.ResultOperators.Remove(castOperator));`
	`35`	`+ queryModel.ResultOperators.OfType<CastResultOperator>().ToArray().ForEach(castOperator => queryModel.ResultOperators.Remove(castOperator));`
`35`	`36`	`}`
`36`	`37`	`if (resultOperator is AnyResultOperator)`
`37`	`38`	`{`
`38`		`- Array.ForEach(queryModel.ResultOperators.OfType<FetchOneRequest>().ToArray(), op => queryModel.ResultOperators.Remove(op));`
`39`		`- Array.ForEach(queryModel.ResultOperators.OfType<FetchManyRequest>().ToArray(), op => queryModel.ResultOperators.Remove(op));`
	`39`	`+ queryModel.ResultOperators.OfType<FetchOneRequest>().ToArray().ForEach(op => queryModel.ResultOperators.Remove(op));`
	`40`	`+ queryModel.ResultOperators.OfType<FetchManyRequest>().ToArray().ForEach(op => queryModel.ResultOperators.Remove(op));`
`40`	`41`	`}`
`41`	`42`	`base.VisitResultOperator(resultOperator, queryModel, index);`
`42`	`43`	`}`
`43`	`44`	`}`
`44`		`-}`
	`45`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using System.Reflection;`
`5`	`5`	`using System.Text;`
	`6`	`+using NHibernate.Util;`
`6`	`7`
`7`	`8`	`namespace NHibernate.Mapping.ByCode`
`8`	`9`	`{`
`@@ -228,7 +229,7 @@ protected virtual void AddAsTablePerClassEntity(System.Type type, bool rootEntit`
`228`	`229`	`{`
`229`	`230`	`if(!rootEntityMustExists)`
`230`	`231`	`{`
`231`		`- delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitiesOf(type).ToArray(), root=> tablePerClassEntities.Add(root)));`
	`232`	`+ delayedRootEntityRegistrations.Enqueue(() => GetRootEntitiesOf(type).ForEach(root => tablePerClassEntities.Add(root)));`
`232`	`233`	`EnlistTypeRegistration(type, t => AddAsTablePerClassEntity(t, true));`
`233`	`234`	`return;`
`234`	`235`	`}`
`@@ -263,7 +264,7 @@ protected virtual void AddAsTablePerClassHierarchyEntity(System.Type type, bool`
`263`	`264`	`{`
`264`	`265`	`if (!rootEntityMustExists)`
`265`	`266`	`{`
`266`		`- delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitiesOf(type).ToArray(), root => tablePerClassHierarchyEntities.Add(root)));`
	`267`	`+ delayedRootEntityRegistrations.Enqueue(() => GetRootEntitiesOf(type).ForEach(root => tablePerClassHierarchyEntities.Add(root)));`
`267`	`268`	`EnlistTypeRegistration(type, t => AddAsTablePerClassHierarchyEntity(t, true));`
`268`	`269`	`return;`
`269`	`270`	`}`
`@@ -299,7 +300,7 @@ protected virtual void AddAsTablePerConcreteClassEntity(System.Type type, bool r`
`299`	`300`	`{`
`300`	`301`	`if (!rootEntityMustExists)`
`301`	`302`	`{`
`302`		`- delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitiesOf(type).ToArray(), root => tablePerConcreteClassEntities.Add(root)));`
	`303`	`+ delayedRootEntityRegistrations.Enqueue(() => GetRootEntitiesOf(type).ForEach(root => tablePerConcreteClassEntities.Add(root)));`
`303`	`304`	`EnlistTypeRegistration(type, t => AddAsTablePerConcreteClassEntity(t, true));`
`304`	`305`	`return;`
`305`	`306`	`}`
`@@ -592,4 +593,4 @@ protected bool HasDelayedEntityRegistration(System.Type type)`
`592`	`593`	`return delayedEntityRegistrations.ContainsKey(type);`
`593`	`594`	`}`
`594`	`595`	`}`
`595`		`-}`
	`596`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Reflection;`
`5`	`5`	`using NHibernate.Cfg.MappingSchema;`
`6`	`6`	`using NHibernate.Persister.Entity;`
	`7`	`+using NHibernate.Util;`
`7`	`8`
`8`	`9`	`namespace NHibernate.Mapping.ByCode.Impl`
`9`	`10`	`{`
`@@ -335,8 +336,10 @@ public void Synchronize(params string[] table)`
`335`	`336`	`return;`
`336`	`337`	`}`
`337`	`338`	`var existingSyncs = new HashSet<string>(classMapping.synchronize != null ? classMapping.synchronize.Select(x => x.table) : Enumerable.Empty<string>());`
`338`		`- System.Array.ForEach(table.Where(x => x != null).Select(tableName => tableName.Trim()).Where(cleanedName => !"".Equals(cleanedName)).ToArray(),`
`339`		`- x => existingSyncs.Add(x.Trim()));`
	`339`	`+ table.Where(x => x != null)`
	`340`	`+ .Select(tableName => tableName.Trim())`
	`341`	`+ .Where(cleanedName => !"".Equals(cleanedName))`
	`342`	`+ .ForEach(x => existingSyncs.Add(x.Trim()));`
`340`	`343`	`classMapping.synchronize = existingSyncs.Select(x => new HbmSynchronize {table = x}).ToArray();`
`341`	`344`	`}`
`342`	`345`
`@@ -391,4 +394,4 @@ public void Subselect(string sql)`
`391`	`394`
`392`	`395`	`#endregion`
`393`	`396`	`}`
`394`		`-}`
	`397`	`+}`