C # 'da tek öğe listesi oluşturma kısayolu

C # 'da, bir Listeyi <T> başlatmak için yalnızca bir öğeyle satır içi kısayol var mı?

Şu anda yapıyorum:

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

Bu kodun her yerde bulunması okunabilirliği azaltır. Ben böyle bir yardımcı yöntem kullanmayı düşündüm:

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

Böylece yapabilirim:

SingleItemList("title");

Daha kısa / daha temiz bir yol var mı?

Teşekkürler.

Sadece şunu kullanın:

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

() Parantezlerini bile atlayabilirsiniz:

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

Güncelleme: tabii ki bu birden fazla giriş için de çalışır:

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

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

Başlangıçta yalnızca tek bir öğe için yer ayırmayı sağlamak dışında, diğerlerinin gönderdiklerine çok benzer.

Tabii ki, daha sonra bir sürü şey ekleyeceğinizi biliyorsanız, iyi bir fikir olmayabilir, ancak yine de bir kez bahsetmeye değer.

Michael'ın uzatma yöntemlerini kullanma fikri daha da basit bir şeye yol açar:

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

Böylece bunu yapabilirsiniz:

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

Sevip sevmediğimden emin değilim, dikkat et ...

Google Java Koleksiyonlarına maruz kalmama dayalı olarak öncekime farklı bir cevap :

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

Sonra:

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

GJC'yi kontrol etmenizi öneririm - içinde çok ilginç şeyler var. .)

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

Daha kısa

new List<string> { "item" };

ve türü belirtmeniz gerekmez.

Yöntem zincirleme ile bir genişletme yöntemi kullanın.

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

Bu, bunu yapmanıza izin verir:

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

veya

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

Güncelleme

Artık liste başlatıcıları kullanabilirsiniz:

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

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

"C # /. Net Little harikaları" üzerinde bulunan başka bir yol (ne yazık ki, site artık mevcut değil):

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

Java'da numaralandırılabilen tek bir öğe için Collections.singleton ("string");

C # 'da bu yeni bir Listeden daha verimli olacaktır:

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

ancak çerçeveyi kullanmanın daha basit bir yolu var mı?

Sadece yaparım

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

Bu küçük işleve sahibim:

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

Somut bir geri dönüş tipi reçete etmediği için, o kadar genel ki, her yerde kullanıyorum. Kodunuz şöyle görünür

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

Ama tabii ki

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

Bir LINQ deyiminin çıktısına bir öğe eklemek / eklemek zorunda kaldığımda sıklıkla kullanırım. Örneğin, seçim listesine boş bir öğe eklemek için:

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

Birkaç kaydeder ToList()ve Addifadeler.

(Geç cevap, ama bu ihtiyar tökezledi ve bunun yararlı olabileceğini düşündüm)

Var'ı deneyin

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

Diğer cevaplardan esinlenerek (ve ihtiyaç duyduğumda alabilirim!), Ancak adlandırma / stil ile F # ( singletonveri yapısı başına standart bir işleve sahiptir) ile hizalanmış :

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

* ResizeArrayTabii ki kendisi hariç , bu yüzden bu soru :)

Pratikte ben aslında Adını Createben gibi tanımlayan diğer yardımcıları uyum sağlamak Tuple.Create, Lazy.Create[2], LazyTask.Createvb:

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

Ayrıca yapabilirsin

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