listas - Acceso directo para crear una sola lista de elementos en C#

lista estatica c++

Question

En C #, ¿hay un atajo en línea para instanciar una Lista <T> con solo un elemento?

Actualmente estoy haciendo:

new List<string>( new string[] { "title" } ))

Tener este código en todas partes reduce la legibilidad. He pensado en usar un método de utilidad como este:

public static List<T> SingleItemList<T>( T value )
{
    return (new List<T>( new T[] { value } ));
}

Entonces podría hacer:

SingleItemList("title");

¿Hay una manera más corta / más limpia?

Gracias.

Answer 1

Inspirado por las otras respuestas (¡y así puedo recogerlo cuando lo necesite!), Pero con el nombre / estilo alineado con F # (que tiene una función singleton estándar por estructura de datos *):

namespace System.Collections.Generic
{
    public static class List
    {
        public static List<T> Singleton<T>(T value) => new List<T>(1) { value };
    }
}

* a excepción de ResizeArray por supuesto, de ahí esta pregunta :)

En la práctica, realmente lo llamo Create para alinearlo con otros helpers que defino, como Tuple.Create , Lazy.Create [2], LazyTask.Create , etc.

namespace System.Collections.Generic
{
    static class List
    {
        public static List<T> Create<T>(T value) => new List<T>(1) { value };
    }
}

[2]

namespace System
{
    public static class Lazy
    {
        public static Lazy<T> Create<T>(Func<T> factory) => new Lazy<T>(factory);
    }
}

Answer 2

La idea de Michael de usar métodos de extensión lleva a algo aún más simple:

public static List<T> InList(this T item)
{
    return new List<T> { item };
}

Entonces podrías hacer:

List<string> foo = "Hello".InList();

No estoy seguro de si me gusta o no, fíjate ...

Answer 3

Otra forma más, encontrada en C # /. Net Little wonders :

Enumerable.Repeat("value",1).ToList()

Answer 4

Para un solo elemento enumerable en java, sería Collections.singleton ("cadena");

En c # esto va a ser más eficiente que una nueva lista:

public class SingleEnumerator<T> : IEnumerable<T>
{
    private readonly T m_Value;

    public SingleEnumerator(T value)
    {
        m_Value = value;
    }

    public IEnumerator<T> GetEnumerator()
    {
        yield return m_Value;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        yield return m_Value;
    }
}

pero, ¿hay una manera más simple de usar el marco?

Answer 5

Pruebe var

var s = new List<string> { "a", "bk", "ca", "d" };

Answer 6

Simplemente usa esto:

List<string> list = new List<string>() { "single value" };

Incluso puede omitir los () llaves:

List<string> list = new List<string> { "single value" };

Actualización: por supuesto, esto también funciona para más de una entrada:

List<string> list = new List<string> { "value1", "value2", ... };

Answer 7

También puedes hacer

new List<string>() { "string here" };

Answer 8

Tengo esta pequeña función:

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

Como no prescribe un tipo de retorno concreto, es tan genérico que lo utilizo en todas partes. Tu código se vería como

CoreUtil.ToEnumerable("title").ToList();

Pero, por supuesto, también permite

CoreUtil.ToEnumerable("title1", "title2", "title3").ToArray();

A menudo lo uso cuando tengo que agregar / anteponer un elemento a la salida de una declaración LINQ. Por ejemplo, para agregar un elemento en blanco a una lista de selección:

CoreUtil.ToEnumerable("").Concat(context.TrialTypes.Select(t => t.Name))

Guarda algunas ToList() y Add .

(Última respuesta, pero me encontré con este viejo y pensé que esto podría ser útil)

Answer 9

Una respuesta diferente a la anterior, basada en la exposición a Google Java Collections :

public static class Lists
{
    public static List<T> Of<T>(T item)
    {
        return new List<T> { item };
    }
}

Entonces:

List<string> x = Lists.Of("Hello");

Aconsejo ver el GJC, tiene muchas cosas interesantes. (Personalmente, ignoraría la etiqueta "alfa"; es solo la versión de código abierto que es "alfa" y está basada en una API interna muy estable y muy usada .)

Answer 10

Use un método de extensión con encadenamiento de métodos.

public static List<T> WithItems(this List<T> list, params T[] items)
{
    list.AddRange(items);
    return list;
}

Esto te permitiría hacer esto:

List<string> strings = new List<string>().WithItems("Yes");

o

List<string> strings = new List<string>().WithItems("Yes", "No", "Maybe So");

Actualizar

Ahora puede usar los inicializadores de lista:

var strings = new List<string> { "This", "That", "The Other" };

Ver http://msdn.microsoft.com/en-us/library/bb384062(v=vs.90).aspx

Answer 11

Yo solo haría

var list = new List<string> { "hello" };

Answer 12

new[] { "item" }.ToList();

Es más corto que

new List<string> { "item" };

y no tienes que especificar el tipo.

Answer 13

var list = new List<string>(1) { "hello" };

Muy similar a lo que otros han publicado, excepto que solo se asegura de asignar espacio para el elemento individual inicialmente.

Por supuesto, si sabes que agregarás muchas cosas más tarde, puede que no sea una buena idea, pero vale la pena mencionar una vez.