C # में एकल आइटम सूची बनाने के लिए शॉर्टकट

Question

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

वहाँ एक छोटा / क्लीनर तरीका है?

धन्यवाद।

Answer 1

बस इसका उपयोग करें:

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

आप भी () ब्रेसिज़ को छोड़ सकते हैं:

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

अद्यतन: बेशक यह एक से अधिक प्रविष्टि के लिए भी काम करता है:

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

Comments

पहले विकल्प के कोष्ठकों में 1 शाब्दिक डालें, ताकि एक स्थान के लिए भंडारण डिफ़ॉल्ट 10 के बजाय आवंटित किया जाए

— जोएल कोएहॉर्न

डिफ़ॉल्ट 4 समाप्त हो रहा है, मेरा मानना ​​है: नई सूची <string> {"हैलो"}। शुद्धता == 4

— जॉन स्कीट

Answer 2

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

दूसरों ने जो पोस्ट किया है, उसके समान ही, यह सुनिश्चित करता है कि शुरू में केवल एकल आइटम के लिए जगह आवंटित करना सुनिश्चित करें।

बेशक, अगर आपको पता है कि आप बाद में सामान का एक गुच्छा जोड़ देंगे तो यह एक अच्छा विचार नहीं हो सकता है, लेकिन फिर भी एक बार ध्यान देने योग्य है।

Comments

क्षमता एक के लिए सेट। मैंने इस पृष्ठ पर चार जवाबों के लिए मतदान किया जिसमें जॉन स्कीट दोनों शामिल हैं लेकिन मैं इसे सबसे सही मानता हूं।

— लोनली कोडर

Answer 3

विस्तार विधियों का उपयोग करने के माइकल के विचार से कुछ सरल भी हो जाता है:

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

तो आप ऐसा कर सकते हैं:

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

मुझे यकीन नहीं है कि मुझे यह पसंद है या नहीं, आपको बुरा लगता है ...

Comments

मुझे यकीन नहीं है कि मुझे यह पसंद है: यह स्ट्रिंग प्रकार (उदाहरण के लिए) का "अजीब" विस्तार नहीं है?

— 194 पर M4N

मैंने इसे आपकी पुस्तक में अभी तक विस्तार के तरीकों के लिए नहीं बनाया है, जॉन :-) यह अजीब तरह का लगता है, लेकिन मुझे इसकी उपयोगिता पसंद है। धन्यवाद मार्टिन और जॉन।

— रेयान इशे

@ मॉर्टिन: यह हर प्रकार का एक अजीब विस्तार है । यह आमतौर पर हतोत्साहित किया जाता है, लेकिन यह एक दिलचस्प सामान्य विचार है।

— जॉन स्कीट

यह विशेष रूप से मूल्य प्रकारों के साथ कुछ आंतरिक डोमेन विशिष्ट भाषा का उपयोग करता है। उदाहरण के लिए लें: घड़ी ।lertUser.In (1.Muteute) घड़ी की तुलना में बहुत बेहतर पढ़ती है। AlertUser (TimeSpan.FromMinute (1));

— माइकल मीडोज

Answer 4

Google जावा संग्रह के संपर्क के आधार पर मेरे पहले वाले का एक अलग उत्तर :

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

फिर:

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

मैं GJC की जाँच करने की सलाह देता हूं - इसमें बहुत सारी दिलचस्प चीजें हैं। (व्यक्तिगत रूप से मैं "अल्फा" टैग को अनदेखा करूंगा - यह केवल खुला स्रोत संस्करण है जो "अल्फा" है और यह बहुत स्थिर और भारी रूप से उपयोग किए जाने वाले आंतरिक एपीआई पर आधारित है। ।)

Answer 5

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

से छोटा है

new List<string> { "item" };

और आपको प्रकार निर्दिष्ट करने की आवश्यकता नहीं है।

Answer 6

एक विधि विधि का उपयोग करते हुए विधि जंजीर के साथ।

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 देखें

Comments

शायद यह 2009 के बाद से सी # के नए संस्करणों के कारण है, लेकिन मुझे new List<string> {"Yes"}बेहतर लगता है ...?

— एरिक

@ErikE Microsoft दस्तावेज़ीकरण ( msdn.microsoft.com/en-us/library/bb384062(v=vs.90).aspx ) के अनुसार विज़ुअल स्टूडियो 2008 में इसका समर्थन किया गया था। मुझे याद नहीं होगा कि निश्चित रूप से कहने के लिए वह बहुत दूर है। मैंने उस समय इसे अधिक जटिल बना दिया। अद्यतन कर रहा है।

— माइकल मीडोज

Answer 7

फिर भी एक और तरीका, "सी # /। नेट लिटिल वंडर्स" पर पाया गया (दुर्भाग्य से, साइट अब मौजूद नहीं है):

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

Comments

भ्रामक लेकिन चतुर।

— PRMan

Answer 8

जावा में एक एकल आइटम के लिए यह संग्रह होगा। सिंघलटन ("स्ट्रिंग");

सी # में यह एक नई सूची की तुलना में अधिक कुशल होने जा रहा है:

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

लेकिन क्या फ्रेमवर्क का उपयोग करने का एक सरल तरीका है?

Comments

यह वास्तव में मेरी राय में सबसे अच्छा जवाब है। आवंटन आकार को कम करने के लिए एकल आइटम सूची होना एक बहुत ही सामान्य पैटर्न है। यदि आप पहले से ही एक शॉर्टकट की तलाश कर रहे हैं तो आप सुविधाजनक को अच्छे के साथ जोड़ सकते हैं।

— एलेक्स

Answer 9

मैं बस करूँगा

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

Answer 10

मुझे यह छोटा सा फंक्शन मिला है:

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

मैं अक्सर इसका उपयोग तब करता हूं जब मुझे एक आइटम को एक लाइनक्यू स्टेटमेंट के आउटपुट के लिए संलग्न करना / रोकना होता है। उदाहरण के लिए चयन सूची में एक रिक्त आइटम जोड़ने के लिए:

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

कुछ बचाता है ToList()और Addबयान करता है।

(देर से जवाब, लेकिन मैं इस पुराने पर ठोकर खाई और सोचा कि यह उपयोगी हो सकता है)

Answer 11

कोशिश वर

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

Answer 12

अन्य उत्तरों से प्रेरित (और इसलिए जब भी मुझे इसकी आवश्यकता हो मैं इसे उठा सकता हूं!), लेकिन नामकरण / स्टाइल के साथ एफ # (जो कि 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);
    }
}

Comments

धन्यवाद! मेरा समाधान भी। युगल बातें: (1) आपकी सूची का कार्यान्वयन सार्वजनिक नहीं है, इसलिए इसे घोषित विधानसभा के बाहर इस्तेमाल नहीं किया जा सकता है, और (2) सिस्टम नेमस्पेस में इन्हें भरने का क्या उद्देश्य है?

— कोडर

Lazyविस्तार करने के लिए @StephenRobinson कारण Systemयह है कि Lazyखुद में है System[और इसलिए Createकॉम्पेलिटन सूचियों में बिना प्रकट होगा using]। लोगों को openएक अलग नामस्थान के लिए मजबूर करने से कुछ हासिल नहीं होता है ? दूसरी बात को निजी बनाना जानबूझकर नहीं था; नियत

— रूबेन बार्टलिंक

Answer 13

आप भी कर सकते हैं

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