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

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.

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)

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 https://stackoverflow.com/questions/43601101/what-are-the-43-apis-that-are-in-net-standard-2-0-but-not-in-net-framework-4-6 for a great list of new functionality.

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

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

You can use Enumerable.Concat:

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

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

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

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

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

There is the Concat method which joins two sequences.

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