Menu

Liste et dictionnaire C # - Tutoriel avec des exemples de code

  • Principal
  • Autre
  • Liste et dictionnaire C # - Tutoriel avec des exemples de code

c list dictionary tutorial with code examples

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel explique la liste et le dictionnaire C # avec des exemples. Vous apprendrez à initialiser, remplir et accéder aux éléments dans le dictionnaire et la liste C #:

Dans notre didacticiel précédent sur les collections C #, nous avons découvert les types de collections présentes dans le C # comme ArrayList, Hashtable, Stack, SortedList, etc.

Cela semble assez utile pour stocker différents types de données dans une seule entité de collecte, mais l'inconvénient est que lors de la récupération des données de la collection, la diffusion de données vers un type de données applicable est nécessaire. Sans datacast, le programme lèvera une exception d'exécution et peut gêner l'application.

=> Tutoriels de formation C # GRATUITS pour tous

Liste et dictionnaire C #

Pour résoudre ces problèmes, C # propose également des classes de collection génériques. Une collection générique offre de meilleures performances lors du stockage et de la récupération des éléments.

Ce que vous apprendrez:

Liste C #

Nous avons déjà découvert ArrayList dans les articles précédents. Fondamentalement, une liste est similaire à une ArrayList, la seule différence étant que la liste est générique. La liste a une propriété unique d'étendre sa taille à mesure qu'elle grandit, similaire à la liste de tableaux.

Comment initialiser une liste?

Nous pouvons initialiser une liste des manières suivantes:

//using List type for initialization List listInteger = new List(); //using IList type for initialization IList listString = new List();

Si vous regardez l'exemple ci-dessus, vous pouvez voir que dans la première ligne, nous avons utilisé List pour initialiser une liste d'entiers. Mais dans la deuxième ligne, nous avons utilisé IList pour l'initialisation de la liste de chaînes. Vous pouvez utiliser n'importe lequel de ces éléments pour votre programme. La liste est en fait l'implémentation de l'interface IList.

Comment ajouter et insérer un élément dans la liste?

Semblable à ArrayList, nous pouvons ajouter un élément à la liste en utilisant la méthode Add (). La méthode add accepte la valeur du type de données comme argument.

Syntaxe

ListName.Add(DataType value);

Jetons un œil à un programme simple pour ajouter des données à une liste et à IList.

Programme:

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List ;(); //Add elements to the list listInteger.Add(1); listInteger.Add(2); listInteger.Add(3); //using IList type for initialization IList listString = new List(); listString.Add('One'); listString.Add('Two'); listString.Add('Three'); Console.ReadLine(); } }

L'élément peut également être ajouté directement lors de l'initialisation de la liste. Nous pouvons directement ajouter la valeur à la liste au moment de l'initialisation elle-même, de la même manière que nous l'avons fait au cours de notre chapitre Arrays.

Cela peut être ajouté en plaçant des accolades après la liste, puis en écrivant la valeur à l'intérieur séparée par des virgules. Modifions un peu le programme ci-dessus afin que nous puissions ajouter la valeur directement lors de l’initialisation.

comment ouvrir un fichier torrent sur mac

Ainsi, notre programme ressemblera maintenant à:

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //using IList type for initialization IList listString = new List(); listString.Add('One'); listString.Add('Two'); listString.Add('Three'); Console.ReadLine(); } }

Dans le programme ci-dessus, nous avons initialisé les valeurs de la liste d'entiers au début lors de l'initialisation. Cela nous a permis de passer la valeur directement sans écrire la méthode Add () pour chaque valeur. Ceci est très utile si nous avons une quantité limitée de données quantifiables que nous devons mettre dans une liste.

Comment accéder à la liste?

Nous pouvons accéder aux éléments individuels de la liste en utilisant l'index. L'index peut être passé entre crochets après le nom de la liste.

Syntaxe

dataType Val = list_Name(index);

Examinons maintenant un programme simple pour obtenir les données de la liste que nous avons créée dans notre programme précédent.

Programme

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; int val = listInteger(1); Console.WriteLine(val); } }

La sortie du programme suivant sera la valeur à l'index 1. L'index commence à 0, la sortie sera:

deux

Maintenant, disons que nous voulons obtenir toutes les données de la liste, nous pouvons le faire en utilisant la boucle for-each ou pour une boucle.

Pour chaque boucle

Nous pouvons utiliser pour chaque boucle pour obtenir toutes les données de la liste.

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; foreach (var val in listInteger) { Console.WriteLine(val); } } }

Ici, nous avons parcouru la liste en utilisant pour chaque boucle en déclarant une valeur de variable. Cela permettra à chaque boucle à travers la liste jusqu'à ce qu'il y ait des données à l'intérieur.

Pour la boucle

Pour utiliser la boucle for, nous devons connaître le nombre d'éléments présents dans la liste. La méthode Count () peut être utilisée pour obtenir le nombre de l'élément.

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

Parfois, nous pouvons également avoir besoin d'insérer un nouvel élément dans la liste. Pour ce faire, nous devons utiliser la méthode Insert () pour ajouter une nouvelle méthode n'importe où dans la liste. La méthode insert accepte deux arguments, le premier est l'index auquel vous souhaitez insérer les données et le second les données que vous souhaitez insérer.

La syntaxe de l'insertion est:

List_Name.Insert(index, element_to_be_inserted);

Maintenant, insérons un élément dans la liste que nous avons créée précédemment. Nous ajouterons une instruction d'insertion au programme ci-dessus et essaierons de voir comment cela fonctionne:

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

Si nous exécutons le programme ci-dessus, la sortie sera:

1
deux
3
Valeur de liste après insertion d'une nouvelle valeur
1
22
deux
3

Après la boucle for, nous avons ajouté l'instruction insert pour insérer l'entier 22 à l'index 1 dans la liste précédemment définie. Ensuite, nous avons écrit une boucle pour chaque boucle pour imprimer tous les éléments maintenant présents dans la liste (après avoir inséré les premières données).

Nous pouvons clairement voir à partir de la sortie que tous les éléments de la liste ont été décalés vers l'avant pour faire place au nouvel élément à l'index 1. L'index 1 a maintenant 22 comme élément et l'élément précédent à l'index 1 c'est-à-dire 2 est passé à l'index suivant et ainsi de suite.

Comment supprimer un élément de la liste?

Parfois, nous pouvons également exiger de supprimer des éléments de la liste. Pour ce faire, C # propose deux méthodes différentes. Ces deux méthodes sont Remove () et RemoveAt (). Remove est utilisé pour supprimer un certain élément de la liste et RemoveAt est utilisé pour supprimer tout élément présent à l'index donné.

Regardons la syntaxe.

Syntaxe

Remove(Element name); RemoveAt(index);

Maintenant, ajoutons l'instruction Remove au code précédent et voyons ce qui se passe.

class Program { static void Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

La sortie du programme ci-dessus sera:

1
deux
3
Supprimer la valeur de la liste
1
3

Dans le programme ci-dessus, nous avons utilisé la méthode remove pour supprimer l'élément 2 de la liste. Comme vous pouvez le voir dans la sortie une fois que la méthode Remove a été exécutée, la liste ne contient plus l'élément que nous avons supprimé.

De même, nous pouvons également utiliser la méthode RemoveAt. Remplaçons la méthode Remove dans le programme ci-dessus par la méthode RemoveAt () et transmettons le numéro d’index comme paramètre.

class Program { staticvoid Main(string() args) { //using List type for initialization List listInteger = new List () {1,2,3}; //finding the size of the list using count int size = listInteger.Count; for (int i =0; i

La sortie du programme ci-dessus sera:

1
deux
3
Supprimer la valeur de la liste
1
deux

Dans le programme ci-dessus, vous pouvez clairement voir que nous avons supprimé l'élément présent à l'index 2 plutôt que de supprimer l'entier 2. Par conséquent, en fonction de l'exigence, on peut utiliser Remove () ou RemoveAt () pour supprimer un certain élément d'un liste.

Dictionnaire C #

Le dictionnaire en C # est similaire au dictionnaire que nous avons dans n'importe quelle langue. Ici aussi, nous avons une collection de mots et leurs significations. Les mots sont appelés clés et leur signification ou leur définition peut être définie comme des valeurs.

Le dictionnaire accepte deux arguments, le premier est la clé et le second est la valeur. Il peut être initialisé à l'aide d'une variable de la classe Dictionary ou de l'interface IDictionary.

La syntaxe du dictionnaire est:

Dictionary

Jetons un œil à un programme simple pour initialiser Dictionary:

Dictionary data = new Dictionary();

Dans le programme ci-dessus, vous pouvez clairement voir que nous avons initialisé les données du dictionnaire avec la clé et la valeur sous forme de chaîne. Mais vous pouvez utiliser n'importe quelle paire de types de données pour les clés et les valeurs. Par exemple, si nous modifions l'instruction ci-dessus pour qu'elle contienne un type de données différent, elle sera également correcte.

Dictionary data = new Dictionary();

Le type de données à l'intérieur du crochet angulaire concerne les clés et les valeurs. Vous pouvez conserver n'importe quel type de données comme clé et valeur.

Comment ajouter des clés et des valeurs à un dictionnaire?

Nous avons vu comment nous pouvons initialiser un dictionnaire. Nous allons maintenant ajouter des clés et leurs valeurs au dictionnaire. Le dictionnaire est très utile lorsque vous souhaitez ajouter différentes données et leurs valeurs dans une liste. La méthode Add () peut être utilisée pour ajouter des données au dictionnaire.

Syntaxe

DictionaryVariableName.Add(Key, Value);

Maintenant, incluons l'instruction Add dans le programme ci-dessus pour ajouter des clés et des valeurs au dictionnaire.

Programme

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); } }

Dans le programme ci-dessus, nous avons utilisé la méthode Add () pour ajouter la clé et les valeurs au dictionnaire. Le premier paramètre passé à la méthode Add () est la clé et le deuxième paramètre est la valeur de la clé.

Comment accéder aux clés et aux valeurs d'un dictionnaire?

Comme indiqué dans notre tutoriel sur la liste, nous pouvons également accéder aux éléments du dictionnaire de plusieurs manières différentes. Nous discuterons ici de quelques-unes des manières importantes dont nous pouvons y accéder. Nous discuterons de la boucle for, pour chaque boucle et index d'accès aux éléments de données.

L'index peut être utilisé pour accéder à des valeurs spécifiques de la liste.

Questions d'entretien de jira pour Scrum Master

La boucle For peut être utilisée pour accéder ou récupérer tous les éléments du dictionnaire mais nécessite la taille du dictionnaire pour arrêter la boucle. Pour que chaque boucle soit plus flexible, elle permet de récupérer toutes les données présentes du dictionnaire sans nécessiter la taille du dictionnaire.

Utilisation de l'indexation

Un élément de l'index peut être utilisé comme un tableau pour accéder à l'élément, la différence fondamentale étant qu'au lieu d'index, nous avons besoin de clés pour accéder aux valeurs.

Syntaxe

Dictionary_Name(key);

Programme

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); string value = dctn('two'); Console.WriteLine(value); Console.ReadLine(); } }

La sortie du programme ci-dessus sera:

deuxième

angular js entretien questions et réponses

Utilisation de la boucle For pour accéder à l'élément

La boucle for permet d'accéder à tous les éléments du dictionnaire. Mais il doit également obtenir le nombre d'éléments dans le dictionnaire pour un certain nombre d'itérations requises.

Ajoutons une boucle for au programme ci-dessus pour récupérer toutes les valeurs du dictionnaire.

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); for(int i =0; i

La sortie du programme ci-dessus sera:

L'élément à key: one et sa valeur est: first
L'élément à clé: deux et sa valeur est: second
L'élément à la clé: trois et sa valeur est: Troisième

Dans le programme ci-dessus, nous avons utilisé la méthode ElementAt () pour obtenir la clé à un index donné, puis nous avons utilisé la même clé pour récupérer les données de la valeur de clé. La boucle for parcourt toutes les données du dictionnaire. La propriété Count a été utilisée pour obtenir la taille du dictionnaire pour l'itération.

Utilisation de la boucle For-Each

Similaire à la boucle for, nous pouvons également utiliser le pour chaque boucle.

Jetons un œil au programme ci-dessus avec la boucle for-each.

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); foreach (KeyValuePair item in dctn) { Console.WriteLine('The Key is :'+ item.Key+' - The value is: '+ item.Value); } Console.ReadLine(); } }

La sortie du programme ci-dessus sera:

La clé est: one - La valeur est: first
La clé est: deux - La valeur est: seconde
La clé est: trois - La valeur est: Troisième

Le programme ci-dessus utilise KeyValuePair pour déclarer la variable, puis nous parcourons chacune des paires clé-valeur du dictionnaire et l'imprimons sur la console.

Comment valider la présence de données dans un dictionnaire?

Parfois, nous devons vérifier si une certaine clé ou valeur existe dans le dictionnaire ou non. Nous pouvons valider cela en utilisant deux méthodes, à savoir ContainsValue () et ContainsKey () pour vérifier la clé ou la valeur existante dans le dictionnaire.

La méthode Contains est utilisée pour valider si la valeur donnée est présente ou non dans le dictionnaire. La méthode ContainsKey est utilisée pour vérifier si une clé donnée existe ou non dans le dictionnaire.

Syntaxe

Dictionary_Name.ContainsValue(Value); Dictionary_Name.ContainsKey(Key);

Écrivons un programme simple à valider à l'aide de la méthode Contains et ContainsKey.

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); bool key = dctn.ContainsKey('one'); bool val = dctn.ContainsValue('four'); Console.WriteLine('The key one is available : ' + key); Console.WriteLine('The value four is available : ' + val); Console.ReadLine(); } }

La sortie du programme ci-dessus sera:

La clé est disponible: True
La valeur quatre est disponible: False

Dans le programme ci-dessus, nous avons d'abord utilisé la méthode ContainsKey pour valider si la clé donnée est présente dans le dictionnaire. Comme la clé est présente dans le dictionnaire, la méthode renvoie true. Ensuite, nous utilisons ContainsValue pour déterminer si la valeur donnée est présente ou non. Comme la valeur «quatre» n'est pas présente dans le dictionnaire, elle retournera false.

Comment supprimer un élément d'un dictionnaire?

Il peut y avoir un moment où nous devrons supprimer une certaine paire clé-valeur du dictionnaire pour répondre à une certaine logique de programmation. La méthode Remove peut être utilisée pour supprimer n'importe quelle paire du dictionnaire en fonction de la clé.

Syntaxe

Remove(key);

Programme

class Program { static void Main(string() args) { Dictionary dctn = new Dictionary(); dctn.Add('one', 'first'); dctn.Add('two', 'second'); dctn.Add('three', 'Third'); //removing key two dctn.Remove('two'); //validating if the key is present or not bool key = dctn.ContainsKey('two'); Console.WriteLine('The key two is available : ' + key); Console.ReadLine(); } }

La sortie du programme ci-dessus sera:

La clé deux est disponible: Faux

Dans le programme ci-dessus, nous avons d'abord ajouté une paire clé-valeur au dictionnaire. Ensuite, nous avons supprimé une clé du dictionnaire, et nous avons utilisé la méthode ContainsKey () pour valider si la paire clé-valeur n'est plus présente dans le dictionnaire.

Conclusion

La liste stocke les éléments du type de données spécifique et augmente au fur et à mesure que des éléments sont ajoutés. Il peut également stocker plusieurs éléments en double. Nous pouvons facilement accéder aux éléments de la liste en utilisant un index ou des boucles. La liste est très utile pour stocker une grande quantité de données.

Un dictionnaire est utilisé pour stocker des paires clé-valeur. Ici, les clés doivent être uniques. Les valeurs du dictionnaire peuvent être récupérées à l'aide d'une boucle ou d'un index. Nous pouvons également valider des clés ou des valeurs à l'aide de la méthode Contains.

=> Regardez la série complète de formations C # ici

lecture recommandée

^