C# Arrays verstehen

Verstehen von Arrays

Layla beginnt mit der Erläuterung von Arrays als Sammlungen mit fester Länge in C#. Im Gegensatz zu einigen anderen Programmiersprachen, in denen Arrays ihre Größe dynamisch ändern können, sind Arrays in C# unveränderlich, sobald sie erstellt wurden. Das bedeutet, dass ihre Größe nach der Initialisierung aufgrund von Speicherzuweisungsbeschränkungen nicht mehr geändert werden kann.

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

Ein Array deklarieren - Array-Initialisierung

Zur Veranschaulichung demonstriert Layla zunächst, wie ein Array von Strings deklariert und initialisiert wird, in diesem Fall eine Liste von Käsesorten, die dem Benutzer zunächst als Menü präsentiert wird. Sie stellt die Syntax für die Definition eines eindimensionalen Arrays (2:30) und dessen Befüllung mit Anfangswerten mithilfe geschweifter Klammern (2:54) vor.

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

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

Sie betont die Bedeutung der nullbasierten Indizierung in Arrays, bei der auf das erste Element in einem eindimensionalen Array mit Index 0 zugegriffen wird. Anschließend zeigt Layla, wie man mit einer for-Schleife über Arrays iteriert. Diese Schleifenstruktur ist in der Programmierung von zentraler Bedeutung, da sie die wiederholte Ausführung von Code auf der Grundlage einer bestimmten Bedingung ermöglicht.

Implementierung von Schleifen

In Bezug auf Schleifen stellt Layla die for-Schleife mit ihren drei wesentlichen Komponenten vor: Initialisierer, Bedingung und Iterator. Diese Schleife wird verwendet, um durch die Elemente eines Arrays basierend auf dessen Länge zu iterieren.

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

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

Sie betont um 4:44, dass cheeses.Length die Anzahl der Elemente im Array angibt und sicherstellt, dass die Schleife präzise durch jedes Element iteriert. Die Variable i fungiert als Indexvariable, um durch Indizes zu iterieren. Dies druckt effektiv einzelne Array-Elemente aus, ohne die Console.WriteLine-Methode mehrfach zu schreiben, wie oben gezeigt, ohne auf Array-Elemente zuzugreifen. Layla führt bei 6:17 die Anwendung aus, um zu zeigen, dass die Ausgabe dieser for-Schleife genau dieselbe ist wie im vorherigen Beispiel:

Sortierung und Veränderlichkeit

Layla erklärt den Nutzen des Sortierens und zeigt dann um 7:17 das Sortieren eines Arrays alphabetisch mit der Sort-Methode, wobei sie darauf hinweist, dass das Sortieren tatsächlich ein neues Array im Hintergrund erstellt, aufgrund der Unveränderlichkeit von Arrays in C#. Dies ist ein entscheidender Punkt, um zu verstehen, wie sich die Datenmanipulation auf Speicher und Leistung auswirkt.

Array.Sort(cheeses);

Array.Sort(cheeses);

Sie zeigt auch, wie einzelne Elemente innerhalb des Arrays direkt geändert werden können, ohne ein neues Array zu erstellen (8:10), was die Veränderbarkeit innerhalb der Unveränderbarkeit veranschaulicht. Der Index des zu ersetzenden Elements wird in eckigen Klammern nach der cheeses-Arrayvariablen übergeben:

cheeses[0] = "Roquefort";

cheeses[0] = "Roquefort";

Dadurch wird das Array-Element "Brie" bei Index 0 durch den neuen Wert "Roquefort" ersetzt.

Aktualisierung der Käseliste: Umgang mit neuen Einträgen (8:46)

Layla erklärt, wie wir Werte an eine bestehende Liste anhängen können. Dazu werden die vorhandenen Werte und der neue Wert genommen, ein neues Array erstellt, das beide enthält, und der Verweis auf dieses neue Array aktualisiert. Der folgende Code zeigt, wie es funktioniert:

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

Dieses Beispiel zeigt den Prozess auf einfache Weise mit grundlegenden Array-Operationen und einer foreach-Schleife, um zu überprüfen, ob der Käse bereits in der Liste ist. Falls nicht, fügt Layla ihn um 13:33 mit der Append-Methode von System.Linq dem Array hinzu.

Layla sagt um 13:50, dass der Code Fehler verursacht, weil cheeses und das Ergebnis von Append unterschiedliche Typen sind. Append gibt ein IEnumerable zurück, eine Schnittstelle für Sammlungen. Um dies zu beheben, konvertieren wir das IEnumerable in ein Array mit der ToArray()-Methode und weisen es dann zurück zu cheeses. Layla merkt an, dass die gelbe Wellenlinie eine Compilerwarnung ist, die auf potenzielle Probleme hinweist, wie das favouriteCheese null sein könnte, aber wir ignorieren Sicherheitstests in dieser Demo.

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

Erweiterung mit Objekt-Arrays

Um das Verständnis zu erweitern, führt Layla Arrays von Objekten ein, indem sie eine Cheese-Klasse mit Eigenschaften für Name und Strength erstellt (16:14). Dann ersetzt sie die Zeichenfolgenliste, um ein Array von Cheese-Objekten zu erstellen und demonstriert, wie man Eigenschaften innerhalb von Objekten während der Iteration zugreift (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);

Dieses Segment vermittelt ein grundlegendes Verständnis dafür, wie Arrays komplexe Datenstrukturen kapseln können und so Flexibilität und Leistung bei der Programmierung bieten.

Nutzung von Cheese Object in Schleifen

Layla zeigt nun, wie man alle Elemente der aktualisierten Liste auf dem Bildschirm ausgibt. In diesem Szenario wird jeder Käse als Objekt mit Eigenschaften Name und Strength dargestellt. Die for-Schleife iteriert durch dieses Array von Cheese-Objekten, wobei jede Iteration ein einzelnes Array-Element direkt behandelt.

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

Diese Schleife vereinfacht den Zugriff auf die Eigenschaften von Cheese-Objekten, die im cheeses-Array gespeichert sind. Layla führt um 20:34 Uhr das Programm aus, und die Ausgabe sieht wie folgt aus:

Abschluss

Zusammenfassend lässt sich sagen, dass Layla Porters Tutorial zu Arrays und Schleifen in C# eine solide Grundlage für Anfänger bietet, um diese wesentlichen Konzepte zu verstehen. Durch die Beherrschung von Arrays und verschiedenen Schleifenkonstrukten können angehende C#-Entwickler Datenstrukturen effektiv manipulieren und durch Sammlungen in ihren Programmen iterieren. Das Verständnis dieser Grundlagen ist entscheidend für die Erstellung komplexerer Anwendungen und die Erkundung weiterer Aspekte der C#-Programmierung.

Anhand von Laylas Beispielen und Erklärungen können Anfänger Sicherheit bei der effektiven Verwendung von Arrays und Schleifen in ihren eigenen C#-Projekten gewinnen. Für eine tiefergehende Behandlung von C#-Sammlungen und fortgeschrittenen zweidimensionalen und gezackten Arrays werden die Lernenden ermutigt, die nachfolgenden Tutorials und praktischen Übungen zu erkunden.