.NET Framework
collecties

Opmerkingen

Een geïnitialiseerde lijst met aangepaste typen maken

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

Hier hebben we een klasse zonder constructor met twee eigenschappen: Name en een nullable Boolean-eigenschap Selected . Als we een List<Model> wilden initialiseren, zijn er een paar verschillende manieren om dit uit te voeren.

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

Hier maken we verschillende new exemplaren van onze Model en initialiseren ze met gegevens. Wat als we een constructor toevoegen?

public class Model
{

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

Hierdoor kunnen we onze lijst een beetje anders initialiseren.

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

Hoe zit het met een klasse waar een van de eigenschappen zelf een klasse is?

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

Merk op dat we de constructor op de Model klasse hebben teruggezet om het voorbeeld een beetje te vereenvoudigen.

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

Merk op dat we onze List<ExtendedModel> kunnen uitwisselen met Collection<ExtendedModel> , ExtendedModel[] , object[] , of zelfs gewoon [] .

Wachtrij

Er is een verzameling in .Net die wordt gebruikt om waarden in een Queue te beheren die het FIFO- concept (first-in first-out) gebruikt . De basis van wachtrijen is de methode Enqueue(T item) die wordt gebruikt om elementen in de wachtrij toe te voegen en Dequeue() die wordt gebruikt om het eerste element te krijgen en uit de wachtrij te verwijderen. De generieke versie kan worden gebruikt zoals de volgende code voor een rij met strings.

Voeg eerst de naamruimte toe:

using System.Collections.Generic;

en gebruik het:

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

Er is een niet-generieke versie van het type dat met objecten werkt.

De naamruimte is:

using System.Collections;

Voeg een codevoorbeeld toe voor niet-generieke wachtrij:

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)

Er is ook een methode genaamd Peek () die het object aan het begin van de wachtrij retourneert zonder de elementen te verwijderen.

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

De uitvoer (zonder te verwijderen):

10
20
30
40
50

stack

Er is een verzameling in .Net die wordt gebruikt om waarden in een Stack te beheren die het LIFO- concept (last-in first-out) gebruikt . De basis van stapels is de methode Push(T item) die wordt gebruikt om elementen in de stapel toe te voegen en Pop() die wordt gebruikt om het laatst toegevoegde element te krijgen en van de stapel te verwijderen. De generieke versie kan worden gebruikt zoals de volgende code voor een rij met strings.

Voeg eerst de naamruimte toe:

using System.Collections.Generic;

en gebruik het:

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

Er is een niet-generieke versie van het type dat met objecten werkt.

De naamruimte is:

using System.Collections;

En een codevoorbeeld van niet-generieke stapel:

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)

Er is ook een methode genaamd Peek () die het laatst toegevoegde element retourneert, maar zonder het uit de Stack te verwijderen.

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

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

Het is mogelijk om de elementen op de stapel te herhalen en de volgorde van de stapel (LIFO) te respecteren.

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

De uitvoer (zonder te verwijderen):

50
40
30
20
10

Verzamelinginitializers gebruiken

Sommige soorten collecties kunnen op het moment van aangifte worden geïnitialiseerd. De volgende instructie maakt en initialiseert bijvoorbeeld de numbers met enkele gehele getallen:

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

Intern converteert de C # compiler deze initialisatie naar een reeks aanroepen naar de methode Add. Daarom kunt u deze syntaxis alleen gebruiken voor collecties die de methode Add daadwerkelijk ondersteunen.

De klassen Stack<T> en Queue<T> ondersteunen dit niet.

Voor complexe collecties zoals de klasse Dictionary<TKey, TValue> , die sleutel / waarde-paren bevatten, kunt u elk sleutel / waarde-paar opgeven als een anoniem type in de initialisatielijst.

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

Het eerste item in elk paar is de sleutel en het tweede is de waarde.