Get rid of JoinedEnumerable<T> and SingletonEnumerable<T>

src/NHibernate.Test/UtilityTest/JoinedEnumerableGenericFixture.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using NHibernate.Util;
@@ -6,6 +7,8 @@
 namespace NHibernate.Test.UtilityTest
 {
 	// This test is the same of JoinedEnumerableFixture but for generic version.
+	// Since 5.3
+	[Obsolete]
 	[TestFixture]
 	public class JoinedEnumerableGenericFixture
 	{

src/NHibernate.Test/UtilityTest/SingletonEnumerableFixture.cs

@@ -1,9 +1,12 @@
+using System;
 using System.Collections;
 using NHibernate.Util;
 using NUnit.Framework;
 
 namespace NHibernate.Test.UtilityTest
 {
+	// Since 5.3
+	[Obsolete]
 	[TestFixture]
 	public class SingletonEnumerableFixture
 	{
@@ -46,4 +49,4 @@ public void ShouldWorkAsEnumerator()
 			Assert.That(i, Is.EqualTo(1));
 		}
 	}
-}
+}

src/NHibernate/Mapping/Component.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NHibernate.Tuple.Component;
 using NHibernate.Type;
 using NHibernate.Util;
@@ -72,12 +73,7 @@ public override IEnumerable<ISelectable> ColumnIterator
 		{
 			get
 			{
-				List<IEnumerable<ISelectable>> iters = new List<IEnumerable<ISelectable>>();
-				foreach (Property property in PropertyIterator)
-				{
-					iters.Add(property.ColumnIterator);
-				}
-				return new JoinedEnumerable<ISelectable>(iters);
+				return PropertyIterator.SelectMany(x => x.ColumnIterator);
 			}
 		}
 

src/NHibernate/Mapping/DenormalizedTable.cs

@@ -18,7 +18,7 @@ public DenormalizedTable(Table includedTable)
 
 		public override IEnumerable<Column> ColumnIterator
 		{
-			get { return new JoinedEnumerable<Column>(includedTable.ColumnIterator, base.ColumnIterator); }
+			get { return includedTable.ColumnIterator.Concat(base.ColumnIterator); }
 		}
 
 		public override IEnumerable<UniqueKey> UniqueKeyIterator
@@ -39,7 +39,6 @@ public override IEnumerable<Index> IndexIterator
 		{
 			get
 			{
-				List<Index> indexes = new List<Index>();
 				IEnumerable<Index> includedIdxs = includedTable.IndexIterator;
 				foreach (Index parentIndex in includedIdxs)
 				{
@@ -55,9 +54,13 @@ public override IEnumerable<Index> IndexIterator
 					index.IsInherited = true;
 					index.Table = this;
 					index.AddColumns(parentIndex.ColumnIterator);
-					indexes.Add(index);
+					yield return index;
+				}
+
+				foreach (var index in base.IndexIterator)
+				{
+					yield return index;
 				}
-				return new JoinedEnumerable<Index>(indexes, base.IndexIterator);
 			}
 		}
 

src/NHibernate/Mapping/PersistentClass.cs

@@ -215,26 +215,15 @@ public virtual IEnumerable<Subclass> SubclassIterator
 		{
 			get
 			{
-				IEnumerable<Subclass>[] iters = new IEnumerable<Subclass>[subclasses.Count + 1];
-				int i = 0;
-				foreach (Subclass subclass in subclasses)
-					iters[i++] = subclass.SubclassIterator;
-
-				iters[i] = subclasses;
-				return new JoinedEnumerable<Subclass>(iters);
+				return subclasses.SelectMany(s => s.SubclassIterator).Concat(subclasses);
 			}
 		}
 
 		public virtual IEnumerable<PersistentClass> SubclassClosureIterator
 		{
 			get
 			{
-				List<IEnumerable<PersistentClass>> iters = new List<IEnumerable<PersistentClass>>();
-				iters.Add(new SingletonEnumerable<PersistentClass>(this));
-				foreach (Subclass clazz in SubclassIterator)
-					iters.Add(clazz.SubclassClosureIterator);
-
-				return new JoinedEnumerable<PersistentClass>(iters);
+				return new[] {this}.Concat(SubclassIterator.SelectMany(x => x.SubclassClosureIterator));
 			}
 		}
 
@@ -322,19 +311,15 @@ public virtual IEnumerable<Property> SubclassPropertyClosureIterator
 		{
 			get
 			{
-				List<IEnumerable<Property>> iters = new List<IEnumerable<Property>>();
-				iters.Add(PropertyClosureIterator);
-				iters.Add(subclassProperties);
-				foreach (Join join in subclassJoins)
-					iters.Add(join.PropertyIterator);
-
-				return new JoinedEnumerable<Property>(iters);
+				return PropertyClosureIterator
+						.Concat(subclassProperties)
+						.Concat(subclassJoins.SelectMany(x => x.PropertyIterator));
 			}
 		}
 
 		public virtual IEnumerable<Join> SubclassJoinClosureIterator
 		{
-			get { return new JoinedEnumerable<Join>(JoinClosureIterator, subclassJoins); }
+			get { return JoinClosureIterator.Concat(subclassJoins); }
 		}
 
 		/// <summary>
@@ -345,7 +330,7 @@ public virtual IEnumerable<Join> SubclassJoinClosureIterator
 		/// <remarks>It adds the TableClosureIterator and the subclassTables into the IEnumerable.</remarks>
 		public virtual IEnumerable<Table> SubclassTableClosureIterator
 		{
-			get { return new JoinedEnumerable<Table>(TableClosureIterator, subclassTables); }
+			get { return TableClosureIterator.Concat(subclassTables); }
 		}
 
 		public bool IsLazy
@@ -455,12 +440,7 @@ public virtual IEnumerable<Property> PropertyIterator
 		{
 			get
 			{
-				List<IEnumerable<Property>> iterators = new List<IEnumerable<Property>>();
-				iterators.Add(properties);
-				foreach (Join join in joins)
-					iterators.Add(join.PropertyIterator);
-
-				return new JoinedEnumerable<Property>(iterators);
+				return properties.Concat(joins.SelectMany(x => x.PropertyIterator));
 			}
 		}
 

src/NHibernate/Mapping/RootClass.cs

@@ -89,12 +89,12 @@ public override IEnumerable<Property> PropertyClosureIterator
 		/// </remarks>
 		public override IEnumerable<Table> TableClosureIterator
 		{
-			get { return new SingletonEnumerable<Table>(Table); }
+			get { return new[] {Table}; }
 		}
 
 		public override IEnumerable<IKeyValue> KeyClosureIterator
 		{
-			get { return new SingletonEnumerable<IKeyValue>(Key); }
+			get { return new[] {Key}; }
 		}
 
 		/// <summary>

src/NHibernate/Mapping/SingleTableSubclass.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NHibernate.Util;
 
 namespace NHibernate.Mapping
@@ -12,7 +13,7 @@ public SingleTableSubclass(PersistentClass superclass)
 
 		protected internal override IEnumerable<Property> NonDuplicatedPropertyIterator
 		{
-			get { return new JoinedEnumerable<Property>(Superclass.UnjoinedPropertyIterator, UnjoinedPropertyIterator); }
+			get { return Superclass.UnjoinedPropertyIterator.Concat(UnjoinedPropertyIterator); }
 		}
 
 		protected internal override IEnumerable<ISelectable> DiscriminatorColumnIterator
@@ -39,4 +40,4 @@ public override void Validate(Engine.IMapping mapping)
 			base.Validate(mapping);
 		}
 	}
-}
+}

src/NHibernate/Mapping/Subclass.cs

@@ -58,7 +58,7 @@ public override bool IsInherited
 		/// </remarks>
 		public override IEnumerable<Property> PropertyClosureIterator
 		{
-			get { return new JoinedEnumerable<Property>(Superclass.PropertyClosureIterator, PropertyIterator); }
+			get { return Superclass.PropertyClosureIterator.Concat(PropertyIterator); }
 		}
 
 		/// <summary>
@@ -75,12 +75,12 @@ public override IEnumerable<Property> PropertyClosureIterator
 		/// </remarks>
 		public override IEnumerable<Table> TableClosureIterator
 		{
-			get { return new JoinedEnumerable<Table>(Superclass.TableClosureIterator, new SingletonEnumerable<Table>(Table)); }
+			get { return Superclass.TableClosureIterator.Concat(new[] {Table}); }
 		}
 
 		public override IEnumerable<IKeyValue> KeyClosureIterator
 		{
-			get { return new JoinedEnumerable<IKeyValue>(Superclass.KeyClosureIterator, new SingletonEnumerable<IKeyValue>(Key)); }
+			get { return Superclass.KeyClosureIterator.Concat(new[] {Key}); }
 		}
 
 		/// <summary>
@@ -143,7 +143,7 @@ public override int PropertyClosureSpan
 
 		public override IEnumerable<Join> JoinClosureIterator
 		{
-			get { return new JoinedEnumerable<Join>(Superclass.JoinClosureIterator, base.JoinClosureIterator); }
+			get { return Superclass.JoinClosureIterator.Concat(base.JoinClosureIterator); }
 		}
 
 		public override ISet<string> SynchronizedTables

src/NHibernate/Util/JoinedEnumerable.cs

@@ -167,6 +167,8 @@ private void Dispose(bool isDisposing)
 		#endregion
 	}
 
+	// Since 5.3
+	[Obsolete("This class has no more usages and will be removed in a future version")]
 	public class JoinedEnumerable<T> : IEnumerable<T>
 	{
 		private readonly IEnumerable<T>[] enumerables;

src/NHibernate/Util/SingletonEnumerable.cs

@@ -1,8 +1,11 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 
 namespace NHibernate.Util
 {
+	// Since 5.3
+	[Obsolete("This class has no more usages and will be removed in a future version")]
 	public sealed class SingletonEnumerable<T> : IEnumerable<T>
 	{
 		private readonly T value;
@@ -78,4 +81,4 @@ object IEnumerator.Current
 			#endregion
 		}
 	}
-}
+}