.NET Framework
Sammlungen

Bemerkungen

Erstellen einer initialisierten Liste mit benutzerdefinierten Typen

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

Hier haben wir eine Klasse ohne Konstruktor mit zwei Eigenschaften: Name und eine boolesche, nullfähige Eigenschaft Selected . Wenn wir eine List<Model> initialisieren wollten, gibt es verschiedene Möglichkeiten, dies auszuführen.

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 erstellen wir mehrere new Instanzen unserer Model Klasse und initialisieren sie mit Daten. Was ist, wenn wir einen Konstruktor hinzufügen?

public class Model
{

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

Dadurch können wir unsere Liste etwas anders initialisieren.

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

Was ist mit einer Klasse, bei der eine der Eigenschaften selbst eine Klasse ist?

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

Beachten Sie, dass wir den Konstruktor auf die Klasse Model , um das Beispiel etwas zu vereinfachen.

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

Beachten Sie, dass wir unsere List<ExtendedModel> mit Collection<ExtendedModel> , ExtendedModel[] , object[] oder einfach [] austauschen können.

Warteschlange

In .Net gibt es eine Sammlung, die zum Verwalten von Werten in einer Queue , die das FIFO- Konzept (First-In-First-Out) verwendet . Die Enqueue(T item) der Warteschlangen ist die Methode Enqueue(T item) der Elemente in die Warteschlange Dequeue() und Dequeue() der das erste Element Dequeue() und aus der Warteschlange entfernt wird. Die generische Version kann wie der folgende Code für eine Warteschlange von Zeichenfolgen verwendet werden.

Fügen Sie zuerst den Namespace hinzu:

using System.Collections.Generic;

und benutze es:

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

Es gibt eine nicht generische Version des Typs, die mit Objekten arbeitet.

Der Namensraum ist:

using System.Collections;

Fügen Sie ein Codebeispiel für eine nicht generische Warteschlange hinzu:

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)

Es gibt auch eine Methode namens Peek (), die das Objekt am Anfang der Warteschlange zurückgibt, ohne die Elemente zu entfernen.

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

Die Ausgabe (ohne zu entfernen):

10
20
30
40
50

Stapel

Es gibt eine Sammlung in .NET, die zum Verwalten von Werten in einem Stack , die das LIFO- Konzept (Last-In-First-Out) verwendet . Die Grundlagen von Stapeln sind die Methode Push(T item) der Elemente im Stack hinzugefügt werden, und Pop() der das letzte Element hinzugefügt und aus dem Stack entfernt wird. Die generische Version kann wie der folgende Code für eine Warteschlange von Zeichenfolgen verwendet werden.

Fügen Sie zuerst den Namespace hinzu:

using System.Collections.Generic;

und benutze es:

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

Es gibt eine nicht generische Version des Typs, die mit Objekten arbeitet.

Der Namensraum ist:

using System.Collections;

Und ein Codebeispiel eines nicht generischen Stapels:

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)

Es gibt auch eine Methode namens Peek (), die das zuletzt hinzugefügte Element zurückgibt, ohne es aus dem Stack zu entfernen.

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

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

Es ist möglich, die Elemente auf dem Stapel zu durchlaufen und die Reihenfolge des Stapels (LIFO) einzuhalten.

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

Die Ausgabe (ohne zu entfernen):

50
40
30
20
10

Sammlungsinitialisierer verwenden

Einige Sammlungstypen können zum Zeitpunkt der Deklaration initialisiert werden. Die folgende Anweisung erstellt und initialisiert beispielsweise die numbers mit einigen ganzen Zahlen:

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

Intern konvertiert der C # -Compiler diese Initialisierung tatsächlich in eine Reihe von Aufrufen der Add-Methode. Daher können Sie diese Syntax nur für Auflistungen verwenden, die die Add Methode tatsächlich unterstützen.

Die Klassen Stack<T> und Queue<T> dies nicht.

Für komplexe Sammlungen wie die Klasse Dictionary<TKey, TValue> , die Schlüssel / Wert-Paare annehmen, können Sie jedes Schlüssel / Wert-Paar als anonymen Typ in der Initialisierungsliste angeben.

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

Das erste Element in jedem Paar ist der Schlüssel und das zweite ist der Wert.