Ярлык для создания одного списка элементов в C #

В C # есть встроенный ярлык для создания экземпляра List <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 Collections :

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

Затем:

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

Я советую проверить GJC - в нем много интересного. (Лично я бы проигнорировал тег «alpha» - это всего лишь версия с открытым исходным кодом, которая называется «alpha»), и она основана на очень стабильном и интенсивно используемом внутреннем 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 # /. Net Little чудеса» (к сожалению, сайт больше не существует):

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

Для отдельного элемента, перечисляемого в java, это будет Collections.singleton ("string");

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