Generiere spezifische Kombination in C#, die meine erwartete Ausgabe erzeugt

Question

Ich habe zwei Listen mit mehreren Daten in jeder Liste. Und brauchen unterhalb der Ausgabe, die Kombinationswerte der Liste (n) wären. Hier

Example1: 
List1: {"A","B","C"} 
List2: {"D","E"} 

Expected Output Combinations: 
{"A"} 
{"B"} 
{"C"} 
{"D"} 
{"E"} 
{"A,D"} 
{"A,E"} 
{"B,D"} 
{"B,E"} 
{"C,D"} 
{"C,E"} 

Example2: 
List1: {"A","B"} 
List2: {"D"} 

Expected Output Combinations: 
{"A"} 
{"B"} 
{"D"} 
{"A,D"} 
{"B,D"} 

ist Code-Schnipsel, die ich versuche:

public static IEnumerable<IEnumerable<T>> Combinations<T>(this IEnumerable<T> source, int n) 
{ 
    if (n == 0) yield return Enumerable.Empty<T>(); 

    int count = 1; 
    foreach (T item in source) 
    { 
     foreach (var innerSequence in source.Skip(count).Combinations(n - 1)) 
     { 
      yield return new T[] { item }.Concat(innerSequence);}count++; 
     } 
    } 
} 

public static IEnumerable<IEnumerable<T>> AllCombinations<T>(this IList<T> source) 
{ 
    IEnumerable<IEnumerable<T>> output = Enumerable.Empty<IEnumerable<T>>(); 
    for (int i = 0; i < source.Count; i++) 
    { 
     output = output.Concat(source.Combinations(i)); 
    } 
    return output; 
} 

...

List<string> lstCodes = new List<string>(); 
List<string> lstCodeOut = new List<string>(); 

if (!String.IsNullOrEmpty(txtbox1.Text)) 
    lstCodes.AddRange(txtbo‌​x1.Text.Split(',').T‌​oList()); 
if (!String.IsNullOrEmpty(txtbox2.Text)) 
    lstCodes.AddRange(txtbo‌​x2.Text.Split(',').T‌​oList()); 
if (!String.IsNullOrEmpty(txtbox3.Text)) 
    lstCodes.AddRange(txtbo‌​x3.Text.Split(',').T‌​oList()); 

foreach (var sequence in lstCodes.AllCombinations()) 
{ 
    lstCodeOut.Add(string.Join(",", sequence)); 
} 
txtBox.Text = string.Join(Environment.NewLine, lstCodeOut); 

Answer 1

Der direkteste Weg ist einfach foreach-Schleifen zu verwenden; dies setzt voraus, keine Duplikate:

var l1 = new List<string> { "A", "B", "C" }; 
var l2 = new List<string> { "D", "E" }; 

var result = new List<string>(l1.Concat(l2)); 

foreach(string s1 in l1) 
{ 
    foreach(string s2 in l2) 
    { 
     result.Add($"{s1},{s2}"); 
    } 
} 

Und von:

var l1 = new List<string> { "A", "B", "C" }; 
var l2 = new List<string> { "D", "E" }; 

var result = new HashSet<string>(); 

foreach(string s1 in l1) 
{ 
    result.Add(s1); 

    foreach(string s2 in l2) 
    { 
     result.Add(s2); 
     result.Add($"{s1},{s2}"); 
    } 
} 

Von hier aus können wir einen Teil der Redundanz in der inneren Schleife durch Verknüpfung der zwei Listen dann die 2 in die Kombinationen verschmelzenden Refactoring entfernen hier können wir wieder in eine LINQ-Anweisung refactor:

var l1 = new List<string> { "A", "B", "C" }; 
var l2 = new List<string> { "D", "E" }; 

string[] result = l1 
    .Concat(l2) 
    .Concat(l1.SelectMany(s1 => l2, (s1, s2) => $"{s1},{s2}")) 
    .ToArray();