Get rid of JoinedEnumerable<T> and SingletonEnumerable<T> (#2351)

bahusoid · web-flow · commit 129e4c108375 · 2020-04-19T02:24:16.000Z
diff --git 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
@@ -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));
 		}
 	}
-}
+}
diff --git 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
@@ -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
@@ -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));
 			}
 		}
 
diff --git 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
@@ -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);
 		}
 	}
-}
+}
diff --git 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
@@ -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
@@ -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
 		}
 	}
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Collections;`
`2`	`3`	`using System.Collections.Generic;`
`3`	`4`	`using NHibernate.Util;`
`@@ -6,6 +7,8 @@`
`6`	`7`	`namespace NHibernate.Test.UtilityTest`
`7`	`8`	`{`
`8`	`9`	`// This test is the same of JoinedEnumerableFixture but for generic version.`
	`10`	`+ // Since 5.3`
	`11`	`+ [Obsolete]`
`9`	`12`	`[TestFixture]`
`10`	`13`	`public class JoinedEnumerableGenericFixture`
`11`	`14`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,12 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Collections;`
`2`	`3`	`using NHibernate.Util;`
`3`	`4`	`using NUnit.Framework;`
`4`	`5`
`5`	`6`	`namespace NHibernate.Test.UtilityTest`
`6`	`7`	`{`
	`8`	`+ // Since 5.3`
	`9`	`+ [Obsolete]`
`7`	`10`	`[TestFixture]`
`8`	`11`	`public class SingletonEnumerableFixture`
`9`	`12`	`{`
`@@ -46,4 +49,4 @@ public void ShouldWorkAsEnumerator()`
`46`	`49`	`Assert.That(i, Is.EqualTo(1));`
`47`	`50`	`}`
`48`	`51`	`}`
`49`		`-}`
	`52`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Linq;`
`3`	`4`	`using NHibernate.Tuple.Component;`
`4`	`5`	`using NHibernate.Type;`
`5`	`6`	`using NHibernate.Util;`
`@@ -72,12 +73,7 @@ public override IEnumerable<ISelectable> ColumnIterator`
`72`	`73`	`{`
`73`	`74`	`get`
`74`	`75`	`{`
`75`		`- List<IEnumerable<ISelectable>> iters = new List<IEnumerable<ISelectable>>();`
`76`		`- foreach (Property property in PropertyIterator)`
`77`		`- {`
`78`		`- iters.Add(property.ColumnIterator);`
`79`		`- }`
`80`		`- return new JoinedEnumerable<ISelectable>(iters);`
	`76`	`+ return PropertyIterator.SelectMany(x => x.ColumnIterator);`
`81`	`77`	`}`
`82`	`78`	`}`
`83`	`79`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public DenormalizedTable(Table includedTable)`
`18`	`18`
`19`	`19`	`public override IEnumerable<Column> ColumnIterator`
`20`	`20`	`{`
`21`		`- get { return new JoinedEnumerable<Column>(includedTable.ColumnIterator, base.ColumnIterator); }`
	`21`	`+ get { return includedTable.ColumnIterator.Concat(base.ColumnIterator); }`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public override IEnumerable<UniqueKey> UniqueKeyIterator`
`@@ -39,7 +39,6 @@ public override IEnumerable<Index> IndexIterator`
`39`	`39`	`{`
`40`	`40`	`get`
`41`	`41`	`{`
`42`		`- List<Index> indexes = new List<Index>();`
`43`	`42`	`IEnumerable<Index> includedIdxs = includedTable.IndexIterator;`
`44`	`43`	`foreach (Index parentIndex in includedIdxs)`
`45`	`44`	`{`
`@@ -55,9 +54,13 @@ public override IEnumerable<Index> IndexIterator`
`55`	`54`	`index.IsInherited = true;`
`56`	`55`	`index.Table = this;`
`57`	`56`	`index.AddColumns(parentIndex.ColumnIterator);`
`58`		`- indexes.Add(index);`
	`57`	`+ yield return index;`
	`58`	`+ }`
	`59`	`+`
	`60`	`+ foreach (var index in base.IndexIterator)`
	`61`	`+ {`
	`62`	`+ yield return index;`
`59`	`63`	`}`
`60`		`- return new JoinedEnumerable<Index>(indexes, base.IndexIterator);`
`61`	`64`	`}`
`62`	`65`	`}`
`63`	`66`
Original file line number	Diff line number	Diff line change
`@@ -215,26 +215,15 @@ public virtual IEnumerable<Subclass> SubclassIterator`
`215`	`215`	`{`
`216`	`216`	`get`
`217`	`217`	`{`
`218`		`- IEnumerable<Subclass>[] iters = new IEnumerable<Subclass>[subclasses.Count + 1];`
`219`		`- int i = 0;`
`220`		`- foreach (Subclass subclass in subclasses)`
`221`		`- iters[i++] = subclass.SubclassIterator;`
`222`		`-`
`223`		`- iters[i] = subclasses;`
`224`		`- return new JoinedEnumerable<Subclass>(iters);`
	`218`	`+ return subclasses.SelectMany(s => s.SubclassIterator).Concat(subclasses);`
`225`	`219`	`}`
`226`	`220`	`}`
`227`	`221`
`228`	`222`	`public virtual IEnumerable<PersistentClass> SubclassClosureIterator`
`229`	`223`	`{`
`230`	`224`	`get`
`231`	`225`	`{`
`232`		`- List<IEnumerable<PersistentClass>> iters = new List<IEnumerable<PersistentClass>>();`
`233`		`- iters.Add(new SingletonEnumerable<PersistentClass>(this));`
`234`		`- foreach (Subclass clazz in SubclassIterator)`
`235`		`- iters.Add(clazz.SubclassClosureIterator);`
`236`		`-`
`237`		`- return new JoinedEnumerable<PersistentClass>(iters);`
	`226`	`+ return new[] {this}.Concat(SubclassIterator.SelectMany(x => x.SubclassClosureIterator));`
`238`	`227`	`}`
`239`	`228`	`}`
`240`	`229`
`@@ -322,19 +311,15 @@ public virtual IEnumerable<Property> SubclassPropertyClosureIterator`
`322`	`311`	`{`
`323`	`312`	`get`
`324`	`313`	`{`
`325`		`- List<IEnumerable<Property>> iters = new List<IEnumerable<Property>>();`
`326`		`- iters.Add(PropertyClosureIterator);`
`327`		`- iters.Add(subclassProperties);`
`328`		`- foreach (Join join in subclassJoins)`
`329`		`- iters.Add(join.PropertyIterator);`
`330`		`-`
`331`		`- return new JoinedEnumerable<Property>(iters);`
	`314`	`+ return PropertyClosureIterator`
	`315`	`+ .Concat(subclassProperties)`
	`316`	`+ .Concat(subclassJoins.SelectMany(x => x.PropertyIterator));`
`332`	`317`	`}`
`333`	`318`	`}`
`334`	`319`
`335`	`320`	`public virtual IEnumerable<Join> SubclassJoinClosureIterator`
`336`	`321`	`{`
`337`		`- get { return new JoinedEnumerable<Join>(JoinClosureIterator, subclassJoins); }`
	`322`	`+ get { return JoinClosureIterator.Concat(subclassJoins); }`
`338`	`323`	`}`
`339`	`324`
`340`	`325`	`/// <summary>`
`@@ -345,7 +330,7 @@ public virtual IEnumerable<Join> SubclassJoinClosureIterator`
`345`	`330`	`/// <remarks>It adds the TableClosureIterator and the subclassTables into the IEnumerable.</remarks>`
`346`	`331`	`public virtual IEnumerable<Table> SubclassTableClosureIterator`
`347`	`332`	`{`
`348`		`- get { return new JoinedEnumerable<Table>(TableClosureIterator, subclassTables); }`
	`333`	`+ get { return TableClosureIterator.Concat(subclassTables); }`
`349`	`334`	`}`
`350`	`335`
`351`	`336`	`public bool IsLazy`
`@@ -455,12 +440,7 @@ public virtual IEnumerable<Property> PropertyIterator`
`455`	`440`	`{`
`456`	`441`	`get`
`457`	`442`	`{`
`458`		`- List<IEnumerable<Property>> iterators = new List<IEnumerable<Property>>();`
`459`		`- iterators.Add(properties);`
`460`		`- foreach (Join join in joins)`
`461`		`- iterators.Add(join.PropertyIterator);`
`462`		`-`
`463`		`- return new JoinedEnumerable<Property>(iterators);`
	`443`	`+ return properties.Concat(joins.SelectMany(x => x.PropertyIterator));`
`464`	`444`	`}`
`465`	`445`	`}`
`466`	`446`
Original file line number	Diff line number	Diff line change
`@@ -89,12 +89,12 @@ public override IEnumerable<Property> PropertyClosureIterator`
`89`	`89`	`/// </remarks>`
`90`	`90`	`public override IEnumerable<Table> TableClosureIterator`
`91`	`91`	`{`
`92`		`- get { return new SingletonEnumerable<Table>(Table); }`
	`92`	`+ get { return new[] {Table}; }`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`public override IEnumerable<IKeyValue> KeyClosureIterator`
`96`	`96`	`{`
`97`		`- get { return new SingletonEnumerable<IKeyValue>(Key); }`
	`97`	`+ get { return new[] {Key}; }`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public override bool IsInherited`
`58`	`58`	`/// </remarks>`
`59`	`59`	`public override IEnumerable<Property> PropertyClosureIterator`
`60`	`60`	`{`
`61`		`- get { return new JoinedEnumerable<Property>(Superclass.PropertyClosureIterator, PropertyIterator); }`
	`61`	`+ get { return Superclass.PropertyClosureIterator.Concat(PropertyIterator); }`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`/// <summary>`
`@@ -75,12 +75,12 @@ public override IEnumerable<Property> PropertyClosureIterator`
`75`	`75`	`/// </remarks>`
`76`	`76`	`public override IEnumerable<Table> TableClosureIterator`
`77`	`77`	`{`
`78`		`- get { return new JoinedEnumerable<Table>(Superclass.TableClosureIterator, new SingletonEnumerable<Table>(Table)); }`
	`78`	`+ get { return Superclass.TableClosureIterator.Concat(new[] {Table}); }`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`public override IEnumerable<IKeyValue> KeyClosureIterator`
`82`	`82`	`{`
`83`		`- get { return new JoinedEnumerable<IKeyValue>(Superclass.KeyClosureIterator, new SingletonEnumerable<IKeyValue>(Key)); }`
	`83`	`+ get { return Superclass.KeyClosureIterator.Concat(new[] {Key}); }`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`/// <summary>`
`@@ -143,7 +143,7 @@ public override int PropertyClosureSpan`
`143`	`143`
`144`	`144`	`public override IEnumerable<Join> JoinClosureIterator`
`145`	`145`	`{`
`146`		`- get { return new JoinedEnumerable<Join>(Superclass.JoinClosureIterator, base.JoinClosureIterator); }`
	`146`	`+ get { return Superclass.JoinClosureIterator.Concat(base.JoinClosureIterator); }`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`public override ISet<string> SynchronizedTables`
Original file line number	Diff line number	Diff line change
`@@ -167,6 +167,8 @@ private void Dispose(bool isDisposing)`
`167`	`167`	`#endregion`
`168`	`168`	`}`
`169`	`169`
	`170`	`+ // Since 5.3`
	`171`	`+ [Obsolete("This class has no more usages and will be removed in a future version")]`
`170`	`172`	`public class JoinedEnumerable<T> : IEnumerable<T>`
`171`	`173`	`{`
`172`	`174`	`private readonly IEnumerable<T>[] enumerables;`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,11 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Collections;`
`2`	`3`	`using System.Collections.Generic;`
`3`	`4`
`4`	`5`	`namespace NHibernate.Util`
`5`	`6`	`{`
	`7`	`+ // Since 5.3`
	`8`	`+ [Obsolete("This class has no more usages and will be removed in a future version")]`
`6`	`9`	`public sealed class SingletonEnumerable<T> : IEnumerable<T>`
`7`	`10`	`{`
`8`	`11`	`private readonly T value;`
`@@ -78,4 +81,4 @@ object IEnumerator.Current`
`78`	`81`	`#endregion`
`79`	`82`	`}`
`80`	`83`	`}`
`81`		`-}`
	`84`	`+}`