将单个项目作为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; 
    }
}

当然，其他方法是创建并填充a List<T>或an Array并将其传递给而不是IEnumerable<T>。

[编辑]作为扩展方法，它可以命名为：

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

我在这里想念什么吗？

[Edit2]我们发现someObject.Yield()（如@Peter在下面的评论中所建议的）是此扩展方法的最佳名称，主要是为了简洁起见，因此，如果有人想要抓住它，它与XML注释一起使用：

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()。

此辅助方法适用于一个或多个项目。

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

我很惊讶没有人建议使用类型T的参数来简化客户端API的方法的新重载。

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

这种模式将允许您以多种方式调用相同的功能：单个项目；多个项目（以逗号分隔）；数组; 一个列表; 枚举等

我不确定100％使用AsEnumerable方法的效率，但是确实可以。

更新：AsEnumerable函数看起来非常有效！（参考）

尽管这对于一种方法来说过于夸张，但我相信有些人可能会发现Interactive Extensions有用。

Microsoft的交互式扩展（Ix）包括以下方法。

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

可以这样利用：

var result = EnumerableEx.Return(0);

Ix添加了原始Linq扩展方法中找不到的新功能，这是创建反应性扩展（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实现它的过程]。

如果您对它的性能方面感兴趣，James Michael Hare 也会返回零或一件商品，这很值得一看。

这可能没有什么好处，但是有点酷：

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

我同意@EarthEngine对原始帖子的评论，即“ AsSingleton”是一个更好的名称。请参阅此维基百科条目。然后，根据单例的定义得出以下结论：如果将空值作为参数传递，则“ AsSingleton”应返回具有单个空值的IEnumerable而不是将解决if (item == null) yield break;争论的空IEnumerable 。我认为最好的解决方案是使用两种方法：“ 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;
});

上面的代码在使用like时很有用

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

在上面的代码片段中，没有空/空检查，并且保证只返回一个对象而不必担心异常。此外，由于它是惰性的，因此在证明不存在符合标准的数据之前，将不会执行关闭操作。

我参加聚会有点晚了，但是我还是会分享我的方式。我的问题是我想将ItemSource或WPF TreeView绑定到单个对象。层次结构如下所示：

项目>地块>房间

总是只有一个项目，但是我仍然想在树中显示该项目，而不必像建议的那样传递仅包含一个对象的Collection。
由于您只能将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!");

从.NET Framework 4.7.1和.NET Core 1.0开始，后两种方法可用。

这是一个是否是一个可行的解决方案确实在使用现有的方法，而不是写自己，虽然我犹豫不决，如果这是不是更多或更少的明确意图的Enumerable.Repeat<>()解决方案。这肯定是更长的代码（部分是由于无法进行类型参数推断Empty<>()），并且创建了两倍的枚举器对象。

四舍五入“您知道这些方法存在吗？” 答案，Array.Empty<>()可以代替Enumerable.Empty<>()，但很难说情况会变得更好。

我最近在另一篇文章中问了同样的事情（是否有一种方法可以调用需要具有单个值的IEnumerable <T>的C＃方法？）。

我希望人们在这里停留，看看在较新的文章中对这些答案中提出的4种方法进行了简要的基准比较。

似乎简单地new[] { x }在方法的参数中写入是最短和最快的解决方案。