diff --git a/src/NHibernate.Test/UtilityTest/JoinedEnumerableGenericFixture.cs b/src/NHibernate.Test/UtilityTest/JoinedEnumerableGenericFixture.cs
index d3acabd74c7..58dde26a1c2 100644
--- a/src/NHibernate.Test/UtilityTest/JoinedEnumerableGenericFixture.cs
+++ b/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
 	{
diff --git a/src/NHibernate.Test/UtilityTest/SingletonEnumerableFixture.cs b/src/NHibernate.Test/UtilityTest/SingletonEnumerableFixture.cs
index 4312bceca0f..9051edab9ec 100644
--- a/src/NHibernate.Test/UtilityTest/SingletonEnumerableFixture.cs
+++ b/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));
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/NHibernate/Mapping/Component.cs b/src/NHibernate/Mapping/Component.cs
index 9febe1a6845..c9f1409cf6f 100644
--- a/src/NHibernate/Mapping/Component.cs
+++ b/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);
 			}
 		}
 
diff --git a/src/NHibernate/Mapping/DenormalizedTable.cs b/src/NHibernate/Mapping/DenormalizedTable.cs
index bfb814e2858..4852025ddc3 100644
--- a/src/NHibernate/Mapping/DenormalizedTable.cs
+++ b/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);
 			}
 		}
 
diff --git a/src/NHibernate/Mapping/PersistentClass.cs b/src/NHibernate/Mapping/PersistentClass.cs
index 3b23cb5e6dc..542212df025 100644
--- a/src/NHibernate/Mapping/PersistentClass.cs
+++ b/src/NHibernate/Mapping/PersistentClass.cs
@@ -215,13 +215,7 @@ 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);
 			}
 		}
 
@@ -229,12 +223,7 @@ 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));
 			}
 		}
 
diff --git a/src/NHibernate/Mapping/RootClass.cs b/src/NHibernate/Mapping/RootClass.cs
index f35c00d913e..56e6dd4d9c3 100644
--- a/src/NHibernate/Mapping/RootClass.cs
+++ b/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>
diff --git a/src/NHibernate/Mapping/SingleTableSubclass.cs b/src/NHibernate/Mapping/SingleTableSubclass.cs
index 618be14daca..5f0d8368120 100644
--- a/src/NHibernate/Mapping/SingleTableSubclass.cs
+++ b/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);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/NHibernate/Mapping/Subclass.cs b/src/NHibernate/Mapping/Subclass.cs
index 1ca0f915208..90129783f49 100644
--- a/src/NHibernate/Mapping/Subclass.cs
+++ b/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
diff --git a/src/NHibernate/Util/JoinedEnumerable.cs b/src/NHibernate/Util/JoinedEnumerable.cs
index df7c268efed..2e9d3ab6b50 100644
--- a/src/NHibernate/Util/JoinedEnumerable.cs
+++ b/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;
diff --git a/src/NHibernate/Util/SingletonEnumerable.cs b/src/NHibernate/Util/SingletonEnumerable.cs
index 155aff136e4..73feb1a074a 100644
--- a/src/NHibernate/Util/SingletonEnumerable.cs
+++ b/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
 		}
 	}
-}
\ No newline at end of file
+}