.NET Framework
संग्रह

टिप्पणियों

कस्टम प्रकारों के साथ एक प्रारंभिक सूची बनाना

public class Model
{
    public string Name { get; set; }
    public bool? Selected { get; set; }
}

यहां हमारे पास एक क्लास है जिसमें दो गुणों के साथ कोई निर्माता नहीं है: Name और एक अशक्त बूलियन संपत्ति Selected । यदि हम एक List<Model> को इनिशियलाइज़ करना चाहते हैं, तो इसे निष्पादित करने के लिए कुछ अलग तरीके हैं।

var SelectedEmployees = new List<Model>
 {
      new Model() {Name = "Item1", Selected = true},
      new Model() {Name = "Item2", Selected = false},
      new Model() {Name = "Item3", Selected = false},
      new Model() {Name = "Item4"}
 };

यहां, हम अपने Model वर्ग के कई new उदाहरण बना रहे हैं, और उन्हें डेटा के साथ आरंभ कर रहे हैं। क्या होगा अगर हमने एक कंस्ट्रक्टर जोड़ा?

public class Model
{

    public Model(string name, bool? selected = false)
    {
        Name = name;
        selected = Selected;
    }
    public string Name { get; set; }
    public bool? Selected { get; set; }
}

यह हमें हमारी सूची को थोड़ा अलग तरीके से आरंभ करने की अनुमति देता है।

var SelectedEmployees = new List<Model>
{
    new Model("Mark", true),
    new Model("Alexis"),
    new Model("")
};

उस वर्ग के बारे में क्या है जहाँ एक गुण स्वयं एक वर्ग है?

public class Model
{
    public string Name { get; set; }
    public bool? Selected { get; set; }
}

public class ExtendedModel : Model
{
    public ExtendedModel()
    {
        BaseModel = new Model();
    }

    public Model BaseModel { get; set; }
    public DateTime BirthDate { get; set; }
}

ध्यान दें कि हमने उदाहरण को थोड़ा सरल बनाने के लिए Model वर्ग पर निर्माणकर्ता को वापस कर दिया।

var SelectedWithBirthDate = new List<ExtendedModel>
{
    new ExtendedModel()
    {
        BaseModel = new Model { Name = "Mark", Selected = true},
        BirthDate = new DateTime(2015, 11, 23)
    },
                    new ExtendedModel()
    {
        BaseModel = new Model { Name = "Random"},
        BirthDate = new DateTime(2015, 11, 23)
    }
};

ध्यान दें कि हम अपनी List<ExtendedModel> Collection<ExtendedModel> , ExtendedModel[] , object[] , या यहां तक कि बस [] साथ इंटरचेंज कर सकते हैं।

पंक्ति

एक संग्रह में .Net एक Queue में मानों को प्रबंधित करने के लिए उपयोग किया जाता है जो FIFO (पहली-पहली पहली-आउट) अवधारणा का उपयोग करता है। कतारों की मूल बातें विधि Enqueue(T item) जिसका उपयोग कतार में तत्वों को जोड़ने के लिए किया जाता है और Dequeue() जिसका उपयोग पहले तत्व को प्राप्त करने और इसे कतार से निकालने के लिए किया जाता है। जेनेरिक संस्करण को स्ट्रिंग की एक कतार के लिए निम्न कोड की तरह उपयोग किया जा सकता है।

सबसे पहले, नामस्थान जोड़ें:

using System.Collections.Generic;

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

Queue<string> queue = new Queue<string>();
queue.Enqueue("John");
queue.Enqueue("Paul");
queue.Enqueue("George");
queue.Enqueue("Ringo");

string dequeueValue;
dequeueValue = queue.Dequeue(); // return John
dequeueValue = queue.Dequeue(); // return Paul
dequeueValue = queue.Dequeue(); // return George
dequeueValue = queue.Dequeue(); // return Ringo

प्रकार का एक गैर सामान्य संस्करण है, जो वस्तुओं के साथ काम करता है।

नाम स्थान है:

using System.Collections;

नॉन जेनेरिक कतार के लिए एक कोड नमूना लें:

Queue queue = new Queue();
queue.Enqueue("Hello World"); // string
queue.Enqueue(5); // int
queue.Enqueue(1d); // double
queue.Enqueue(true); // bool
queue.Enqueue(new Product()); // Product object

object dequeueValue;
dequeueValue = queue.Dequeue(); // return Hello World (string)
dequeueValue = queue.Dequeue(); // return 5 (int)
dequeueValue = queue.Dequeue(); // return 1d (double)
dequeueValue = queue.Dequeue(); // return true (bool)
dequeueValue = queue.Dequeue(); // return Product (Product type)

पीक () नामक एक विधि भी है जो वस्तु को तत्वों को हटाए बिना कतार की शुरुआत में लौटाती है।

Queue<int> queue = new Queue<int>();
queue.Enqueue(10);
queue.Enqueue(20);
queue.Enqueue(30);
queue.Enqueue(40);
queue.Enqueue(50);

foreach (int element in queue)
{
    Console.WriteLine(i);
}

उत्पादन (हटाने के बिना):

10
20
30
40
50

ढेर

एक संग्रह में .Net का उपयोग एक Stack में मानों को प्रबंधित करने के लिए किया जाता है जो LIFO (पिछली-पहली बार पहली अवधारणा ) का उपयोग करता है। स्टैक की मूल बातें विधि Push(T item) जिसका उपयोग स्टैक में तत्वों को जोड़ने के लिए किया जाता है और Pop() का उपयोग अंतिम तत्व को जोड़ने और स्टैक से निकालने के लिए किया जाता है। जेनेरिक संस्करण को स्ट्रिंग की एक कतार के लिए निम्न कोड की तरह उपयोग किया जा सकता है।

सबसे पहले, नामस्थान जोड़ें:

using System.Collections.Generic;

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

Stack<string> stack = new Stack<string>();
stack.Push("John");
stack.Push("Paul");
stack.Push("George");
stack.Push("Ringo");

string value;
value = stack.Pop(); // return Ringo
value = stack.Pop(); // return George
value = stack.Pop(); // return Paul
value = stack.Pop(); // return John

प्रकार का एक गैर सामान्य संस्करण है, जो वस्तुओं के साथ काम करता है।

नाम स्थान है:

using System.Collections;

और गैर सामान्य स्टैक का एक कोड नमूना:

Stack stack = new Stack();
stack.Push("Hello World"); // string
stack.Push(5); // int
stack.Push(1d); // double
stack.Push(true); // bool
stack.Push(new Product()); // Product object

object value;
value = stack.Pop(); // return Product (Product type)
value = stack.Pop(); // return true (bool)
value = stack.Pop(); // return 1d (double)
value = stack.Pop(); // return 5 (int)
value = stack.Pop(); // return Hello World (string)

पीक () नामक एक विधि भी है जो जोड़े गए अंतिम तत्व को वापस करती है लेकिन Stack से इसे हटाए बिना।

Stack<int> stack = new Stack<int>();
stack.Push(10);
stack.Push(20);

var lastValueAdded = stack.Peek(); // 20

स्टैक पर तत्वों पर पुनरावृति करना संभव है और यह स्टैक (LIFO) के आदेश का सम्मान करेगा।

Stack<int> stack = new Stack<int>();
stack.Push(10);
stack.Push(20);
stack.Push(30);
stack.Push(40);
stack.Push(50);

foreach (int element in stack)
{
   Console.WriteLine(element);
}

उत्पादन (हटाने के बिना):

50
40
30
20
10

संग्रह आरंभीकरण का उपयोग करना

कुछ संग्रह प्रकारों को घोषणा समय पर आरंभ किया जा सकता है। उदाहरण के लिए, निम्नलिखित कथन बनाता है और कुछ पूर्णांकों के साथ numbers को आरंभ करता है:

List<int> numbers = new List<int>(){10, 9, 8, 7, 7, 6, 5, 10, 4, 3, 2, 1};

आंतरिक रूप से, C # संकलक वास्तव में कॉल करने की एक श्रृंखला में इस इनिशियलाइज़ेशन को ऐड विधि में परिवर्तित करता है। नतीजतन, आप इस सिंटैक्स का उपयोग केवल उन संग्रह के लिए कर सकते हैं जो वास्तव में Add विधि का समर्थन करते हैं।

Stack<T> और Queue<T> कक्षाएं इसका समर्थन नहीं करती हैं।

Dictionary<TKey, TValue> वर्ग जैसे जटिल संग्रहों के लिए, जो कुंजी / मान जोड़े लेते हैं, आप प्रत्येक कुंजी / मूल्य जोड़ी को प्रारंभिक सूची में एक अनाम प्रकार के रूप में निर्दिष्ट कर सकते हैं।

Dictionary<int, string> employee = new Dictionary<int, string>()
     {{44, "John"}, {45, "Bob"}, {47, "James"}, {48, "Franklin"}};

प्रत्येक जोड़ी में पहला आइटम कुंजी है, और दूसरा मूल्य है।