206 votos

Pasa un solo elemento como IEnumerable<T>

Existe una forma común para pasar un solo elemento del tipo T a un método que espera un IEnumerable<T> parámetro? El lenguaje es C#, framework versión 2.0.

Actualmente estoy usando un método auxiliar (es .Net 2.0, así que tengo un montón de fundición/proyección de los métodos auxiliares similares a LINQ), pero esto sólo parece tonto:

public static class IEnumerableExt
{
    // usage: IEnumerableExt.FromSingleItem(someObject);
    public static IEnumerable<T> FromSingleItem<T>(T item)
    {
        yield return item; 
    }
}

Otra forma sería, por supuesto, crear y rellenar un List<T> o Array y pasarla en lugar de IEnumerable<T>.

[Editar] Como un método de extensión que podría ser denominado:

public static class IEnumerableExt
{
    // usage: someObject.SingleItemAsEnumerable();
    public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
    {
        yield return item; 
    }
}

Me estoy perdiendo algo aquí?

[Edit2] encontramos someObject.Yield() (como @Pedro se sugieren en los comentarios abajo) para ser el mejor nombre para este método de extensión, principalmente por razones de brevedad, así que aquí está junto con el XML comentar que si alguien quiere tomar simplemente:

public static class IEnumerableExt
{
    /// <summary>
    /// Wraps this object instance into an IEnumerable&lt;T&gt;
    /// consisting of a single item.
    /// </summary>
    /// <typeparam name="T"> Type of the wrapped object.</typeparam>
    /// <param name="item"> The object to wrap.</param>
    /// <returns>
    /// An IEnumerable&lt;T&gt; consisting of a single item.
    /// </returns>
    public static IEnumerable<T> Yield<T>(this T item)
    {
        yield return item;
    }
}

62voto

luksan Puntos 4063

En C# 3.0, se puede utilizar la clase de System.Linq.Enumerable:

// using System.Linq

Enumerable.Repeat(item, 1);

Esto creará un nuevo IEnumerable que sólo contiene el elemento.

61voto

Mario Fernandez Puntos 8974

Así, si el método espera un IEnumerable tienes que pasar algo que es una lista, incluso si contiene un solo elemento.

que pasa

new T[] { item }

como el argumento debe ser suficiente creo

55voto

Jon Skeet Puntos 692016

Su método es la forma más limpia de hacerlo, de la OMI. Si usted pasa en una lista o una matriz, entonces un sin escrúpulos pieza de código podría elenco y cambiar el contenido, que conduce a comportamiento extraño en algunas situaciones. Usted puede utilizar un sólo lectura de la colección, pero es probable que involucrar aún más retorcida. Creo que la solución es tan limpio como se pone.

16voto

Dan Puntos 3922

En C# 3 (yo sé que usted dijo 2), se puede escribir un genérico método de extensión que pueden hacer que la sintaxis un poco más aceptable:

static class IEnumerableExtensions
{
    public static IEnumerable<T> ToEnumerable<T>(this T item)
    {
        yield return item;
    }
}

el código de cliente, a continuación, item.ToEnumerable().

8voto

Joshua Starner Puntos 655

Estoy un poco sorprendido de que nadie sugirió una nueva sobrecarga del método con un argumento de tipo T para simplificar el cliente de la API.

public void DoSomething<T>(IEnumerable<T> list)
{
    // Do Something
}

public void DoSomething<T>(T item)
{
    DoSomething(new T[] { item });
}

Ahora su código de cliente sólo puede hacer esto:

MyItem item = new MyItem();
Obj.DoSomething(item);

o con una lista:

List<MyItem> itemList = new List<MyItem>();
Obj.DoSomething(itemList);

Iteramos.com

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

Powered by:

X