Scorciatoia per la creazione di un singolo elenco di elementi in C #

In C #, esiste un collegamento in linea per creare un'istanza di un Elenco <T> con un solo elemento.

Attualmente sto facendo:

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

Avere questo codice ovunque riduce la leggibilità. Ho pensato di utilizzare un metodo di utilità come questo:

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

Quindi potrei fare:

SingleItemList("title");

C'è un modo più breve / più pulito?

Grazie.

Basta usare questo:

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

Puoi anche omettere le parentesi graffe ():

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

Aggiornamento: ovviamente questo funziona anche per più di una voce:

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

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

Molto simile a quello che altri hanno pubblicato, tranne per il fatto che inizialmente alloca solo lo spazio per il singolo elemento.

Naturalmente, se sai che aggiungerai un sacco di cose in seguito, potrebbe non essere una buona idea, ma vale comunque la pena menzionarle una volta.

L'idea di Michael di utilizzare i metodi di estensione porta a qualcosa di ancora più semplice:

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

Quindi potresti farlo:

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

Non sono sicuro che mi piaccia o no, intendiamoci ...

Una risposta diversa alla mia precedente, basata sull'esposizione alle raccolte Java di Google :

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

Poi:

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

Consiglio di dare un'occhiata al GJC - contiene molte cose interessanti. (Personalmente ignorerei il tag "alpha" - è solo la versione open source che è "alpha" ed è basata su un'API interna molto stabile e molto usata .)

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

È più corto di

new List<string> { "item" };

e non è necessario specificare il tipo.

Utilizzare un metodo di estensione con concatenamento di metodi.

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

Questo ti permetterebbe di fare questo:

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

o

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

Aggiornare

Ora puoi utilizzare gli inizializzatori di elenchi:

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

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

Ancora un altro modo, trovato su "C # /. Net Little Wonders" (sfortunatamente, il sito non esiste più):

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

Per un singolo elemento enumerabile in java sarebbe Collections.singleton ("stringa");

In c # questo sarà più efficiente di un nuovo elenco:

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

ma c'è un modo più semplice di usare il framework?

Vorrei solo fare

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

Ho questa piccola funzione:

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

Dal momento che non prescrive un tipo di ritorno concreto, questo è così generico che lo uso ovunque. Il tuo codice sarebbe simile

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

Ma ovviamente lo permette anche

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

Lo uso spesso quando devo aggiungere / anteporre un elemento all'output di un'istruzione LINQ. Ad esempio per aggiungere un elemento vuoto a un elenco di selezione:

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

Salva alcune dichiarazioni ToList()e Add.

(Risposta tardiva, ma mi sono imbattuto in questo vecchio e ho pensato che potesse essere utile)

Prova var

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

Ispirato dalle altre risposte (e quindi posso raccoglierlo ogni volta che ne ho bisogno!), Ma con denominazione / stile allineati con F # (che ha una singletonfunzione standard per struttura di dati *):

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

* tranne che per ResizeArraysé ovviamente, quindi questa domanda :)

In pratica lo chiamo in realtàCreate per allinearlo con altri helper che definisco come Tuple.Create, Lazy.Create[2], LazyTask.Createecc:

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

Puoi anche fare

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