Is there a Linq method to add a single item to an IEnumerable<T>?

Question

I am trying to do something like this:

image.Layers

which returns an IEnumerable<Layer> for all layers except the Parent layer, but in some cases, I just want to do:

image.Layers.With(image.ParentLayer);

because it's only used in a few places compared to the 100s of the usual usage which is satisfied by image.Layers. That's why I don't want to make another property that also returns the Parent layer.

Swedenborgianism

Answer 1

One way would be to create a singleton-sequence out of the item (such as an array), and then Concat it onto the original:

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

If you're doing this really often, consider writing an Append (or similar) extension-method, such as the one listed here, which would let you do:

image.Layers.Append(image.ParentLayer)

.NET Core Update (per the "best" answer below):

Append and Prepend have now been added to the .NET Standard framework, so you no longer need to write your own. Simply do this:

image.Layers.Append(image.ParentLayer)

Lindemann

Answer 2

Append and Prepend have now been added to the .NET Standard framework, so you no longer need to write your own. Simply do this:

image.Layers.Append(image.ParentLayer)

See What are the 43 APIs that are in .Net Standard 2.0 but not in .Net Framework 4.6.1? for a great list of new functionality.

Hord

There is one downside to this approach vs. using .Concat(new[] { ... }): If the item being added also implements IEnumerable<T>, then the Append method will default to adding IEnumerable<T> when you might have just intended to add T. – Intuitivism

Recall, however, that it doesn't operate on the original. You need to image.Layers = image.Layers.Append(image.ParentLayer) (and possibly image.Layers = image.Layers.Append(image.ParentLayer).ToArray() or similar) to get the intended effect. – Trabue

Answer 3

EDIT

Like @cpb mentioned correctly: Append and Prepend comes out of the box now. (source) Microsoft also decided to implement both a way to add items at the start end on the end. They created a AppendPrepend1Iterator class, that has some optimizations (e.g. getting the count if the original underlying collection is an ICollection)

I'll leave my answer for historical reasons.

---

Many implementations have been given already. Mine looks a bit different (but performs just as well)

Also, I find it practicle to also have control over the ORDER. thus often, I also have a ConcatTo method, putting the new element op front.

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

Or alternatively, use an implicitly created array. (using the params keyword) so you can call the method to add one or more items at a time:

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

Utter

.NET will probably compile the yield statement to an anonymous object, which is instantiated. – Candidate

@Jorrit: Actually, the compiler creates an ("anonymous") iterator, which also has some overhead. So the compiled code is bigger, but at runtime the allocated memory is a few bytes instead of a complete duplicate of the list. – Utter

Answer 4

There is no single method which does this. The closest is the Enumerable.Concat method but that tries to combine an IEnumerable<T> with another IEnumerable<T>. You can use the following to make it work with a single element

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

Or just add a new extension method

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

Starvation

Answer 5

You can use Enumerable.Concat:

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

Costumier

Answer 6

You can do something like:

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

which concats the enum with a single-element array containing the thing you want to add

Pishogue

Answer 7

I once made a nice little function for this:

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

Now this is possible:

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

Pod

AsEnumerable is now a built-in extension method as of .Net 3.5, so a different name might be in order. Additionally, AsX implies it's an extension method (aren't methods supposed to be a verb?), so I don't think it was a good name in the first place. I would suggest Enumerate. – Britton

Ha! Long ago. Yes, I came to the same conclusion in the mean time. I still use the little thing, but now it's ToEnumerable. Enumerate isn't bad either. – Pod

I still see ToEnumerable as suggesting an extension method. How about CreateEnumerable? :) – Britton

Answer 8

If you like the syntax of .With, write it as an extension method. IEnumerable won't notice another one.

Distinguishing

Answer 9

I use the following extension methods to avoid creating a useless 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;
}

Raseda

+1 Nice implementation, but why avoid the array? I know it feels wrong to create the array, but is it really less efficient than all the hidden work C# does for these iterators? – Faxun

Yield will allocate and return an anonymous IEnumerable<T> that holds a reference to your item, so this probably takes more memory and time than the single item array. – Peh

Answer 10

There is the Concat method which joins two sequences.

Phytography

The second element is not a sequence... that's the point of the question. – Gillmore

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

This solution is based on realbart's answer. I adjusted it to allow the use of a single null value as a parameter:

var newCollection = collection.ConcatItems(null)

Soporific

Answer 12

With C# 12 Collection expressions you can simply use the .. spread operator:

        IEnumerable<int> a = [1, 2, 3]; // a can be Array, List or any IEnumerable
        IEnumerable<int> b = [..a, 4]; // Append, you can't use var here though
        IEnumerable<int> c = [0, ..a]; // Prepend
        
        Console.WriteLine(string.Join(", ", b));
        Console.WriteLine(string.Join(", ", c));

Interestingly I found this because the code analysis was smart enough to suggest it to me when I was trying to concat a single item with Concat:

int[] a = new[] { 0 }.Concat(b).ToArray();
// IntelliSense suggests:
int[] a = [0, ..b];

Congregationalism