让我有点惊讶的是，没有人建议使用类型为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);

被归为“不一定是一个好的解决方案，但仍然……”一个解决方案”或“愚蠢的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<>()，但很难说这样做会使情况好转。

我来晚了一点，但我还是要分享我的方式。 我的问题是，我想将ItemSource或WPF TreeView绑定到单个对象。层次结构是这样的:

项目>图(s) >室(s)

总是只有一个项目，但我仍然想在树中显示项目，而不必像一些人建议的那样传递一个只有一个对象的集合。 因为你只能传递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()方法更正了一个错误。

正如我刚刚发现的，也看到了用户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函数看起来非常高效!(参考)

如果方法需要一个IEnumerable，你就必须传递一个列表，即使它只包含一个元素。

通过

new[] { item }

我认为这个论点应该足够了

我认为最简单的方法是new T[]{item};;没有语法来做这个。我能想到的最类似的是params关键字，但当然，它要求您能够访问方法定义，并且只能用于数组。