/// <summary>
/// Fusioniert zwei Arrays zu einem teilbaren Container Array
/// </summary>
/// <typeparam name="T1">Typ1</typeparam>
/// <typeparam name="T2">Typ2</typeparam>
/// <param name="t1">Das erweiterte Objekt</param>
/// <param name="t2">Der zweite Array</param>
/// <returns>Einen teilbaren Container Array</returns>
/// <exception cref="IndexOutOfRangeException">Wenn die Arrays unterschiedlich lang sind</exception>
/// <example>
/// <para>
/// Mit der Bindung zweier Objekte kann man z.B. Änderungen von Positionen in Collections an beiden Objekten gleichzeitig durchführen,
/// ohne einen eigenen Algorithmus zu schreiben. Hier wird ein <see cref="string"/>-<see cref="Array"/> von mit Zahl-Representationen anhand ihrer
/// Zahl-Equivalente sortiert (der <see cref="int"/>-<see cref="Array"/>)
/// </para>
/// <code>
/// string[] aa = new string[] { "eins", "drei", "zwei", "minus vier" };
/// int[] bb = new int[] { 1, 3, 2, -4 };
///
/// aa.Fuse(bb).OrderBy(i => i.Item2).DeFuse(out aa, out bb);
/// //aa: { "minus vier", "eins", "zwei", "drei" }
/// //bb: { -4, 1, 2, 3 }
/// </code>
/// </example>
public static FusionTuple <T1, T2>[] Fuse <T1, T2>(this T1[] t1, T2[] t2)
{
if (t1.Length != t2.Length)
{
throw new IndexOutOfRangeException("uneven array-lengths");
}
FusionTuple <T1, T2>[] result = new FusionTuple <T1, T2> [t1.Length];
for (int i = 0; i < t1.Length; i++)
{
result[i] = new FusionTuple <T1, T2>(t1[i], t2[i]);
}
return(result);
}
/// <summary>
/// Fusioniert zwei <see cref="IEnumerable"/>s zu einem teilbaren Container Array
/// </summary>
/// <typeparam name="T1">Typ1</typeparam>
/// <typeparam name="T2">Typ2</typeparam>
/// <param name="c1">Das erweiterte Objekt</param>
/// <param name="c2">Die zweite <see cref="ICollection"/></param>
/// <returns>Einen teilbaren Container Array</returns>
///<exception cref="IndexOutOfRangeException">Wenn die Enumerationen unterschiedlich lang sind</exception>
/// /// <example>
/// <para>
/// Mit der Bindung zweier Objekte kann man z.B. Änderungen von Positionen in Collections an beiden Objekten gleichzeitig durchführen,
/// ohne einen eigenen Algorithmus zu schreiben. Hier wird ein <see cref="string"/>-<see cref="Array"/> von mit Zahl-Representationen anhand ihrer
/// Zahl-Equivalente sortiert (der <see cref="int"/>-<see cref="Array"/>)
/// </para>
/// <code>
/// string[] aa = new string[] { "eins", "drei", "zwei", "minus vier" };
/// int[] bb = new int[] { 1, 3, 2, -4 };
///
/// aa.Fuse(bb).OrderBy(i => i.Item2).DeFuse(out aa, out bb);
/// //aa: { "minus vier", "eins", "zwei", "drei" }
/// //bb: { -4, 1, 2, 3 }
/// </code>
/// </example>
public static FusionTuple <T1, T2>[] Fuse <T1, T2>(this ICollection <T1> c1, ICollection <T2> c2)
{
if (c1.Count != c2.Count)
{
throw new IndexOutOfRangeException("uneven collection-counts");
}
int counter = 0;
FusionTuple <T1, T2>[] result = new FusionTuple <T1, T2> [c1.Count];
IEnumerator <T1> enu1 = c1.GetEnumerator();
IEnumerator <T2> enu2 = c2.GetEnumerator();
while (enu1.MoveNext() && enu2.MoveNext())
{
result[counter++] = new FusionTuple <T1, T2>(enu1.Current, enu2.Current);
}
return(result);
}
/// <summary>
/// Fusioniert zwei <see cref="IEnumerable"/>s zu einem teilbaren Container Array
/// </summary>
/// <typeparam name="T1">Typ1</typeparam>
/// <typeparam name="T2">Typ2</typeparam>
/// <param name="e1">Das erweiterte Objekt</param>
/// <param name="e2">Das zweite <see cref="IEnumerable"/></param>
/// <returns>Einen teilbaren Container Array</returns>
///<exception cref="IndexOutOfRangeException">Wenn die Enumerationen unterschiedlich lang sind</exception>
/// /// <example>
/// <para>
/// Mit der Bindung zweier Objekte kann man z.B. Änderungen von Positionen in Collections an beiden Objekten gleichzeitig durchführen,
/// ohne einen eigenen Algorithmus zu schreiben. Hier wird ein <see cref="string"/>-<see cref="Array"/> von mit Zahl-Representationen anhand ihrer
/// Zahl-Equivalente sortiert (der <see cref="int"/>-<see cref="Array"/>)
/// </para>
/// <code>
/// string[] aa = new string[] { "eins", "drei", "zwei", "minus vier" };
/// int[] bb = new int[] { 1, 3, 2, -4 };
///
/// aa.Fuse(bb).OrderBy(i => i.Item2).DeFuse(out aa, out bb);
/// //aa: { "minus vier", "eins", "zwei", "drei" }
/// //bb: { -4, 1, 2, 3 }
/// </code>
/// </example>
public static FusionTuple <T1, T2>[] Fuse <T1, T2>(this IEnumerable <T1> e1, IEnumerable <T2> e2)
{
int e1Count = e1.Count();
if (e1Count != e2.Count())
{
throw new IndexOutOfRangeException("uneven enumeration-counts");
}
int counter = 0;
FusionTuple <T1, T2>[] result = new FusionTuple <T1, T2> [e1Count];
IEnumerator <T1> enu1 = e1.GetEnumerator();
IEnumerator <T2> enu2 = e2.GetEnumerator();
while (enu1.MoveNext() && enu2.MoveNext())
{
result[counter++] = new FusionTuple <T1, T2>(enu1.Current, enu2.Current);
}
return(result);
}