Apprendre le C#

Comprendre les tableaux en C#

Layla Porter

21 min 53 s

Les tableaux en C# sont une structure de données fondamentale qui permet aux développeurs de stocker une collection d'éléments du même type dans des emplacements mémoire contigus. Les tableaux peuvent être unidimensionnels, multidimensionnels ou irréguliers.

Cet article sur les tableaux C# s'inspire de la vidéo éducative de Layla Porter, "C# pour débutants Partie 5 - Tableaux et autres boucles." Dans sa vidéo, Layla plonge dans les principes fondamentaux des tableaux et présente d'autres techniques de bouclage en C#, dotant les spectateurs de compétences essentielles pour gérer les collections et itérer dans les données de manière efficace.

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.

Interaction simple avec la console : Choisir son fromage préféré

Dans le code suivant, contrairement aux tableaux, Layla (1:50) montre d'abord comment un utilisateur peut se voir présenter une liste d'éléments parmi lesquels il peut choisir.

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!");

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")
Dim 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")
Dim favouriteCheese = Console.ReadLine()
Console.WriteLine($"Here is a lump of {favouriteCheese} cheese!")

Ce code utilise d'abord Console.WriteLine pour afficher un message sur la console qui demande à l'utilisateur quel est son fromage préféré. Il utilise ensuite Console.WriteLine quatre fois de plus pour afficher une liste de fromages sur la console. Le code utilise ensuite Console.ReadLine pour lire l'entrée de l'utilisateur depuis la console et la stocke dans la variable favouriteCheese. Enfin, le code utilise à nouveau Console.WriteLine pour afficher un message sur la console qui inclut le fromage préféré de l'utilisateur.

Layla, à 2:04, exécute ce code pour montrer comment il fonctionne :

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" };

Dim cheeses As String() = {"Brie", "Cheddar", "Stilton", "Gouda"}

Dim cheeses As String() = {"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]);
}

For i As Integer = 0 To cheeses.Length - 1
    Console.WriteLine(cheeses(i))
Next

For i As Integer = 0 To cheeses.Length - 1
    Console.WriteLine(cheeses(i))
Next

Elle souligne, à 4:44, que cheeses.Length donne le nombre d'éléments dans le tableau, garantissant que la boucle parcourt précisément chaque élément. La variable i fonctionne comme une variable d'index pour parcourir les index. Cela permet efficacement d'afficher des é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, et ensuite à 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 réalité un nouveau tableau en arrière-plan 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);

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";

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();
}

Dim favouriteCheese = Console.ReadLine()

Dim containsFavourite As Boolean = False

For Each cheese In cheeses
    If favouriteCheese = cheese Then
        containsFavourite = True
    End If
Next

If Not containsFavourite Then
    cheeses = cheeses.Append(favouriteCheese).ToArray()
End If

Dim favouriteCheese = Console.ReadLine()

Dim containsFavourite As Boolean = False

For Each cheese In cheeses
    If favouriteCheese = cheese Then
        containsFavourite = True
    End If
Next

If Not containsFavourite Then
    cheeses = cheeses.Append(favouriteCheese).ToArray()
End If

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 génère 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 corriger cela, nous convertissons le IEnumerable en un tableau en utilisant la méthode ToArray() et puis le réassignons à cheeses. Layla note que la ligne en zigzag jaune est un avertissement du compilateur indiquant des problèmes potentiels, comme favouriteCheese étant nul, mais nous ignorons les vérifications de sécurité dans cette démonstration.

Mise à jour et impression de la liste des fromages

Layla explique que lorsque nous avons ajouté un nouvel élément à notre tableau, nous devons imprimer la liste mise à jour à l'écran. Pour réaliser cela, nous utilisons une boucle for, affichant chaque élément avec son index pour montrer que le tableau contient maintenant plus d'éléments.

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!");

Console.WriteLine("The new list:")

For i As Integer = 0 To cheeses.Length - 1
    Console.WriteLine(i & " " & cheeses(i))
Next

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

Console.WriteLine("The new list:")

For i As Integer = 0 To cheeses.Length - 1
    Console.WriteLine(i & " " & cheeses(i))
Next

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

Cela démontre la nature dynamique des tableaux en C#, en montrant comment ajouter de nouveaux éléments et vérifier la mise à jour en imprimant le contenu du tableau.

Layla exécute ensuite l'application pour afficher le fromage nouvellement ajouté (15:19) :

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 dans les 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);

Class Cheese
    Public Property Name As String
    Public Property Strength As Integer

    Public Sub New(name As String, strength As Integer)
        Me.Name = name
        Me.Strength = strength
    End Sub
End Class

Dim cheeses As Cheese() = 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 Property Name As String
    Public Property Strength As Integer

    Public Sub New(name As String, strength As Integer)
        Me.Name = name
        Me.Strength = strength
    End Sub
End Class

Dim cheeses As Cheese() = 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 les propriétés Name et Strength. La boucle for parcourt ce tableau d'objets Cheese où chaque itération gère directement un élément unique du tableau.

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}");
}

For i As Integer = 0 To cheeses.Length - 1
    Console.WriteLine($"{cheeses(i).Name}, Strength: {cheeses(i).Strength}")
Next

For i As Integer = 0 To cheeses.Length - 1
    Console.WriteLine($"{cheeses(i).Name}, Strength: {cheeses(i).Strength}")
Next

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.