Acceso directo para crear una lista de elementos individuales en C #

En C #, ¿hay un acceso directo en línea para crear una instancia de la Lista <T> con un solo 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.

Simplemente use esto:

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

Incluso puede omitir las 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", ... };

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

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

Por supuesto, si sabe que agregará un montón de cosas más tarde, puede que no sea una buena idea, pero vale la pena mencionarlo una vez.

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

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

Entonces podrías hacer esto:

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

No estoy seguro de si me gusta o no, eso sí ...

Una respuesta diferente a la anterior, basada en la exposición a las Colecciones de Google Java :

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

Luego:

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

Aconsejo revisar el GJC - tiene muchas cosas interesantes adentro. (Personalmente ignoraría la etiqueta "alpha" - es solo la versión de código abierto que es "alpha" y se basa en una API interna muy estable y muy utilizada) .)

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

Es mas corto que

new List<string> { "item" };

y no tienes que especificar el tipo.

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

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

Otra forma más, que se encuentra en "C # /. Net Little maravillas" (desafortunadamente, el sitio ya no existe):

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

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

En c # esto 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?

Yo solo haría

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

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 uso por todas partes. Tu código se vería así

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 algunos ToList()y Adddeclaraciones.

(Respuesta tardía, pero me topé con este viejo y pensé que esto podría ser útil)

Prueba var

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

Inspirado por las otras respuestas (¡y así puedo recogerlo cuando lo necesite!), Pero con nombres / estilos alineados con F # (que tiene una singletonfunción 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 };
    }
}

* excepto por ResizeArraysí mismo, por supuesto, de ahí esta pregunta :)

En la práctica he hecho nombro Createpara alinearse con otros ayudantes defino como Tuple.Create, Lazy.Create[2], LazyTask.Createetc:

namespace System.Collections.Generic
{
    public 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);
    }
}

Tambien puedes hacer

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