ทางลัดสำหรับสร้างรายการเดียวใน 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" };

คล้ายกับที่คนอื่นโพสต์ไว้มากยกเว้นว่าจะต้องจัดสรรพื้นที่สำหรับรายการเดียวในตอนแรกเท่านั้น

แน่นอนว่าหากคุณรู้ว่าคุณจะเพิ่มสิ่งต่างๆมากมายในภายหลังอาจไม่ใช่ความคิดที่ดี แต่ก็ยังควรกล่าวถึงสักครั้ง

ความคิดของ Michael ในการใช้วิธีการขยายนำไปสู่สิ่งที่ง่ายกว่า:

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" - เป็นเพียงเวอร์ชันโอเพ่นซอร์สซึ่งเป็น "อัลฟ่า" และใช้ 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");

อัปเดต

ตอนนี้คุณสามารถใช้ list initializers:

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

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

อีกวิธีหนึ่งที่พบใน "C # /. Net Little Wonders" (น่าเสียดายที่ไซต์นี้ไม่มีอยู่แล้ว):

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

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