是否有 Linq 方法可以将单个项目添加到 IEnumerable<T>？

Question

基本上我正在尝试做这样的事情：

image.Layers

它为除Parent 层之外的所有层返回一个 IEnumerable，但在某些情况下，我只想这样做：

image.Layers.With(image.ParentLayer);

因为它只在少数地方使用，而 image.Layers 满足的通常使用的 100 多个。这就是为什么我不想创建另一个也返回 Parent 层的属性。

Answer 1

一种方法是从项目（例如数组）中创建一个单例序列，然后将Concat 放在原始序列上：

image.Layers.Concat(new[] { image.ParentLayer } )

如果您经常这样做，请考虑编写一个Append（或类似的）扩展方法，例如listed here，它可以让您这样做：

image.Layers.Append(image.ParentLayer)

.NET Core 更新 (per the "best" answer below)：

Append 和 Prepend 现在已添加到 .NET Standard 框架中，因此您不再需要自己编写。只需这样做：

image.Layers.Append(image.ParentLayer)

Answer 2

Append 和 Prepend 现在已添加到 .NET Standard 框架中，因此您不再需要自己编写。只需这样做：

image.Layers.Append(image.ParentLayer)

请参阅What are the 43 APIs that are in .Net Standard 2.0 but not in .Net Framework 4.6.1? 了解新功能的详细列表。

Answer 3

已经给出了许多实现。 我的看起来有点不同（但性能一样好）

另外，我发现控制 ORDER 也是可行的。因此，我通常也有一个 ConcatTo 方法，将新元素放在前面。

public static class Utility
{
    /// <summary>
    /// Adds the specified element at the end of the IEnummerable.
    /// </summary>
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam>
    /// <param name="target">The target.</param>
    /// <param name="item">The item to be concatenated.</param>
    /// <returns>An IEnumerable, enumerating first the items in the existing enumerable</returns>
    public static IEnumerable<T> ConcatItem<T>(this IEnumerable<T> target, T item)
    {
        if (null == target) throw new ArgumentException(nameof(target));
        foreach (T t in target) yield return t;
        yield return item;
    }

    /// <summary>
    /// Inserts the specified element at the start of the IEnumerable.
    /// </summary>
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam>
    /// <param name="target">The IEnummerable.</param>
    /// <param name="item">The item to be concatenated.</param>
    /// <returns>An IEnumerable, enumerating first the target elements, and then the new element.</returns>
    public static IEnumerable<T> ConcatTo<T>(this IEnumerable<T> target, T item)
    {
        if (null == target) throw new ArgumentException(nameof(target));
        yield return item;
        foreach (T t in target) yield return t;
    }
}

或者，使用隐式创建的数组。 （使用 params 关键字），以便您可以调用该方法一次添加一个或多个项目：

public static class Utility
{
    /// <summary>
    /// Adds the specified element at the end of the IEnummerable.
    /// </summary>
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam>
    /// <param name="target">The target.</param>
    /// <param name="items">The items to be concatenated.</param>
    /// <returns>An IEnumerable, enumerating first the items in the existing enumerable</returns>
    public static IEnumerable<T> ConcatItems<T>(this IEnumerable<T> target, params T[] items) =>
        (target ?? throw new ArgumentException(nameof(target))).Concat(items);

    /// <summary>
    /// Inserts the specified element at the start of the IEnumerable.
    /// </summary>
    /// <typeparam name="T">The type of elements the IEnumerable contans.</typeparam>
    /// <param name="target">The IEnummerable.</param>
    /// <param name="items">The items to be concatenated.</param>
    /// <returns>An IEnumerable, enumerating first the target elements, and then the new elements.</returns>
    public static IEnumerable<T> ConcatTo<T>(this IEnumerable<T> target, params T[] items) =>
        items.Concat(target ?? throw new ArgumentException(nameof(target)));

Answer 4

没有一种方法可以做到这一点。最接近的是Enumerable.Concat 方法，但它试图将IEnumerable<T> 与另一个IEnumerable<T> 结合起来。您可以使用以下内容使其与单个元素一起使用

image.Layers.Concat(new [] { image.ParentLayer });

或者只是添加一个新的扩展方法

public static IEnumerable<T> ConcatSingle<T>(this IEnumerable<T> enumerable, T value) {
  return enumerable.Concat(new [] { value });
}

Answer 5

你可以使用Enumerable.Concat:

var allLayers = image.Layers.Concat(new[] {image.ParentLayer});

Answer 6

你可以这样做：

image.Layers.Concat(new[] { image.ParentLayer });

将枚举与包含您要添加的内容的单元素数组连接

Answer 7

我曾经为此做了一个不错的小功能：

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

现在这是可能的：

image.Layers.Append(CoreUtil.AsEnumerable(image.ParentLayer, image.AnotherLayer))

Answer 8

如果您喜欢 .With 的语法，请将其写为扩展方法。 IEnumerable 不会注意到另一个。

Answer 9

我使用以下扩展方法来避免创建无用的Array：

public static IEnumerable<T> ConcatSingle<T>(this IEnumerable<T> enumerable, T value) {
   return enumerable.Concat(value.Yield());
}

public static IEnumerable<T> Yield<T>(this T item) {
    yield return item;
}

Answer 10

有Concat 方法可以连接两个序列。

Answer 11

/// <summary>Concatenates elements to a sequence.</summary>
/// <typeparam name="T">The type of the elements of the input sequences.</typeparam>
/// <param name="target">The sequence to concatenate.</param>
/// <param name="items">The items to concatenate to the sequence.</param>
public static IEnumerable<T> ConcatItems<T>(this IEnumerable<T> target, params T[] items)
{
    if (items == null)
        items = new [] { default(T) };
    return target.Concat(items);
}

此解决方案基于realbart's answer。我对其进行了调整以允许使用单个 null 值作为参数：

var newCollection = collection.ConcatItems(null)