.NET Framework
Collections

Remarques

Création d'une liste initialisée avec des types personnalisés

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

Nous avons ici une classe sans constructeur avec deux propriétés: Name et une propriété booléenne nullable Selected . Si nous voulions initialiser une List<Model> , il y a plusieurs manières d'exécuter ceci.

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

Ici, nous créons plusieurs new instances de notre classe Model et les initialisons avec des données. Et si on ajoutait un constructeur?

public class Model
{

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

Cela nous permet d’initialiser notre liste un peu différemment.

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

Qu'en est-il d'une classe dont l'une des propriétés est une classe elle-même?

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

Notez que nous avons annulé le constructeur de la classe Model pour simplifier un peu l'exemple.

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

Notez que nous pouvons échanger notre List<ExtendedModel> avec Collection<ExtendedModel> , ExtendedModel[] , object[] , ou même simplement [] .

Queue

Il existe une collection dans .Net utilisée pour gérer les valeurs dans une Queue utilisant le concept FIFO (premier entré, premier sorti) . Les bases des files d'attente sont la méthode Enqueue(T item) qui est utilisée pour ajouter des éléments dans la file d'attente et Dequeue() qui est utilisé pour obtenir le premier élément et le supprimer de la file d'attente. La version générique peut être utilisée comme le code suivant pour une file d'attente de chaînes.

Tout d'abord, ajoutez l'espace de noms:

using System.Collections.Generic;

et l'utiliser:

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

Il existe une version non générique du type, qui fonctionne avec des objets.

L'espace de nom est:

using System.Collections;

Adn un exemple de code pour une file d'attente non générique:

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)

Il y a aussi une méthode appelée Peek () qui renvoie l'objet au début de la file sans le retirer des éléments.

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

La sortie (sans suppression):

10
20
30
40
50

Empiler

Il existe une collection dans .Net utilisée pour gérer les valeurs dans une Stack qui utilise le concept LIFO (last-in first-out) . Les bases des piles sont la méthode Push(T item) qui est utilisée pour ajouter des éléments dans la pile et Pop() qui est utilisé pour obtenir le dernier élément ajouté et le supprimer de la pile. La version générique peut être utilisée comme le code suivant pour une file d'attente de chaînes.

Tout d'abord, ajoutez l'espace de noms:

using System.Collections.Generic;

et l'utiliser:

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

Il existe une version non générique du type, qui fonctionne avec des objets.

L'espace de nom est:

using System.Collections;

Et un exemple de code de pile non générique:

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)

Il existe également une méthode appelée Peek () qui renvoie le dernier élément ajouté, mais sans le retirer de la Stack .

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

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

Il est possible d'itérer sur les éléments de la pile et il respectera l'ordre de la pile (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);
}

La sortie (sans suppression):

50
40
30
20
10

Utilisation des initialiseurs de collection

Certains types de collection peuvent être initialisés au moment de la déclaration. Par exemple, l'instruction suivante crée et initialise les numbers avec des nombres entiers:

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

En interne, le compilateur C # convertit en réalité cette initialisation en une série d'appels à la méthode Add. Par conséquent, vous ne pouvez utiliser cette syntaxe que pour les collections qui prennent en charge la méthode Add .

Les classes Stack<T> et Queue<T> ne le prennent pas en charge.

Pour les collections complexes telles que la classe Dictionary<TKey, TValue> , qui utilisent des paires clé / valeur, vous pouvez spécifier chaque paire clé / valeur en tant que type anonyme dans la liste d'initialisation.

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

Le premier élément de chaque paire est la clé et le second la valeur.