Einzelnes Element in der Linq-Anweisung anhängen

Question

Aus Neugier möchte ich ein Element zu einem Enumerable innerhalb eines Linq-Flusses hinzufügen, ohne den Fluss zu beenden oder das einzelne Element auf ein Array zu übertragen.

Anstatt also diese:

myEntity.SelectMany(e => e.SubEntities.Concat(new []{e})).yadayadayada 

Ich möchte einen anderen Befehl, wo ich würde nicht das einzige Element in ein Array wickeln müssen:

myEntity.SelectMany(e => e.SubEntities.SomeBuiltInFunc(e)).yadayadayada 

oder

myEntity.SelectMany(e => e.SubEntities.ToList().SomeBuiltInFunc(e)).yadayadayada 

oder

myEntity.SelectMany(e => SomeBuiltInFunc(e.SubEntities, e).yadayadayada 

Jedes Konstrukt in der Sprache, die ich momentan vermisse, könnte dies tun, ohne eine neue benutzerdefinierte Funktion oder Erweiterungsmethode zu erstellen.

Answer 1

Interessant. Zuallererst können Sie keine Elemente zu IEnumerable hinzufügen, da beispielsweise nicht alle IEnumerable Sammlungen sind. Um das zu erreichen, was Sie wollen, müssen Sie das IEnumerable in etwas wie zB List konvertieren.

Ich denke, Sie sind für Erweiterungsmethoden suchen, die eine mögliche Lösung ist, ich herausfinden konnte:

public class Entity 
{ 
    public IEnumerable<Entity> SubEntities { get; set; } 
} 

public static class EnumerableExtensions 
{ 

    public static IEnumerable<T> SomeBuiltInFunc<T>(this IEnumerable<T> enumerable, T item) 
    { 
     var list = enumerable.ToList(); 
     list.Add(item); 
     return list; 
    } 

} 

... dann sind Sie es so nennen könnte:

IEnumerable<Entity> myEntities = new List<Entity>(); 
var entity = new Entity(); 
myEntities = myEntities.SelectMany(e => e.SubEntities.SomeBuiltInFunc(entity)); 

Nehmen Hinweis Ich habe Ihre myEntity zu myEntities geändert, weil SelectMany() eine integrierte Erweiterungsmethode von IEnumerable<T> ist. Auch, wenn Sie benötigen ein ganzes IEnumerable<T> als Argument zu Ihrem BuiltInFunc() passieren, es ist nur etwas ändern wie:

public static IEnumerable<T> SomeBuiltInFunc<T>(this IEnumerable<T> enumerable, IEnumerable<T> item) 
{ 
    var list = enumerable.ToList(); 
    list.AddRange(item); 
    return list; 
} 

... dann jetzt:

IEnumerable<Entity> myEntities = new List<Entity>(); 
var entity = new Entity(); 
myEntities = myEntities.SelectMany(e => e.SubEntities.SomeBuiltInFunc(myEntities)); 

Schließlich ändern Sie den Namen der SomeBuiltInFunc(), da es nicht wirklich eingebaut ist.

---

Ich möchte nur klar das Problem mit dieser Lösung machen ist, könnten wir nicht den ursprünglichen konkreten Typ des IEnumerable bewahren.

Während die Idee mit Schnittstellen arbeitet haupt nicht über die Details der Implementierung kümmern (was die konkrete Art ist), kann es Situationen geben, in denen es Unterschied macht die konkrete Art zu verändern. So finden Sie entweder einen Weg, um dies zu lösen, oder seien Sie vorsichtig, ob dies ein Problem für Sie wäre oder nicht.

Answer 2

Antwort der rekursiven war ziemlich gut, ich frage mich, wie Enumerable.repeat (e, 1) vergleicht, um neue [] {e}