1. Créer un dictionnaire en C#
Dans le langage C#, les dictionnaires sont créés en utilisant la classe Dictionary<TKey,TValue>. Cette classe fait partie de l’espace de noms System.Collections.Generic, donc assure-toi d’avoir cette directive en haut de ton fichier :
using System.Collections.Generic;
Ensuite, pour créer un dictionnaire, tu dois déclarer le type de la clé TKey et le type de la valeur TValue. Ces types peuvent être n’importe quel type valide en C#, y compris des types primitifs (int, double, string, etc.), des types définis par l’utilisateur (classes ou structures) ou même d’autres collections (listes, tableaux, autres dictionnaires).
Voici un exemple de création d’un dictionnaire simple avec des chaînes de caractères en tant que clés et des entiers en tant que valeurs :
Dictionary<string, int> dict = new Dictionary<string, int>();
Si tu veux initialiser le dictionnaire avec des valeurs au moment de la création, tu peux utiliser la syntaxe suivante :
Dictionary<string, int> dict = new Dictionary<string, int>
{
{« Apple », 1},
{« Banana », 2},
{« Cherry », 3}
};
Ici, nous avons créé un dictionnaire avec des noms de fruits en tant que clés et des entiers en tant que valeurs.
Il est important de noter que toutes les clés d’un dictionnaire doivent être uniques. Si tu essaies d’ajouter une clé en double dans le dictionnaire, le compilateur générera une exception ArgumentException.
Dictionary<string, int> dict = new Dictionary<string, int>
{
{« Apple », 1},
{« Banana », 2},
{« Apple », 3} // Ceci générera une exception ArgumentException
};
En revanche, les valeurs dans un dictionnaire n’ont pas besoin d’être uniques. Les valeurs peuvent être dupliquées autant de fois que nécessaire.
2. Ajouter des éléments à un dictionnaire
Une fois que tu as créé un dictionnaire en C#, ajouter des éléments est assez simple grâce à la méthode Add(). La méthode Add() prend deux arguments : la clé et la valeur que tu souhaites stocker dans le dictionnaire.
Dictionary<string, int> dict = new Dictionary<string, int>();
dict.Add(« Apple », 1);
dict.Add(« Banana », 2);
dict.Add(« Cherry », 3);
Dans cet exemple, nous avons ajouté trois éléments à notre dictionnaire dict. Chaque élément est composé d’une clé (par exemple, « Apple ») et d’une valeur (par exemple, 1).
Chaque clé dans un dictionnaire doit être unique. Si tu essaies d’ajouter un élément avec une clé qui existe déjà dans le dictionnaire, une exception ArgumentException sera levée. Par exemple, l’ajout suivant provoquera une exception :
dict.Add(« Apple », 4); // Ceci générera une exception ArgumentException.
Pour éviter cette exception, tu peux vérifier si la clé existe déjà dans le dictionnaire avant de tenter d’ajouter un nouvel élément. Tu peux le faire en utilisant la méthode ContainsKey() :
if (!dict.ContainsKey(« Apple »)) {
dict.Add(« Apple », 4);
}
Dans cet exemple, nous n’ajoutons l’élément que si la clé « Apple » n’existe pas déjà dans le dictionnaire.
Une autre façon de gérer cela est d’utiliser la méthode TryAdd(), qui a été introduite dans .NET Core 2.0. Cette méthode tente d’ajouter l’élément spécifié au dictionnaire. Si l’élément est ajouté avec succès, la méthode retourne true si la clé existait déjà, aucun nouvel élément n’est ajouté et la méthode retourne false.
bool added = dict.TryAdd(« Apple », 4); // Retournera false si « Apple » existe déjà.
3. Accéder à des éléments dans un dictionnaire
Les dictionnaires en C# permettent un accès rapide et efficace aux valeurs en utilisant leurs clés correspondantes. Pour accéder à la valeur associée à une clé particulière, il te suffit de passer la clé entre crochets, comme tu le feras avec un tableau :
Dictionary<string, int> fruits = new Dictionary<string, int>
{
{« Apple », 1},
{« Banana », 2},
{« Cherry », 3}
};
int appleQuantity = fruits[« Apple »];
Console.WriteLine(appleQuantity); // Affiche « 1 »
Dans cet exemple, fruits[« Apple »] retourne la valeur (1) associée à la clé « Apple ».
Il est important de noter que si tu essaies d’accéder à une clé qui n’existe pas dans le dictionnaire, le programme lancera une KeyNotFoundException. Par exemple, l’exécution de fruits[« Pear »] dans notre exemple précédent causerait une exception, car « Pear » n’est pas une clé de notre dictionnaire.
Pour éviter cela, tu peux vérifier si une clé existe avant d’essayer d’y accéder. La méthode ContainsKey() est utile pour cela. Elle prend une clé en argument et renvoie true si cette clé est dans le dictionnaire, false sinon :
if (fruits.ContainsKey(« Pear »)) {
int pearQuantity = fruits[« Pear »];
} else {
Console.WriteLine(« The key ‘Pear’ does not exist in the dictionary. »);
}
Une autre façon d’accéder à une valeur sans risquer une exception est d’utiliser la méthode TryGetValue(). Cette méthode prend en argument la clé à rechercher et une variable de sortie où la valeur trouvée (si elle existe) sera stockée. Elle renvoie true si la clé a été trouvée et false sinon :
int pearQuantity;
bool keyExists = fruits.TryGetValue(« Pear », out pearQuantity);
if (keyExists) {
Console.WriteLine(pearQuantity);
} else {
Console.WriteLine(« The key ‘Pear’ does not exist in the dictionary. »);
}
Dans cet exemple, si « Pear » est une clé dans le dictionnaire, sa valeur associée sera stockée dans pearQuantity et utilisée dans le code. Si « Pear » n’est pas une clé dans le dictionnaire, le message d’erreur sera affiché.
4. Modifier des éléments dans un dictionnaire
Pour modifier une valeur dans un dictionnaire en C#, tu peux simplement utiliser l’opérateur d’affectation (=) avec la clé de l’élément que tu peux changer.
Dictionary<string, int> fruits = new Dictionary<string, int>
{
{« Apple », 1},
{« Banana », 2},
{« Cherry », 3}
};
// Modifier la valeur associée à la clé « Apple »
fruits[« Apple »] = 5;
Dans cet exemple, la valeur associée à la clé « Apple » est maintenant 5.
Notez que si la clé spécifiée n’existe pas dans le dictionnaire, cette opération ajoutera une nouvelle paire clé-valeur avec la clé et la valeur spécifiées. Par exemple :
// Ajouter une nouvelle paire clé-valeur
fruits[« Pear »] = 4;
Dans cet exemple, une nouvelle paire clé-valeur avec la clé « Pear » et la valeur 4 est ajoutée au dictionnaire.
C’est une différence importante entre l’opérateur d’affectation et la méthode Add(). La méthode Add() génère une exception si la clé existe déjà dans le dictionnaire, tandis que l’opérateur d’affectation modifie simplement la valeur existante.
Si tu peux assurer qu’une clé existe déjà avant de modifier sa valeur, tu peux utiliser la méthode ContainsKey(), comme expliqué dans les sections précédentes :
if (fruits.ContainsKey(« Apple »)) {
fruits[« Apple »] = 5;
} else {
Console.WriteLine(« The key ‘Apple’ does not exist in the dictionary. »);
}
Dans cet exemple, la valeur associée à la clé « Apple » n’est modifiée que si « Apple » est déjà une clé dans le dictionnaire.
5. Parcourir un dictionnaire
Parcourir un dictionnaire en C# peut être réalisé de plusieurs façons. Un dictionnaire stocke des paires de clés-valeurs, et tu peux choisir de parcourir les clés, les valeurs ou les deux.
Parcourir les clés et les valeurs
Une des façons les plus courantes de parcourir un dictionnaire est d’utiliser une boucle foreach. Chaque élément dans un dictionnaire est un objet KeyValuePair<TKey, TValue>. Tu peux donc utiliser une boucle foreach pour parcourir ces objets :
Dictionary<string, int> fruits = new Dictionary<string, int>
{
{« Apple », 1},
{« Banana », 2},
{« Cherry », 3}
};
foreach (KeyValuePair<string, int> fruit in fruits)
{
Console.WriteLine(« Key: {0}, Value: {1} », fruit.Key, fruit.Value);
}
Dans cet exemple, fruit.Key donne la clé de l’élément courant et fruit.Value donne la valeur correspondante.
Parcourir uniquement les clés ou les valeurs
Si tu es uniquement intéressé par les clés ou les valeurs, tu peux utiliser les propriétés Keys et Values :
// Parcourir uniquement les clés
foreach (string key in fruits.Keys)
{
Console.WriteLine(« Key: {0} », key);
}
// Parcourir uniquement les valeurs
foreach (int value in fruits.Values)
{
Console.WriteLine(« Value: {0} », value);
}
Dans ces exemples, le premier foreach parcourt uniquement les clés du dictionnaire, tandis que le second parcourt uniquement les valeurs.
Utiliser LINQ
Enfin, si tu utilises .NET Framework 3.5 ou une version ultérieure, tu peux utiliser LINQ (Language Integrated Query) pour effectuer des opérations plus complexes sur un dictionnaire. Par exemple, tu peux trouver toutes les clés dans un dictionnaire dont la valeur est supérieure à un certain nombre :
var keysWithHighValues = fruits.Where(pair => pair.Value > 1).Select(pair => pair.Key);
foreach (string key in keysWithHighValues)
{
Console.WriteLine(« Key with value > 1: {0} », key);
}
Dans cet exemple, Where(pair => pair.Value > 1) filtre les paires clé-valeur dont la valeur est supérieure à 1, et Select(pair => pair.Key) extrait les clés de ces paires. Le résultat est une collection de clés que tu peux parcourir avec une boucle foreach.
Avec ces techniques, tu peux facilement parcourir un dictionnaire en C# et effectuer des opérations sur ses éléments.
6. Supprimer des éléments d’un dictionnaire
Il est très facile de supprimer des éléments d’un dictionnaire en utilisant la méthode Remove().
Voici comment tu peux le faire :
Dictionary<string, int> fruits = new Dictionary<string, int>
{
{« Apple », 1},
{« Banana », 2},
{« Cherry », 3}
};
// Supprimer l’élément avec la clé « Apple »
fruits.Remove(« Apple »);
Dans cet exemple, l’élément avec la clé « Apple » est supprimé du dictionnaire fruits.
La méthode Remove() retourne une valeur booléenne qui indique si la suppression a été réussie. Si la clé donnée est trouvée et son élément est supprimé, la méthode retourne true. Si la clé donnée ne se trouve pas dans le dictionnaire, la méthode retourne false.
bool isRemoved = fruits.Remove(« Apple »);
Console.WriteLine(isRemoved ? « Element was removed successfully. » : « Element not found. »);
Dans cet exemple, un message est affiché en fonction du succès ou de l’échec de la suppression.
Si tu veux supprimer tous les éléments d’un dictionnaire, tu peux utiliser la méthode Clear(). Cette méthode ne prend aucun argument et supprime tous les éléments du dictionnaire.
fruits.Clear(); // Supprime tous les éléments du dictionnaire.
En utilisant ces méthodes, tu peux facilement supprimer des éléments d’un dictionnaire en C#.