Déclaration:
Les tableaux sont déclarés à l'aide de « type[] ArrayName ; » syntaxe où le type signifie le type des membres de la collection de tableaux et « ArrName » est le titre attribué au tableau. La déclaration d'un tableau est indiquée par des crochets [].
taper [ ] Nom du tableau = nouveau genre [ ] ; Les listes sont déclarées à l'aide de « List
Liste < taper > liste de noms = Nouvelle liste < taper > ( ) ;
Initialisation :
Les tableaux utilisent des accolades {} pour entourer les valeurs, tandis que les listes utilisent le nouveau constructeur List
taper [ ] Nom du tableau = { v1 , v2 , v3 , ... } ;
Liste < taper > liste de noms = Nouvelle liste < taper > { v1 , v2 , v3 , ... } ;
Ajouter des valeurs :
Il est essentiel de se rappeler que les tableaux C# possèdent une taille spécifique. Si une taille différente est requise, un nouveau tableau « newArr » doit être créé avec la taille souhaitée (longueur actuelle + nombre de nouvelles valeurs). Ajoutez le tableau d'origine « OrgArr » au nouveau tableau, attribuez les nouvelles valeurs aux nouvelles positions dans le nouveau tableau et mettez à jour la référence au nouveau tableau.
Tableau. Copie ( OrgArr , nouveauArr , OrgArr. Longueur ) ;
nouveauArr [ OrgArr. Longueur ] = 14 ; // nouvelle valeur
nouveauArr [ OrgArr. Longueur + 1 ] = 2 ; // nouvelle valeur
OrgArr = nouveauArr ; // Mise à jour de la référence int[] NewArr = new int[OrgArr.Length + 2];
Les listes offrent une flexibilité en termes de gestion des tailles. Lorsqu'une liste est initialisée, elle commence avec une capacité initiale, mais elle peut s'étendre automatiquement à mesure que d'autres éléments sont ajoutés. Cette capacité de redimensionnement dynamique permet aux listes de s'adapter aux exigences changeantes. Les listes C# fournissent une fonction Add() pour ajouter les valeurs à la liste. Voici comment ajouter des valeurs à une liste C# :
Tableaux vs listes : Comparaison d'utilisation en C #
Accéder aux valeurs
Les valeurs dans les numéros de tableau sont accessibles à l'aide de la notation d'index [], c'est-à-dire en utilisant le numéro d'index entre parenthèses et sont enregistrées dans une autre variable.
élément de type = Nom du tableau [ indice ] ;Pour accéder aux valeurs d'une liste C#, vous pouvez également utiliser la notation d'index [] ainsi que la position d'index souhaitée, similaire aux tableaux.
élément de type = Liste de noms [ indice ] ;
Suppression des valeurs
Les tableaux ont une longueur définie. Par conséquent, pour supprimer les éléments, un nouveau tableau doit être créé avec une taille inférieure et les éléments existants doivent être copiés. Cela peut être fait en utilisant la fonction Array.Copy() comme expliqué dans la section « Ajout de valeurs ». Dans les listes C#, la suppression des valeurs est beaucoup plus simple et intuitive. La classe List
Comptez les valeurs
Pour compter les valeurs d'un tableau C#, vous pouvez utiliser l'attribut length du tableau. La propriété length vous donne le nombre total de valeurs dans le tableau.
int compter = nom du tableau. Longueur ;Pour compter les valeurs dans une liste C#, vous pouvez utiliser la fonctionnalité « compte » de la liste. Le nombre total d'éléments qui résident actuellement dans la liste est également renvoyé par l'attribut « count ».
int compter = liste de noms. Compter ;Itérer les valeurs
Pour parcourir les valeurs d'un tableau C#, vous pouvez utiliser une boucle « for » avec la longueur du tableau comme condition de boucle.
pour ( int je = 0 ; je < Nom du tableau. Longueur ; je ++ ) {tapez e = nom_tableau [ je ] ;
Console. Écrire une ligne ( C'est ) ;
}
Pour parcourir les valeurs d'une liste C#, vous pouvez utiliser une boucle « foreach » car elle simplifie le processus d'itération en itérant automatiquement sur les éléments.
pour chaque ( tapez e dans listName ) {Console. Écrire une ligne ( C'est ) ;
}
Exemple 1 : tableaux C#
Le code donné déclare et initialise un tableau d'entiers nommé « Arr » d'une longueur de 5 et attribue les valeurs à ses éléments. Les valeurs attribuées aux éléments du tableau sont 11, 12, 13, 14 et 15. Le code procède ensuite à l'affichage des éléments du tableau à l'aide d'une boucle « for ». Chaque composant est affiché sur une ligne distincte à l'aide de la méthode Console.WriteLine().
Après avoir affiché les éléments d'origine, le code modifie l'élément à l'index 2 en lui attribuant une nouvelle valeur de 10. Ensuite, le code affiche le tableau modifié en parcourant à nouveau les éléments à l'aide d'une boucle « for ». Enfin, le code affiche le nombre total de valeurs qui résident dans le tableau à l'aide de la propriété « Arr.Length » qui donne la longueur du tableau.
en utilisant le système ;mannequin de classe {
statique vide Principal ( ) {
int [ ] Arr = nouveau int [ 5 ] { onze , 12 , 13 , 14 , quinze } ;
Console. Écrire une ligne ( 'Éléments:' ) ;
pour ( int je = 0 ; je < Arr. Longueur ; je ++ )
{
Console. Écrire une ligne ( Arr [ je ] ) ;
}
Arr [ 2 ] = dix ;
Console. Écrire une ligne ( 'Tableau modifié :' ) ;
pour ( int je = 0 ; je < Arr. Longueur ; je ++ )
{
Console. Écrire une ligne ( Arr [ je ] ) ;
}
Console. Écrire une ligne ( 'Nombre d'éléments : ' + Arr. Longueur ) ;
}
}
Exemple 2 : listes C#
Le code fourni suivant illustre l’utilisation d’une liste C# pour stocker et manipuler une collection d’entiers. Tout d'abord, le code initialise une liste nommée « Arr » avec cinq entiers : 11, 12, 13, 14 et 15. Ceci est réalisé en utilisant la classe List
Ensuite, le programme imprime le message « Elements : » et procède à une itération sur chaque élément de la liste à l'aide d'une boucle « foreach ». Lors de chaque itération, l'élément actuel est imprimé sur la console à l'aide de la méthode Console.WriteLine().
Ensuite, le code modifie la valeur à l'index 2 de la liste en lui attribuant la valeur 10 (Arr[2] = 10). Cette ligne modifie le troisième élément de la liste de 13 à 10. Suite à la modification, le programme imprime à nouveau le message « Liste modifiée : » et parcourt la liste mise à jour, imprimant chaque élément sur la console. Le code affiche ensuite le nombre de valeurs dans la liste à l'aide de « Arr.Count ». Cette propriété renvoie le nombre d'éléments présents dans la liste qui, dans le scénario suivant, s'avère être 5.
Enfin, le code supprime l'élément de valeur 4 de la liste à l'aide de la méthode Arr.Remove(4). Cette méthode recherche la valeur spécifiée dans la liste et supprime sa première occurrence. Enfin, le programme imprime le message « Liste après suppression : » et parcourt à nouveau la liste, affichant chaque élément restant après l'opération de suppression.
en utilisant le système ;en utilisant le système. Collections . Générique ;
mannequin de classe {
statique vide Principal ( ) {
Liste < int > Arr = Nouvelle liste < int > ( ) { onze , 12 , 13 , 14 , quinze } ;
Console. Écrire une ligne ( 'Éléments:' ) ;
pour chaque ( int n dans Arr )
{
Console. Écrire une ligne ( n ) ;
}
Arr [ 2 ] = dix ;
Console. Écrire une ligne ( 'Liste modifiée :' ) ;
pour chaque ( int n dans Arr )
{
Console. Écrire une ligne ( n ) ;
}
Console. Écrire une ligne ( 'Nombre d'éléments : ' + Arr. Compter ) ;
Arr. Retirer ( 4 ) ;
Console. Écrire une ligne ( 'Liste après suppression :' ) ;
pour chaque ( int n dans Arr )
{
Console. Écrire une ligne ( n ) ;
}
}
}
Conclusion
Ce guide couvre les différences de syntaxe de base entre les tableaux C# et les listes C#. Les tableaux ont une longueur fixe et sont accessibles par index, tandis que les listes sont dimensionnées dynamiquement et fournissent des méthodes supplémentaires pour ajouter et supprimer des éléments. Parallèlement à cela, nous avons fourni les programmes de liste C# qui présentent la déclaration, l'initialisation, l'accès, la modification, le comptage et l'ajout d'éléments.