Comprendre les tableaux en C#

Comprendre les tableaux

Layla commence par expliquer les tableaux en tant que collections de longueur fixe en C#. Contrairement à certains autres langages de programmation où les tableaux peuvent changer de taille de manière dynamique, les tableaux en C# sont immuables une fois créés. Cela signifie que leur taille ne peut pas être modifiée après l'initialisation en raison des contraintes d'allocation de mémoire.

Console.WriteLine("Hello, what is your favourite cheese from this list?");
Console.WriteLine("1. Stilton");
Console.WriteLine("2. Cheddar");
Console.WriteLine("3. Pineapple");
Console.WriteLine("4. Brie");
var favouriteCheese = Console.ReadLine();
Console.WriteLine($"Here is a lump of {favouriteCheese} cheese!");

Console.WriteLine("Hello, what is your favourite cheese from this list?");
Console.WriteLine("1. Stilton");
Console.WriteLine("2. Cheddar");
Console.WriteLine("3. Pineapple");
Console.WriteLine("4. Brie");
var favouriteCheese = Console.ReadLine();
Console.WriteLine($"Here is a lump of {favouriteCheese} cheese!");

Déclarer un tableau - Initialisation d'un tableau

Pour illustrer son propos, Layla commence par montrer comment déclarer et initialiser un tableau de chaînes de caractères, en l'occurrence une liste de fromages initialement présentée à l'utilisateur sous la forme d'un menu. Elle présente la syntaxe pour définir un tableau unidimensionnel (2:30) et le remplir avec des valeurs initiales à l'aide d'accolades (2:54).

string[] cheeses = { "Brie", "Cheddar", "Stilton", "Gouda" };

string[] cheeses = { "Brie", "Cheddar", "Stilton", "Gouda" };

Elle souligne l'importance de l'indexation à base zéro dans les tableaux, où le premier élément d'un tableau unidimensionnel est accessible à l'aide de l'index 0. Layla montre ensuite comment itérer sur les tableaux à l'aide d'une boucle for. Cette structure de boucle est essentielle en programmation car elle permet l'exécution répétitive du code en fonction d'une condition spécifiée.

Mise en œuvre des boucles

Passant aux boucles, Layla présente la boucle for avec ses trois composants essentiels : l'initialisateur, la condition et l'itérateur. Cette boucle est utilisée pour parcourir les éléments d'un tableau en fonction de sa longueur.

for (int i = 0; i < cheeses.Length; i++)
{
    Console.WriteLine(cheeses[i]);
}

for (int i = 0; i < cheeses.Length; i++)
{
    Console.WriteLine(cheeses[i]);
}

Elle, à 4:44, souligne que cheeses.Length donne le nombre d'éléments dans le tableau, assurant que la boucle itère précisément à travers chaque élément. La variable i fonctionne comme une variable d'index pour itérer à travers les index. Cela imprime efficacement les éléments individuels du tableau sans écrire la méthode Console.WriteLine plusieurs fois comme montré ci-dessus sans accéder aux éléments du tableau. Layla, à 6:17, exécute l'application pour montrer que la sortie de cette boucle for est exactement la même que celle de l'exemple précédent :

Tri et mutabilité

Layla explique l'avantage du tri, puis à 7:17, elle démontre le tri d'un tableau par ordre alphabétique en utilisant la méthode Sort, avertissant que le tri crée en fait un nouveau tableau en coulisses en raison de l'immuabilité des tableaux en C#. Il s'agit d'un point crucial pour comprendre comment la manipulation des données affecte la mémoire et les performances.

Array.Sort(cheeses);

Array.Sort(cheeses);

Elle montre également comment des éléments individuels du tableau peuvent être modifiés directement sans créer un nouveau tableau (8:10), illustrant ainsi la mutabilité au sein de l'immutabilité. L'index de l'élément à remplacer est passé entre crochets après la variable de tableau cheeses :

cheeses[0] = "Roquefort";

cheeses[0] = "Roquefort";

Cela remplacera l'élément de tableau "Brie" à l'index 0 par la nouvelle valeur "Roquefort".

Mise à jour de la liste des fromages : Gestion des nouvelles entrées (8:46)

Layla explique comment ajouter des valeurs à une liste existante. Cela implique de prendre les valeurs existantes et la nouvelle valeur, de créer un nouveau tableau qui inclut les deux, et de mettre à jour notre référence pour qu'elle pointe vers ce nouveau tableau. Le code suivant montre comment cela fonctionne :

var favouriteCheese = Console.ReadLine();

bool containsFavourite = false;

foreach (var cheese in cheeses)
{
    if (favouriteCheese == cheese)
    {
        containsFavourite = true;
    }
}

if (!containsFavourite)
{
    cheeses = cheeses.Append(favouriteCheese).ToArray();
}

var favouriteCheese = Console.ReadLine();

bool containsFavourite = false;

foreach (var cheese in cheeses)
{
    if (favouriteCheese == cheese)
    {
        containsFavourite = true;
    }
}

if (!containsFavourite)
{
    cheeses = cheeses.Append(favouriteCheese).ToArray();
}

Cet exemple montre le processus de manière simple en utilisant des opérations de tableau de base et une boucle foreach pour vérifier si le fromage est déjà dans la liste. Si ce n'est pas le cas, Layla l'ajoute (13:33) au tableau en utilisant la méthode Append de System.Linq.

Layla, à 13:50, dit que le code contient des erreurs parce que cheeses et le résultat de Append sont de types différents. Append renvoie un IEnumerable, une interface pour les collections. Pour résoudre cela, nous convertissons IEnumerable en un tableau en utilisant la méthode ToArray(), puis nous le réassignons à cheeses. Layla note que la ligne ondulée jaune est un avertissement du compilateur indiquant des problèmes potentiels, comme favouriteCheese étant null, mais nous ignorons les contrôles de sécurité dans cette démonstration.

Console.WriteLine("The new list:");

for (var i = 0; i < cheeses.Length; i++)
{
    Console.WriteLine(i + " " + cheeses[i]);
}

Console.WriteLine($"Here is a lump of {favouriteCheese} cheese!");

Console.WriteLine("The new list:");

for (var i = 0; i < cheeses.Length; i++)
{
    Console.WriteLine(i + " " + cheeses[i]);
}

Console.WriteLine($"Here is a lump of {favouriteCheese} cheese!");

Améliorer avec les tableaux d'objets

Pour élargir la compréhension, Layla introduit des tableaux d'objets en créant une classe Cheese avec des propriétés pour Name et Strength (16:14). Elle remplace ensuite la liste de chaînes pour créer un tableau d'objets Cheese et démontre comment accéder aux propriétés au sein des objets lors de l'itération (17:46).

class Cheese
{
    public string Name { get; set; }
    public int Strength { get; set; }

    public Cheese(string name, int strength)
    {
        Name = name;
        Strength = strength;
    }
}

Cheese[] cheeses = new Cheese[]
{
    new Cheese("Stilton", 3),
    new Cheese("Cheddar", 2),
    new Cheese("Pineapple", 1),
    new Cheese("Brie", 2)
};

cheeses[0] = new Cheese("Roquefort", 4);

class Cheese
{
    public string Name { get; set; }
    public int Strength { get; set; }

    public Cheese(string name, int strength)
    {
        Name = name;
        Strength = strength;
    }
}

Cheese[] cheeses = new Cheese[]
{
    new Cheese("Stilton", 3),
    new Cheese("Cheddar", 2),
    new Cheese("Pineapple", 1),
    new Cheese("Brie", 2)
};

cheeses[0] = new Cheese("Roquefort", 4);

Ce segment fournit une compréhension fondamentale de la façon dont les tableaux peuvent encapsuler des structures de données complexes, offrant flexibilité et puissance dans la programmation.

Utilisation de l'objet fromage dans les boucles

Layla montre maintenant comment imprimer à l'écran tous les éléments de la liste mise à jour. Dans ce scénario, chaque fromage est représenté comme un objet avec des propriétés Name et Strength. La boucle for itère à travers ce tableau d'objets Cheese où chaque itération traite un seul élément de tableau directement.

for (int i = 0; i < cheeses.Length; i++)
{
    Console.WriteLine($"{cheeses[i].Name}, Strength: {cheeses[i].Strength}");
}

for (int i = 0; i < cheeses.Length; i++)
{
    Console.WriteLine($"{cheeses[i].Name}, Strength: {cheeses[i].Strength}");
}

Cette boucle simplifie l'accès aux propriétés des objets Cheese stockés dans le tableau cheeses. Layla, à 20:34, exécute le programme et le résultat est le suivant :

Conclusion

En conclusion, le tutoriel de Layla Porter sur les tableaux et les boucles en C# fournit une base solide aux débutants pour comprendre ces concepts essentiels. En maîtrisant les tableaux et les diverses constructions de boucles, les développeurs C# en herbe peuvent manipuler efficacement les structures de données et itérer à travers les collections dans leurs programmes. Il est essentiel de comprendre ces principes fondamentaux pour créer des applications plus complexes et explorer d'autres aspects de la programmation C#.

En suivant les exemples et les explications de Layla, les débutants peuvent gagner en confiance pour utiliser efficacement les tableaux et les boucles dans leurs propres projets C#. Pour une couverture plus approfondie des collections C# et des tableaux avancés en deux dimensions et en dents de scie, les apprenants sont encouragés à explorer les tutoriels et les exercices pratiques ultérieurs.