.NET Framework
samlingar

Anmärkningar

Skapa en initialiserad lista med anpassade typer

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

Här har vi en klass utan konstruktör med två egenskaper: Name och en nullable booleska egenskap Selected . Om vi ville initiera en List<Model> , finns det några olika sätt att utföra detta.

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

Här skapar vi flera new instanser av vår Model och initialiserar dem med data. Tänk om vi lägger till en konstruktör?

public class Model
{

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

Detta gör att vi kan initialisera vår lista lite annorlunda.

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

Vad sägs om en klass där en av fastigheterna är en klass själv?

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

Lägg märke till att vi återvände konstruktören i klassen Model att förenkla exemplet lite.

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

Observera att vi kan utbyta vår List<ExtendedModel> med Collection<ExtendedModel> , ExtendedModel[] , object[] eller till och med helt enkelt [] .

Kö

Det finns en samling i .Net som används för att hantera värden i en Queue som använder FIFO (first-in first-out) -konceptet. Grunderna i köer är metoden Enqueue(T item) som används för att lägga till element i kön och Dequeue() som används för att få det första elementet och ta bort det från kön. Den generiska versionen kan användas som följande kod för en strängkö.

Lägg först till namnområdet:

using System.Collections.Generic;

och använd det:

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

Det finns en icke generisk version av typen som fungerar med objekt.

Namnområdet är:

using System.Collections;

Lägg till ett kodprov för icke-generisk kö:

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)

Det finns också en metod som heter Peek () som returnerar objektet i början av kön utan att ta bort elementen.

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

Utgången (utan att ta bort):

10
20
30
40
50

Stack

Det finns en samling i .Net som används för att hantera värden i en Stack som använder LIFO- konceptet. Grunderna i staplar är metoden Push(T item) som används för att lägga till element i stacken och Pop() som används för att få det sista elementet till och ta bort det från stacken. Den generiska versionen kan användas som följande kod för en strängkö.

Lägg först till namnområdet:

using System.Collections.Generic;

och använd det:

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

Det finns en icke generisk version av typen som fungerar med objekt.

Namnområdet är:

using System.Collections;

Och ett kodprov av icke generisk stack:

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)

Det finns också en metod som heter Peek () som returnerar det sista elementet som lagts till men utan att ta bort det från Stack .

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

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

Det är möjligt att iterera på elementen på bunten och det kommer att respektera ordningen på bunten (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);
}

Utgången (utan att ta bort):

50
40
30
20
10

Använda samlingsinitierare

Vissa insamlingstyper kan initialiseras vid deklarationen. Följande uttalande skapar och initialiserar exempelvis numbers med vissa heltal:

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

Internt konverterar C # -kompileraren faktiskt denna initialisering till en serie samtal till metoden Lägg till. Följaktligen kan du använda den här syntaxen endast för samlingar som faktiskt stöder Add metoden.

Klasserna Stack<T> och Queue<T> stöder inte det.

För komplexa samlingar som klassen Dictionary<TKey, TValue> , som tar nyckel- / värdepar, kan du ange varje nyckel- / värdepar som en anonym typ i initialiseringslistan.

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

Det första objektet i varje par är nyckeln, och det andra är värdet.