Création et Manipulation de Listes et Tableaux

Bonjour ! J'espère que vous êtes prêt(e) à continuer notre exploration de C#.

Dans la leçon précédente, nous avons appris à utiliser les boucles (for, while, foreach) pour répéter des blocs de code. Nous avons notamment vu que la boucle foreach est particulièrement efficace pour parcourir les éléments d'une "collection". Aujourd'hui, nous allons nous intéresser de plus près à ces collections.

L'objectif de cette leçon est de vous apprendre à créer et manipuler les deux types de collections les plus fondamentaux en C# : les tableaux et les listes (List<T>). Savoir stocker et gérer des groupes de données est une compétence essentielle, que ce soit pour une liste de produits dans une application e-commerce, les scores d'un jeu, ou les tâches d'une "to-do list".

C'est la dernière étape des fondamentaux avant de nous lancer dans la programmation orientée objet !

1. Les Tableaux (Array) : Le conteneur à taille fixe

Commençons par la structure la plus simple : le tableau. Un tableau est une collection d'éléments du même type dont la taille est fixe dès sa création.

Imaginez une boîte d'œufs : elle a un nombre de places défini (6, 10, 12) et vous ne pouvez pas en ajouter une treizième sans changer de boîte. Un tableau fonctionne sur le même principe.

Création et accès aux éléments

En C#, pour accéder à un élément d'un tableau, on utilise son index : un numéro qui représente sa position. Attention, comme dans beaucoup de langages, l'indexation commence à 0. Le premier élément est à l'index 0, le deuxième à l'index 1, et ainsi de suite.

Pour comprendre la nature fixe des tableaux, regardons un court extrait vidéo.

Voici comment cela se traduit en code :

// Création d'un tableau de chaînes de caractères avec 4 éléments.
// La taille de ce tableau est maintenant fixée à 4.
string[] joursSemaine = new string[] { "Lundi", "Mardi", "Mercredi", "Jeudi" };

// Accéder au premier élément (index 0)
Console.WriteLine($"Le premier jour est : {joursSemaine[0]}"); // Affiche "Lundi"

// Modifier le troisième élément (index 2)
joursSemaine[2] = "MERCREDI";

// Parcourir le tableau avec une boucle foreach (vue dans la leçon précédente)
foreach (string jour in joursSemaine)
{
    Console.WriteLine(jour);
}

// Essayer d'ajouter un élément provoquera une erreur de compilation !
// joursSemaine.Add("Vendredi"); // Cette ligne ne fonctionnera pas.

La propriété Length d'un tableau nous donne sa taille. Elle est très utile avec une boucle for :

for (int i = 0; i < joursSemaine.Length; i++)
{
    Console.WriteLine($"Élément à l'index {i} : {joursSemaine[i]}");
}

2. Les Listes (List<T>) : Le conteneur dynamique

Les tableaux sont utiles, mais leur taille fixe est souvent une contrainte. La plupart du temps, nous avons besoin d'une collection qui peut grandir ou rétrécir, comme un panier d'achat. C'est là qu'intervient la List<T>.

Une List<T> est une collection dynamique. Vous pouvez y ajouter, insérer ou supprimer des éléments à tout moment. Le T dans List<T> est un "paramètre de type" : il sera remplacé par le type de données que vous voulez stocker (List<string>, List<int>, etc.).

Commençons par voir comment créer une liste et y ajouter des éléments.

Manipuler une liste

Contrairement aux tableaux, les listes possèdent de nombreuses méthodes utiles pour les manipuler.

Voici un résumé des opérations de base :

// Création d'une liste vide de nombres entiers
List<int> notes = new List<int>();

// 1. Ajouter des éléments à la fin de la liste
notes.Add(15);
notes.Add(12);
notes.Add(18); // La liste contient maintenant : { 15, 12, 18 }

// 2. Accéder à un élément par son index (comme avec un tableau)
Console.WriteLine($"La deuxième note est : {notes[1]}"); // Affiche 12

// 3. Connaître le nombre d'éléments avec la propriété 'Count'
Console.WriteLine($"Il y a {notes.Count} notes."); // Affiche 3

// 4. Supprimer un élément par sa valeur
notes.Remove(12); // La liste contient maintenant : { 15, 18 }

// 5. Supprimer un élément par son index
notes.RemoveAt(0); // La liste contient maintenant : { 18 }

// 6. Insérer un élément à un index spécifique
notes.Insert(0, 20); // La liste contient maintenant : { 20, 18 }

Console.WriteLine("Notes finales :");
foreach (int note in notes)
{
    Console.WriteLine(note);
}

3. Tableau ou Liste : Lequel choisir ?

C'est une question que tout développeur se pose. Heureusement, la réponse est assez simple, surtout quand on débute.

En résumé :

• Utilisez un Array (tableau) lorsque le nombre d'éléments est connu à l'avance et ne changera jamais. Exemples : les mois de l'année, les jours de la semaine, les points cardinaux.
• Utilisez une List<T> (liste) dans presque tous les autres cas. Si vous avez un doute, choisissez une List<T>. C'est la structure de données la plus flexible et la plus couramment utilisée pour gérer des collections dont la taille peut varier.

4. Exercice Pratique : Votre liste de tâches

Mettons tout cela en pratique ! Vous allez créer une simple application console pour gérer une liste de tâches.

Instructions :

1. Ouvrez Visual Studio et créez un nouveau projet "Application console".
2. Dans votre méthode Main, déclarez une List<string> nommée taches.
3. Utilisez la méthode Add() pour ajouter 3 à 4 tâches initiales (ex: "Apprendre C#", "Faire les courses", "Appeler le client").
4. Affichez un titre, comme "--- Ma liste de tâches ---".
5. Utilisez une boucle foreach pour afficher chaque tâche de la liste. Pour un affichage plus propre, vous pouvez utiliser un compteur ou l'index dans une boucle for.
6. Simulez une tâche terminée en la supprimant de la liste avec Remove() (en utilisant le texte de la tâche) ou RemoveAt() (en utilisant son index).
7. Affichez de nouveau la liste pour voir le changement.
8. Pour finir, affichez le nombre de tâches restantes en utilisant la propriété .Count.

Exemple de sortie attendue :

--- Ma liste de tâches ---
1. Apprendre C#
2. Faire les courses
3. Appeler le client

--- Tâche 'Faire les courses' terminée ! ---

--- Ma liste de tâches mise à jour ---
1. Apprendre C#
2. Appeler le client

Il reste 2 tâche(s) à faire.

Prenez le temps de faire cet exercice. C'est en écrivant le code vous-même que ces concepts deviendront une seconde nature.

Conclusion

Félicitations ! Vous avez terminé le premier module sur les fondamentaux de C#. Vous maîtrisez maintenant les variables, les opérateurs, les conditions, les boucles et les collections de base. C'est un socle solide pour tout ce qui va suivre.

Ce qu'il faut retenir :

• Les tableaux (type[]) sont des collections d'éléments de même type à taille fixe.
• Les listes (List<T>) sont des collections dynamiques qui peuvent grandir et rétrécir.
• L'accès aux éléments se fait par un index basé à zéro (collection[0]) pour les deux.
• Par défaut, préférez List<T> pour sa flexibilité.
• Les propriétés clés sont Length pour les tableaux et Count pour les listes.

Dans la prochaine leçon, nous entrerons dans le Module 2 et aborderons un pilier de la programmation moderne : la Programmation Orientée Objet. Nous commencerons par apprendre à définir et appeler des méthodes. Cela nous permettra de découper notre code en blocs logiques et réutilisables, une première étape essentielle pour construire des applications complexes et bien organisées.