C# Language
संग्रह शुरुआती

टिप्पणियों

संग्रह शुरुआती

मूल्यों के साथ एक संग्रह प्रकार की शुरुआत करें:

var stringList = new List<string>
{
    "foo",
    "bar",
};

संग्रह इनिशियलाइज़र Add() कॉल के लिए सिंटैक्टिक शुगर है। उपरोक्त कोड इसके बराबर है:

var temp = new List<string>();
temp.Add("foo");
temp.Add("bar");
var stringList = temp;

ध्यान दें कि intialization दौड़ की परिस्थितियों से बचने के लिए, अस्थायी रूप से एक अस्थायी चर का उपयोग करके किया जाता है।

अपने Add() विधि में कई मापदंडों की पेशकश करने वाले प्रकारों के लिए, घुंघराले ब्रेस में अल्पविराम से अलग किए गए तर्क संलग्न करें:

var numberDictionary = new Dictionary<int, string>
{
    { 1, "One" },
    { 2, "Two" },
};

यह इसके बराबर है:

var temp = new Dictionary<int, string>();
temp.Add(1, "One");
temp.Add(2, "Two");
var numberDictionarynumberDictionary = temp;

सी # 6 इंडेक्स इनिशियलाइज़र

C # 6 के साथ शुरू करना, इंडेक्स के साथ संग्रह को वर्ग कोष्ठक में निर्दिष्ट करने के लिए इंडेक्स को निर्दिष्ट करके आरंभ किया जा सकता है, इसके बाद एक बराबर चिह्न, उसके बाद असाइन करने के लिए मूल्य।

शब्दकोश प्रारंभिक

एक शब्दकोश का उपयोग करते हुए इस वाक्य रचना का एक उदाहरण:

var dict = new Dictionary<string, int>
{
    ["key1"] = 1,
    ["key2"] = 50
};

यह इसके बराबर है:

var dict = new Dictionary<string, int>();
dict["key1"] = 1;
dict["key2"] = 50

C # 6 से पहले ऐसा करने के लिए संग्रह आरम्भिक सिंटैक्स था:

var dict = new Dictionary<string, int>
{
    { "key1", 1 },
    { "key2", 50 }
};

जो इसके अनुरूप होगा:

var dict = new Dictionary<string, int>();
dict.Add("key1", 1);
dict.Add("key2", 50);

इसलिए कार्यक्षमता में एक महत्वपूर्ण अंतर है, क्योंकि नया सिंटैक्स इसके Add() विधि का उपयोग करने के बजाय मान असाइन करने के लिए आरंभीकृत ऑब्जेक्ट के अनुक्रमणिका का उपयोग करता है। इसका मतलब यह है कि नए सिंटैक्स को केवल सार्वजनिक रूप से उपलब्ध इंडेक्सर की आवश्यकता होती है, और किसी भी ऑब्जेक्ट के लिए काम करता है जिसमें एक है।

public class IndexableClass
{
    public int this[int index]
    {
        set 
        { 
            Console.WriteLine("{0} was assigned to index {1}", value, index);
        }
    }
}

var foo = new IndexableClass
{
    [0] = 10,
    [1] = 20
}

यह आउटपुट होगा:

10 was assigned to index 0
20 was assigned to index 1

कस्टम कक्षाओं में शुरुआती संग्रह

क्लास सपोर्ट कलेक्शन इनिशियलाइज़र बनाने के लिए, इसे IEnumerable इंटरफ़ेस लागू करना होगा और कम से कम एक Add मेथड होना चाहिए। C # 6 के बाद से, IEnumerable को लागू करने वाले किसी भी संग्रह को एक्सटेंशन विधियों का उपयोग करके कस्टम Add विधियों के साथ बढ़ाया जा सकता है।

class Program
{
    static void Main()
    {
        var col = new MyCollection {
            "foo",
            { "bar", 3 },
            "baz",
            123.45d,
        };
    }
}

class MyCollection : IEnumerable
{
    private IList list = new ArrayList();

    public void Add(string item)
    {
        list.Add(item)
    }

    public void Add(string item, int count)
    {
        for(int i=0;i< count;i++) {
            list.Add(item);
        }
    }

    public IEnumerator GetEnumerator()
    {
        return list.GetEnumerator();
    }
}

static class MyCollectionExtensions
{
    public static void Add(this MyCollection @this, double value) => 
        @this.Add(value.ToString());
}

पैरामीटर एरे के साथ संग्रह शुरुआती

आप सामान्य पैरामीटर और पैरामीटर सरणियों को मिला सकते हैं:

public class LotteryTicket : IEnumerable{
    public int[] LuckyNumbers;
    public string UserName;

    public void Add(string userName, params int[] luckyNumbers){
        UserName = userName;
        Lottery = luckyNumbers;
    }
}

यह सिंटैक्स अब संभव है:

var Tickets = new List<LotteryTicket>{
    {"Mr Cool"  , 35663, 35732, 12312, 75685},
    {"Bruce"    , 26874, 66677, 24546, 36483, 46768, 24632, 24527},
    {"John Cena", 25446, 83356, 65536, 23783, 24567, 89337}
}

ऑब्जेक्ट इनिशियलाइज़र के अंदर संग्रह आरंभीकरण का उपयोग करना

public class Tag
{
    public IList<string> Synonyms { get; set; }
}

Synonyms एक संग्रह-प्रकार की संपत्ति है। जब Tag ऑब्जेक्ट को ऑब्जेक्ट इनिशियलज़र सिंटैक्स का उपयोग करके बनाया जाता है, तो Synonyms को संग्रह इनिशिएटिव सिंटैक्स के साथ भी इनिशियलाइज़ किया जा सकता है:

Tag t = new Tag 
{
    Synonyms = new List<string> {"c#", "c-sharp"}
};

संग्रह की संपत्ति को आसानी से पढ़ा जा सकता है और फिर भी संग्रह आरम्भिक सिंटैक्स का समर्थन कर सकता है। इस संशोधित उदाहरण पर विचार करें ( Synonyms संपत्ति अब एक निजी सेटर है):

public class Tag
{
    public Tag()
    {
        Synonyms = new List<string>();
    }
    
    public IList<string> Synonyms { get; private set; }
}

एक नई Tag ऑब्जेक्ट इस तरह बनाई जा सकती है:

Tag t = new Tag 
{
    Synonyms = {"c#", "c-sharp"}
};

यह काम करता है क्योंकि संग्रह आरंभीकृत Add() कॉलों के मुकाबले सिंटैटिक शुगर है। यहां कोई नई सूची नहीं बनाई जा रही है, संकलक अभी बाहर निकलने वाली वस्तु पर Add() को कॉल कर रहा है।