Pintasan untuk membuat daftar item tunggal dalam C #

Di C #, apakah ada jalan pintas sebaris untuk instantiate Daftar <T> dengan hanya satu item.

Saya sedang melakukan:

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

Memiliki kode ini di mana-mana mengurangi keterbacaan. Saya sudah memikirkan menggunakan metode utilitas seperti ini:

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

Jadi saya bisa melakukan:

SingleItemList("title");

Apakah ada cara yang lebih pendek / bersih?

Terima kasih.

Cukup gunakan ini:

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

Anda bahkan dapat menghilangkan tanda kurung ():

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

Pembaruan: tentu saja ini juga berfungsi untuk lebih dari satu entri:

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

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

Sangat mirip dengan apa yang diposkan orang lain, kecuali bahwa itu memastikan untuk hanya mengalokasikan ruang untuk item tunggal pada awalnya.

Tentu saja, jika Anda tahu Anda akan menambahkan banyak barang nanti mungkin itu bukan ide yang baik, tetapi masih perlu disebutkan sekali.

Gagasan Michael untuk menggunakan metode ekstensi mengarah ke sesuatu yang lebih sederhana:

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

Jadi Anda bisa melakukan ini:

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

Saya tidak yakin apakah saya suka atau tidak, keberatan Anda ...

Jawaban berbeda dari jawaban saya sebelumnya, berdasarkan paparan ke Google Java Collections :

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

Kemudian:

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

Saya menyarankan untuk memeriksa GJC - ada banyak hal menarik di dalamnya (Secara pribadi saya akan mengabaikan tag "alpha" - itu hanya versi open source yang "alpha" dan didasarkan pada API internal yang sangat stabil dan banyak digunakan) .)

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

Lebih pendek dari

new List<string> { "item" };

dan Anda tidak harus menentukan jenisnya.

Gunakan metode ekstensi dengan metode chaining.

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

Ini akan membuat Anda melakukan ini:

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

atau

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

Memperbarui

Anda sekarang dapat menggunakan inisialisasi daftar:

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

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

Namun cara lain, ditemukan di "C # /. Net Little wonders" (sayangnya, situs tidak ada lagi):

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

Untuk satu item yang dapat dihitung dalam java adalah Collections.singleton ("string");

Dalam c # ini akan lebih efisien daripada Daftar baru:

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

tetapi apakah ada cara yang lebih sederhana menggunakan framework?

Saya hanya akan melakukannya

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

Saya punya fungsi kecil ini:

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

Karena tidak menentukan jenis pengembalian beton, ini sangat umum sehingga saya menggunakannya di semua tempat. Kode Anda akan terlihat seperti

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

Tapi tentu saja itu juga memungkinkan

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

Saya sering menggunakannya ketika saya harus menambahkan / menambahkan satu item ke output dari pernyataan LINQ. Misalnya menambahkan item kosong ke daftar pilihan:

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

Menghemat beberapa ToList()dan Addpernyataan.

(Jawaban terlambat, tetapi saya menemukan oldie ini dan berpikir ini bisa membantu)

Coba var

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

Terinspirasi oleh jawaban lain (dan jadi saya dapat mengambilnya kapan pun saya membutuhkannya!), Tetapi dengan penamaan / gaya yang selaras dengan F # (yang memiliki singletonfungsi standar per struktur data *):

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

* kecuali untuk ResizeArraydirinya sendiri tentu saja, maka pertanyaan ini :)

Dalam praktiknya saya benar-benar menamakannya Createuntuk menyelaraskan dengan pembantu lain yang saya definisikan seperti Tuple.Create, Lazy.Create[2], LazyTask.Createdll:

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

Anda juga bisa melakukannya

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