.NET Framework
collezioni

Osservazioni

Creazione di un elenco inizializzato con tipi personalizzati

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

Qui abbiamo una classe senza costruttore con due proprietà: Name e una proprietà booleana nullable Selected . Se volessimo inizializzare un List<Model> , ci sono diversi modi per eseguirlo.

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

Qui, stiamo creando diverse new istanze della nostra classe Model e inizializzandole con i dati. Cosa succede se abbiamo aggiunto un costruttore?

public class Model
{

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

Questo ci consente di inizializzare la nostra lista in modo leggermente diverso.

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

Che dire di una classe in cui una delle proprietà è una classe stessa?

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

Si noti che abbiamo ripristinato il costruttore della classe Model per semplificare un po 'l'esempio.

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

Nota che possiamo scambiare la nostra List<ExtendedModel> con Collection<ExtendedModel> , ExtendedModel[] , object[] , o anche semplicemente [] .

Coda

C'è una collezione in .Net usata per gestire i valori in una Queue che usa il concetto FIFO (first-in first-out) . Le basi delle code è il metodo Enqueue(T item) che viene utilizzato per aggiungere elementi nella coda e Dequeue() che viene utilizzato per ottenere il primo elemento e rimuoverlo dalla coda. La versione generica può essere utilizzata come il seguente codice per una coda di stringhe.

Innanzitutto, aggiungi lo spazio dei nomi:

using System.Collections.Generic;

e usalo:

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

Esiste una versione non generica del tipo, che funziona con gli oggetti.

Lo spazio dei nomi è:

using System.Collections;

Ad un esempio di codice per coda non generica:

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)

Esiste anche un metodo chiamato Peek () che restituisce l'oggetto all'inizio della coda senza rimuoverlo.

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

L'output (senza rimuovere):

10
20
30
40
50

Pila

C'è una collezione in .Net usata per gestire i valori in uno Stack che usa il concetto LIFO (last-in first-out) . Le basi degli stack sono il metodo Push(T item) che viene utilizzato per aggiungere elementi nello stack e Pop() che viene utilizzato per ottenere l'ultimo elemento aggiunto e rimuoverlo dallo stack. La versione generica può essere utilizzata come il seguente codice per una coda di stringhe.

Innanzitutto, aggiungi lo spazio dei nomi:

using System.Collections.Generic;

e usalo:

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

Esiste una versione non generica del tipo, che funziona con gli oggetti.

Lo spazio dei nomi è:

using System.Collections;

E un esempio di codice di stack non generico:

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)

Esiste anche un metodo chiamato Peek () che restituisce l'ultimo elemento aggiunto ma senza rimuoverlo dallo Stack .

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

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

È possibile iterare sugli elementi in pila e rispetterà l'ordine dello stack (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);
}

L'output (senza rimuovere):

50
40
30
20
10

Utilizzo degli inizializzatori di raccolta

Alcuni tipi di raccolta possono essere inizializzati al momento della dichiarazione. Ad esempio, la seguente istruzione crea e inizializza i numbers con alcuni numeri interi:

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

Internamente, il compilatore C # converte effettivamente questa inizializzazione in una serie di chiamate al metodo Add. Di conseguenza, è possibile utilizzare questa sintassi solo per le raccolte che supportano effettivamente il metodo Add .

Le classi Stack<T> e Queue<T> non la supportano.

Per raccolte complesse come la classe Dictionary<TKey, TValue> , che Dictionary<TKey, TValue> coppie chiave / valore, è possibile specificare ogni coppia chiave / valore come un tipo anonimo nell'elenco di inizializzazione.

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

Il primo elemento di ciascuna coppia è la chiave e il secondo è il valore.