Ярлик для створення списку окремих елементів у C #

У C # є вбудований ярлик для створення списку <T> лише одним елементом.

Я зараз роблю:

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

Наявність цього коду скрізь знижує читабельність. Я думав використовувати такий корисний метод:

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

Тож я міг би зробити:

SingleItemList("title");

Чи існує коротший / чистіший спосіб?

Дякую.

Просто скористайтеся цим:

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

Ви навіть можете пропустити дужки ():

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

Оновлення: звичайно, це також працює для декількох записів:

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

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

Дуже схоже на те, що опублікували інші, за винятком того, що спочатку потрібно виділити місце лише для одного елемента.

Звичайно, якщо ви знаєте, що ви будете додавати купу речей пізніше, це може бути не гарною ідеєю, але все ж варто згадати один раз.

Ідея Майкла про використання методів розширення призводить до чогось ще простішого:

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

Отже, ви могли це зробити:

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

Я не впевнений, подобається мені це чи ні, зауважте ...

Інша відповідь на мою попередню, засновану на впливі на колекції Google Java :

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

Тоді:

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

Я раджу перевірити GJC - у ньому є багато цікавого. (Особисто я б ігнорував тег "альфа" - це лише версія з відкритим кодом, яка "альфа", і вона заснована на дуже стабільному та широко використовуваному внутрішньому API .)

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

Це коротше, ніж

new List<string> { "item" };

і вам не потрібно вказувати тип.

Використовуйте метод розширення з ланцюжком методів.

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

Це дозволить вам зробити це:

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

або

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

Оновлення

Тепер ви можете використовувати ініціалізатори списку:

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

Дивіться http://msdn.microsoft.com/en-us/library/bb384062(v=vs.90).aspx

Ще один спосіб, знайдений на "C # /. Чисті маленькі чудеса" (на жаль, сайт більше не існує):

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

Для одного елемента, перерахованого в Java, це буде Collections.singleton ("рядок");

У c # це стане ефективнішим, ніж новий Список:

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

але чи є простіший спосіб використання рамки?

Я б просто зробив

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

У мене є ця маленька функція:

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

Оскільки він не призначає конкретного типу повернення, це настільки загальне, що я використовую його всюди. Ваш код виглядав би так

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

Але це, звичайно, дозволяє

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

Я часто використовую його, коли мені потрібно додати / додати один елемент до виводу оператора LINQ. Наприклад, додати пустий елемент до списку вибору:

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

Заощаджує кілька ToList()і Addтверджень.

(Пізня відповідь, але я натрапив на цього старого і подумав, що це може бути корисним)

Спробуйте вар

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

Натхненний іншими відповідями (і тому я можу підібрати його завжди, коли мені це потрібно!), Але з називанням / стилем, узгодженим з F # (який має стандартну singletonфункцію на структуру даних *):

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

* крім ResizeArrayсамого себе, звичайно, звідси це питання :)

На практиці я на самому ділі назвати його Createвирівнювати з іншими помічниками я визначаю , такі як Tuple.Create, Lazy.Create[2], і LazyTask.Createт.д .:

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

Ви також можете зробити

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