IEnumerable <T>として単一の項目を渡す

パラメータTを必要とするメソッドにタイプの単一の項目を渡す一般的な方法はあり IEnumerable<T>ますか？言語はC＃、フレームワークバージョン2.0です。

現在、ヘルパーメソッドを使用しています（それは.Net 2.0なので、LINQに似たキャスト/投影ヘルパーメソッドがたくさんあります）が、これはばかげているように見えます。

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

もちろん、List<T>またはを作成してデータを入力し、のArray代わりに渡す方法もありIEnumerable<T>ます。

[編集]拡張メソッドとして、次のような名前が付けられます：

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

ここで何か不足していますか？

[編集2]someObject.Yield()（以下のコメントで@Peterが示唆しているように）この拡張メソッドの主な名前は簡潔にするために最適な名前であることがわかりました。

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;
    }
}

あなたのヘルパーメソッドはそれを行うための最もクリーンな方法です、IMO。リストまたは配列を渡すと、悪質なコードがキャストして内容を変更し、状況によっては奇妙な動作を引き起こす可能性があります。読み取り専用のコレクションを使用することもできますが、これにはさらに多くのラッピングが含まれる可能性があります。私はあなたの解決策がそれと同じくらい素晴らしいと思います。

まあ、もしメソッドが期待しているIEnumerableなら、たとえそれが一つの要素しか含んでいなくても、リストである何かを渡さなければなりません。

通過

new[] { item }

議論は十分だと思うので

C＃3.0では、System.Linq.Enumerableクラスを利用できます。

// using System.Linq

Enumerable.Repeat(item, 1);

これにより、アイテムのみを含む新しいIEnumerableが作成されます。

C＃3（私はあなたが2と言ったのを知っています）では、構文をもう少し受け入れやすくする可能性がある一般的な拡張メソッドを書くことができます：

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

クライアントコードはitem.ToEnumerable()です。

このヘルパーメソッドは、1つ以上のアイテムで機能します。

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

クライアントAPIを簡略化するために、タイプTの引数を持つメソッドの新しいオーバーロードを提案した人がいないことには、ちょっと驚いています。

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

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

今、あなたのクライアントコードはこれを行うことができます：

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

またはリスト付き：

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

どちらか（以前に述べたように）

MyMethodThatExpectsAnIEnumerable(new[] { myObject });

または

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

補足として、匿名オブジェクトの空のリストが必要な場合は、最後のバージョンも便利です。たとえば、

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

私が見つけたばかりで、ユーザーLukeHも提案しているのを見て、これを行う簡単な方法は次のとおりです。

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
    }
}

このパターンにより、同じ機能をさまざまな方法で呼び出すことができます。複数のアイテム（コンマ区切り）; 配列; リスト; 列挙など

AsEnumerableメソッドを使用する効率については100％わかりませんが、それで十分です。

更新：AsEnumerable関数はかなり効率的に見えます！（参考）

1つの方法ではやり過ぎですが、一部の人はInteractive Extensionsが便利だと思うかもしれません。

MicrosoftのInteractive Extensions（Ix）には、次のメソッドが含まれています。

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

そのように利用できます：

var result = EnumerableEx.Return(0);

Ixは、元のLinq拡張メソッドにはない新しい機能を追加し、Reactive Extensions（Rx）を作成した直接の結果です。

Linq Extension Methods+ Ix= Rxと考えてくださいIEnumerable。

CodePlexでRxとIxの両方を見つけることができます。

これは、30％より速いですyieldかEnumerable.Repeatで使用する場合foreachに起因する、このC＃コンパイラの最適化、および他のケースで同じ性能の。

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);
    }
}

このテストでは：

    // 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はこのトピックについて良い投稿をしてEnumerableFrom()おり、名前として示唆しています（HaskellとRxがそれを呼び出すと述べていますReturn）。IIRC F＃はそれもReturnと呼んでいます。F＃Seqは演算子を呼び出しますsingleton<'T>。

C＃中心になる準備ができていると魅力的なのは、それを呼び出すことですYield[ yield return実現に関与していることをほのめかして]。

あなたがそれのパフォーマンスの側面に興味があるなら、ジェームズ・マイケル・ヘアはゼロまたは1つのアイテムの投稿も返すので、スキャンする価値があります。

これは良くないかもしれませんが、それは一種のクールです：

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

元の投稿への@EarthEngineのコメントに同意します。つまり、「AsSingleton」の方がより良い名前です。このウィキペディアエントリを参照してください。次に、シングルトンの定義から、null値が引数として渡された場合、「AsSingleton」は、if (item == null) yield break;議論を解決する空のIEnumerableではなく、単一のnull値を持つIEnumerableを返す必要があることになります。最善の解決策は2つのメソッドを使用することだと思います。「AsSingleton」と「AsSingletonOrEmpty」。nullが引数として渡された場合、「AsSingleton」は単一のnull値を返し、「AsSingletonOrEmpty」は空のIEnumerableを返します。このような：

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;
}

次に、これらは、多かれ少なかれ、正しいと感じるIEnumerableの「First」および「FirstOrDefault」拡張メソッドに類似しています。

私が言う最も簡単な方法はnew T[]{item};、これを行う構文はありません。私が考えることができる最も近い同等物はparamsキーワードですが、もちろん、メソッド定義にアクセスする必要があり、配列でのみ使用できます。

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

上記のコードは、

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

上記のコードスニペットでは、空/ nullチェックはなく、例外を恐れずに1つのオブジェクトのみが返されることが保証されています。さらに、遅延であるため、既存のデータが基準に適合しないことが証明されるまで、クロージャーは実行されません。

パーティーには少し遅れますが、とにかく自分の道を共有します。私の問題は、ItemSourceまたはWPF TreeViewを単一のオブジェクトにバインドすることでした。階層は次のようになります。

プロジェクト>プロット>部屋

常に1つだけのプロジェクトがありましたが、提案されたように、その1つのオブジェクトだけを含むコレクションを渡す必要なく、プロジェクトをツリーに表示したいと思っていました。
IEnumerableオブジェクトのみをItemSourceとして渡すことができるため、クラスIEnumerableを作成することにしました。

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

    ... 

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

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

それに応じて、独自の列挙子を作成します。

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;
}

これはおそらく「最もクリーンな」ソリューションではありませんが、私にとってはうまくいきました。

編集 @Grooが指摘したように単一責任の原則
を守るために、私は新しいラッパークラスを作成しました：

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();
}

私はこのように使いました

TreeView.ItemSource = new SingleItemWrapper(itemToWrap);

編集2メソッドの
間違いを修正しましたMoveNext()。

「必ずしも良い解決策ではないが、それでも...解決策」または「愚かなLINQトリック」に提出するにはEnumerable.Empty<>()、Enumerable.Append<>()...と組み合わせることができます。

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

...またはEnumerable.Prepend<>()...

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

後者の2つの方法は、.NET Framework 4.7.1および.NET Core 1.0以降で使用できます。

これは1つがあった場合に実行可能なソリューションであり、実際に既存のメソッドを使用しての代わりに、これはより多かれ少なかれ明確であれば、私は未定だが、自分自身の記述の意図ソリューション。これは間違いなく長いコードです（タイプパラメータの推論ができないためです）Enumerable.Repeat<>()Empty<>()）、2倍の数の列挙子オブジェクトが作成されます。

この「これらの方法が存在することをご存知でしたか？」答えは、Array.Empty<>()に置き換えることができますEnumerable.Empty<>()が、それが状況を良くすることを主張するのは難しいです...

私は最近別の投稿で同じことを尋ねました（単一の値でIEnumerable <T>を必要とするC＃メソッドを呼び出す方法はありますか？...ベンチマーク付き）。

私はここに立ち寄って、これらの回答で提示された4つのアプローチについて、新しい投稿で示されている簡単なベンチマーク比較を見てほしいと思いました。

new[] { x }メソッドに引数を書き込むだけが最短かつ最速の解決策のようです。