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

我来晚了一点，但我还是要分享我的方式。 我的问题是，我想将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()方法更正了一个错误。

I agree with @EarthEngine's comments to the original post, which is that 'AsSingleton' is a better name. See this wikipedia entry. Then it follows from the definition of singleton that if a null value is passed as an argument that 'AsSingleton' should return an IEnumerable with a single null value instead of an empty IEnumerable which would settle the if (item == null) yield break; debate. I think the best solution is to have two methods: 'AsSingleton' and 'AsSingletonOrEmpty'; where, in the event that a null is passed as an argument, 'AsSingleton' will return a single null value and 'AsSingletonOrEmpty' will return an empty IEnumerable. Like this:

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'扩展方法，这感觉是对的。

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

通过

new[] { item }

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

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

在上面的代码片段中，没有空/空检查，并且保证只返回一个对象，而不担心异常。此外，由于闭包是惰性的，因此直到证明没有现有数据符合条件时才会执行闭包。

在我看来，你的帮手方法是最干净的方法。如果传入一个列表或数组，那么不道德的代码段可能会强制转换它并更改内容，从而在某些情况下导致奇怪的行为。您可以使用只读集合，但这可能涉及更多的包装。我认为你的解决办法非常巧妙。