.NET Framework
collecties
Zoeken…
Opmerkingen
Er zijn verschillende soorten collecties:
-
Array
-
List
-
Queue
-
SortedList
-
Stack
- Woordenboek
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>
enQueue<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.