Übergeben eines einzelnen Elements als IEnumerable <T>

Gibt es eine übliche Möglichkeit, ein einzelnes Element vom Typ Tan eine Methode zu übergeben, die einen IEnumerable<T>Parameter erwartet ? Die Sprache ist C #, Framework Version 2.0.

Derzeit verwende ich eine Hilfsmethode (es ist .Net 2.0, daher habe ich eine ganze Reihe von Hilfsmethoden zum Casting / Projizieren, die LINQ ähneln), aber das scheint einfach albern:

public static class IEnumerableExt
{
    // usage: IEnumerableExt.FromSingleItem(someObject);
    public static IEnumerable<T> FromSingleItem<T>(T item)
    {
        yield return item; 
    }
}

Ein anderer Weg wäre natürlich, ein List<T>oder ein zu erstellen und zu füllen Arrayund es stattdessen zu übergeben IEnumerable<T>.

[Bearbeiten] Als Erweiterungsmethode könnte es heißen:

public static class IEnumerableExt
{
    // usage: someObject.SingleItemAsEnumerable();
    public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
    {
        yield return item; 
    }
}

Vermisse ich hier etwas?

[Edit2] Wir haben festgestellt someObject.Yield()(wie @Peter in den Kommentaren unten vorgeschlagen hat), dass dies der beste Name für diese Erweiterungsmethode ist, hauptsächlich aus Gründen der Kürze. Hier ist es also zusammen mit dem XML-Kommentar, wenn jemand ihn greifen möchte:

public static class IEnumerableExt
{
    /// <summary>
    /// Wraps this object instance into an IEnumerable&lt;T&gt;
    /// consisting of a single item.
    /// </summary>
    /// <typeparam name="T"> Type of the object. </typeparam>
    /// <param name="item"> The instance that will be wrapped. </param>
    /// <returns> An IEnumerable&lt;T&gt; consisting of a single item. </returns>
    public static IEnumerable<T> Yield<T>(this T item)
    {
        yield return item;
    }
}

Ihre Hilfsmethode ist der sauberste Weg, IMO. Wenn Sie eine Liste oder ein Array übergeben, kann ein skrupelloser Code diese umwandeln und den Inhalt ändern, was in einigen Situationen zu merkwürdigem Verhalten führt. Sie könnten eine schreibgeschützte Sammlung verwenden, dies erfordert jedoch wahrscheinlich noch mehr Wrapping. Ich denke, Ihre Lösung ist so ordentlich wie es nur geht.

Nun, wenn die Methode erwartet, dass IEnumerableSie etwas übergeben müssen, das eine Liste ist, auch wenn es nur ein Element enthält.

Vorbeigehen

new[] { item }

da sollte das argument ausreichen sollte ich denke

In C # 3.0 können Sie die System.Linq.Enumerable-Klasse verwenden:

// using System.Linq

Enumerable.Repeat(item, 1);

Dadurch wird eine neue IEnumerable erstellt, die nur Ihren Artikel enthält.

In C # 3 (ich weiß, dass Sie 2 gesagt haben) können Sie eine generische Erweiterungsmethode schreiben, die die Syntax möglicherweise etwas akzeptabler macht:

static class IEnumerableExtensions
{
    public static IEnumerable<T> ToEnumerable<T>(this T item)
    {
        yield return item;
    }
}

Client-Code ist dann item.ToEnumerable().

Diese Hilfsmethode funktioniert für Elemente oder viele.

public static IEnumerable<T> ToEnumerable<T>(params T[] items)
{
    return items;
}    

Ich bin etwas überrascht, dass niemand eine neue Überladung der Methode mit einem Argument vom Typ T vorgeschlagen hat, um die Client-API zu vereinfachen.

public void DoSomething<T>(IEnumerable<T> list)
{
    // Do Something
}

public void DoSomething<T>(T item)
{
    DoSomething(new T[] { item });
}

Jetzt kann Ihr Client-Code Folgendes tun:

MyItem item = new MyItem();
Obj.DoSomething(item);

oder mit einer Liste:

List<MyItem> itemList = new List<MyItem>();
Obj.DoSomething(itemList);

Entweder (wie bereits gesagt)

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

oder

MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(myObject, 1));

Als Randnotiz kann die letzte Version auch schön sein, wenn Sie eine leere Liste eines anonymen Objekts möchten, z

var x = MyMethodThatExpectsAnIEnumerable(Enumerable.Repeat(new { a = 0, b = "x" }, 0));

Wie ich gerade gefunden und gesehen habe, dass Benutzer LukeH auch vorgeschlagen hat, ist eine schöne einfache Möglichkeit, dies zu tun, wie folgt:

public static void PerformAction(params YourType[] items)
{
    // Forward call to IEnumerable overload
    PerformAction(items.AsEnumerable());
}

public static void PerformAction(IEnumerable<YourType> items)
{
    foreach (YourType item in items)
    {
        // Do stuff
    }
}

Mit diesem Muster können Sie dieselbe Funktionalität auf vielfältige Weise aufrufen: ein einzelnes Element; mehrere Elemente (durch Kommas getrennt); eine Anordnung; eine Liste; eine Aufzählung usw.

Ich bin mir nicht 100% sicher, wie effizient die Verwendung der AsEnumerable-Methode ist, aber sie ist ein Vergnügen.

Update: Die AsEnumerable-Funktion sieht ziemlich effizient aus! ( Referenz )

Obwohl es für eine Methode übertrieben ist, glaube ich, dass einige Leute die interaktiven Erweiterungen nützlich finden könnten.

Die Interactive Extensions (Ix) von Microsoft enthalten die folgende Methode.

public static IEnumerable<TResult> Return<TResult>(TResult value)
{
    yield return value;
}

Welches kann so verwendet werden:

var result = EnumerableEx.Return(0);

Ix fügt neue Funktionen hinzu, die in den ursprünglichen Linq-Erweiterungsmethoden nicht enthalten sind, und ist ein direktes Ergebnis der Erstellung der Reactive Extensions (Rx).

Denken Sie, Linq Extension Methods+ Ix= Rxfür IEnumerable.

Sie können sowohl Rx als auch Ix auf CodePlex finden .

Dies ist 30% schneller als yieldoder Enumerable.Repeatbei Verwendung foreachaufgrund dieser C # -Compileroptimierung und in anderen Fällen von gleicher Leistung.

public struct SingleSequence<T> : IEnumerable<T> {
    public struct SingleEnumerator : IEnumerator<T> {
        private readonly SingleSequence<T> _parent;
        private bool _couldMove;
        public SingleEnumerator(ref SingleSequence<T> parent) {
            _parent = parent;
            _couldMove = true;
        }
        public T Current => _parent._value;
        object IEnumerator.Current => Current;
        public void Dispose() { }

        public bool MoveNext() {
            if (!_couldMove) return false;
            _couldMove = false;
            return true;
        }
        public void Reset() {
            _couldMove = true;
        }
    }
    private readonly T _value;
    public SingleSequence(T value) {
        _value = value;
    }
    public IEnumerator<T> GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
    IEnumerator IEnumerable.GetEnumerator() {
        return new SingleEnumerator(ref this);
    }
}

in diesem Test:

    // Fastest among seqs, but still 30x times slower than direct sum
    // 49 mops vs 37 mops for yield, or c.30% faster
    [Test]
    public void SingleSequenceStructForEach() {
        var sw = new Stopwatch();
        sw.Start();
        long sum = 0;
        for (var i = 0; i < 100000000; i++) {
            foreach (var single in new SingleSequence<int>(i)) {
                sum += single;
            }
        }
        sw.Stop();
        Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds}");
        Console.WriteLine($"Mops {100000.0 / sw.ElapsedMilliseconds * 1.0}");
    }

IanG hat einen guten Beitrag zu diesem Thema , der EnumerableFrom()als Namen vorgeschlagen wird (und erwähnt, dass Haskell und Rx ihn nennen Return). IIRC F # nennt es auch Return . F # Seqruft den Operator ansingleton<'T> .

Wenn Sie bereit sind, C # -zentriert zu sein, ist es verlockend, es zu nennen Yield[was auf die yield returnan der Realisierung Beteiligten anspielt ].

Wenn Sie sich für die Perfektion interessieren, hat James Michael Hare auch einen Post mit null oder einem Artikel, der einen Scan wert ist.

Das ist vielleicht nicht besser, aber irgendwie cool:

Enumerable.Range(0, 1).Select(i => item);

Ich stimme den Kommentaren von @ EarthEngine zum ursprünglichen Beitrag zu, wonach 'AsSingleton' ein besserer Name ist. Siehe diesen Wikipedia-Eintrag . Aus der Definition von Singleton folgt dann, dass 'AsSingleton', wenn ein Nullwert als Argument übergeben wird, eine IEnumerable mit einem einzelnen Nullwert anstelle einer leeren IEnumerable zurückgeben sollte, die die if (item == null) yield break;Debatte regeln würde . Ich denke, die beste Lösung besteht darin, zwei Methoden zu haben: 'AsSingleton' und 'AsSingletonOrEmpty'; In dem Fall, dass eine Null als Argument übergeben wird, gibt 'AsSingleton' einen einzelnen Nullwert und 'AsSingletonOrEmpty' eine leere IEnumerable zurück. So was:

public static IEnumerable<T> AsSingletonOrEmpty<T>(this T source)
{
    if (source == null)
    {
        yield break;
    }
    else
    {
        yield return source;
    }
}

public static IEnumerable<T> AsSingleton<T>(this T source)
{
    yield return source;
}

Dann wären diese mehr oder weniger analog zu den Erweiterungsmethoden 'First' und 'FirstOrDefault' in IEnumerable, was sich einfach richtig anfühlt.

Der einfachste Weg, den ich sagen würde, wäre new T[]{item};; Dafür gibt es keine Syntax. Das nächste Äquivalent, an das ich denken kann, ist das paramsSchlüsselwort, aber das erfordert natürlich Zugriff auf die Methodendefinition und kann nur mit Arrays verwendet werden.

Enumerable.Range(1,1).Select(_ => {
    //Do some stuff... side effects...
    return item;
});

Der obige Code ist nützlich, wenn Sie like verwenden

var existingOrNewObject = MyData.Where(myCondition)
       .Concat(Enumerable.Range(1,1).Select(_ => {
           //Create my object...
           return item;
       })).Take(1).First();

Im obigen Code-Snippet gibt es keine Leer- / Null-Prüfung, und es wird garantiert, dass nur ein Objekt ohne Angst vor Ausnahmen zurückgegeben wird. Da es faul ist, wird der Abschluss nicht ausgeführt, bis nachgewiesen wird, dass keine Daten vorhanden sind, die den Kriterien entsprechen.

Ich bin etwas spät zur Party, aber ich werde mich trotzdem teilen. Mein Problem war, dass ich die ItemSource oder eine WPF TreeView an ein einzelnes Objekt binden wollte. Die Hierarchie sieht folgendermaßen aus:

Projekt> Grundstück (e)> Raum (e)

Es gab immer nur ein Projekt, aber ich wollte das Projekt trotzdem im Baum anzeigen, ohne eine Sammlung mit nur diesem einen Objekt übergeben zu müssen, wie von einigen vorgeschlagen.
Da Sie nur IEnumerable-Objekte als ItemSource übergeben können, habe ich beschlossen, meine Klasse IEnumerable zu machen:

public class ProjectClass : IEnumerable<ProjectClass>
{
    private readonly SingleItemEnumerator<AufmassProjekt> enumerator;

    ... 

    public IEnumerator<ProjectClass > GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Und erstelle meinen eigenen Enumerator entsprechend:

public class SingleItemEnumerator : IEnumerator
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(object current)
    {
        this.Current = current;
    }

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public object Current { get; }
}

public class SingleItemEnumerator<T> : IEnumerator<T>
{
    private bool hasMovedOnce;

    public SingleItemEnumerator(T current)
    {
        this.Current = current;
    }

    public void Dispose() => (this.Current as IDisposable).Dispose();

    public bool MoveNext()
    {
        if (this.hasMovedOnce) return false;
        this.hasMovedOnce = true;
        return true;
    }

    public void Reset()
    { }

    public T Current { get; }

    object IEnumerator.Current => this.Current;
}

Dies ist wahrscheinlich nicht die "sauberste" Lösung, aber es hat bei mir funktioniert.

BEARBEITEN
Um das Prinzip der Einzelverantwortung aufrechtzuerhalten, wie @Groo hervorhob, habe ich eine neue Wrapper-Klasse erstellt:

public class SingleItemWrapper : IEnumerable
{
    private readonly SingleItemEnumerator enumerator;

    public SingleItemWrapper(object item)
    {
        this.enumerator = new SingleItemEnumerator(item);
    }

    public object Item => this.enumerator.Current;

    public IEnumerator GetEnumerator() => this.enumerator;
}

public class SingleItemWrapper<T> : IEnumerable<T>
{
    private readonly SingleItemEnumerator<T> enumerator;

    public SingleItemWrapper(T item)
    {
        this.enumerator = new SingleItemEnumerator<T>(item);
    }

    public T Item => this.enumerator.Current;

    public IEnumerator<T> GetEnumerator() => this.enumerator;

    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
}

Was ich so benutzt habe

TreeView.ItemSource = new SingleItemWrapper(itemToWrap);

EDIT 2
Ich habe einen Fehler mit der MoveNext()Methode korrigiert .

Um unter "Nicht unbedingt eine gute Lösung, aber dennoch ... eine Lösung" oder "Dumme LINQ-Tricks" abgelegt zu werden , können Sie Enumerable.Empty<>()mit Enumerable.Append<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Append("Hello, World!");

... oder Enumerable.Prepend<>()...

IEnumerable<string> singleElementEnumerable = Enumerable.Empty<string>().Prepend("Hello, World!");

Die beiden letztgenannten Methoden sind seit .NET Framework 4.7.1 und .NET Core 1.0 verfügbar.

Dies ist eine praktikable Lösung, wenn man wirklich beabsichtigte, vorhandene Methoden zu verwenden, anstatt eigene zu schreiben, obwohl ich mich nicht sicher bin, ob dies mehr oder weniger klar ist als die Enumerable.Repeat<>()Lösung . Dies ist definitiv längerer Code (teilweise aufgrund der nicht möglichen Inferenz von Typparametern Empty<>()) und erstellt jedoch doppelt so viele Enumerator-Objekte.

Abgerundet wird dies durch "Wussten Sie, dass diese Methoden existieren?" Antwort, Array.Empty<>()könnte ersetzt werden Enumerable.Empty<>(), aber es ist schwer zu argumentieren, dass die Situation ... besser macht.

Ich habe kürzlich dasselbe in einem anderen Beitrag gefragt ( Gibt es eine Möglichkeit, eine C # -Methode aufzurufen, für die ein IEnumerable <T> mit einem einzelnen Wert erforderlich ist? ... mit Benchmarking ).

Ich wollte, dass die Leute hier vorbeischauen, um den kurzen Benchmark-Vergleich zu sehen, der in diesem neueren Beitrag für 4 der in diesen Antworten vorgestellten Ansätze gezeigt wird.

Es scheint, dass das einfache Schreiben new[] { x }der Argumente zur Methode die kürzeste und schnellste Lösung ist.