¿Hay un método de Linq para agregar un solo elemento a un IEnumerable <T>?

Question

Básicamente estoy tratando de hacer algo como esto:

image.Layers 

que devuelve un IEnumerable para todas las capas excepto la capa Parent, pero en algunos casos, sólo quiero hacer:

image.Layers.With(image.ParentLayer); 

porque solo se usa en algunos lugares en comparación con los 100 del uso habitual que se cumple con image.Layers. Es por eso que no quiero hacer otra propiedad que también devuelva la capa Parent.

Answer 1

Una forma sería la creación de un conjunto unitario-secuencia fuera del elemento (como una matriz), y luego Concat que en el original:

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

Si usted está haciendo esto muy a menudo, considere escribir una extensión método Append (o similar), como el que se listed here, que le permiten hacer:

image.Layers.Append(image.ParentLayer) 

Answer 2

Puede utilizar Enumerable.Concat:

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

Answer 3

No es el método Concat que une dos secuencias.

Answer 4

usted puede hacer algo como:

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

cuales concats la enumeración de una serie de un solo elemento que contiene la cosa que desea añadir

Answer 5

Si te gusta la sintaxis de .Con, escribo como un método de extensión. IEnumerable no notará otro.

Answer 6

No hay un solo método que lo haga. El más cercano es el método Enumerable.Concat pero que intenta combinar un IEnumerable<T> con otro IEnumerable<T>. Se puede utilizar el siguiente para que funcione con un solo elemento

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

O simplemente añadir un nuevo método de extensión

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

Answer 7

vez que hice una pequeña función agradable para esto:

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

Ahora esto es posible:

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

Answer 8

Muchas implementaciones ya se han dado. El mío se ve un poco diferente (pero funciona igual de bien)

Además, me parece práctico tener también control sobre el PEDIDO. así que a menudo, también tengo un método ConcatTo, poniendo el nuevo elemento op en primer plano.

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

O, alternativamente, utilizar una matriz creado implícitamente.(Utilizando los params palabra clave) para que pueda llamar al método para agregar uno o más elementos a la vez:

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 9

que utilizan los siguientes métodos de extensión para evitar crear un inútil 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

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

Esta solución se basa en realbart's answer. Me ajusté para permitir el uso de un único valor null como parámetro:

var newCollection = collection.ConcatItems(null) 

Answer 11

Append y Prepend ahora se han añadido a la plataforma .NET estándar, por lo que ya no es necesario escribir el suyo propio. Basta con hacer esto:

image.Layers.Append(image.ParentLayer) 

Ver What are the 43 APIs that are in .Net Standard 2.0 but not in .Net Framework 4.6.1? para una gran lista de nuevas funcionalidades.