C# Fall wechseln

Layla Porter

20m 21s

Die switch-Anweisung in C# ist ein leistungsfähiger Kontrollflussmechanismus, der es Entwicklern ermöglicht, einen von vielen Codeblöcken basierend auf dem Wert eines Ausdrucks auszuführen. Sie ist besonders nützlich für Situationen, in denen mehrere Bedingungen gegen eine einzige Variable geprüft werden müssen. Operatoren können innerhalb von Switch Cases verwendet werden, um verschiedene Aktionen an Match-Ausdrücken durchzuführen, wie z. B. Vergleiche und logische Prüfungen.

Layla Porter geht in ihrem Video "C# für Anfänger Teil 4 - Operatoren und Schalter" auf die grundlegenden Konzepte der C#-Programmierung ein und konzentriert sich dabei auf Operatoren und Switch-Case-Anweisungen. In diesem Artikel, der von ihrem Video inspiriert wurde, werden ihre Erklärungen aufgeschlüsselt und Codeschnipsel aus ihrem Video bereitgestellt, um Switch Cases und Operatoren zu verstehen.

Einführung in die Operatoren

Operatoren in C# sind entscheidend für die Manipulation von Daten, den Vergleich von Werten und das Treffen von Entscheidungen auf der Grundlage von Fallwerten und Vergleichen. Layla beginnt mit der Erläuterung der verschiedenen Arten von Operatoren: arithmetische, vergleichende und logische Operatoren.

Benutzereingaben mit Console.ReadLine

Layla beginnt damit, zu demonstrieren, wie Benutzereingaben mit Console.ReadLine() erfasst werden. Diese Methode liest eine Eingabezeile von der Konsole, was für interaktive C#-Anwendungen unerlässlich ist.

Console.WriteLine("Hello, please write any word:");
string word = Console.ReadLine();

Console.WriteLine("Hello, please write any word:");
string word = Console.ReadLine();

Console.WriteLine("Hello, please write any word:")
Dim word As String = Console.ReadLine()

Console.WriteLine("Hello, please write any word:")
Dim word As String = Console.ReadLine()

Zuweisungsoperator

Im obigen Code-Ausschnitt verwendet Layla den Zuweisungsoperator (=), um den aus der Benutzereingabe erhaltenen Wert in der Variablen word zu speichern. Hier ist eine Aufschlüsselung:

• string word: Deklariert eine Variable namens word vom Typ string.

• word = Console.ReadLine(): Verwendet den Zuweisungsoperator (=), um den vom Benutzer eingegebenen Wert (erhalten von Console.ReadLine()) der Variable word zuzuweisen.

In diesem Kontext wird der Zuweisungsoperator verwendet, um den Wert der Variablen word auf das zu setzen, was der Benutzer in die Konsole eingibt. Der Zuweisungsoperator ist in der Programmierung von grundlegender Bedeutung, da er verwendet wird, um Werte in Variablen zu speichern, so dass diese Werte während der Ausführung des Programms verwendet und manipuliert werden können.

Arithmetische Operatoren

Arithmetische Operatoren in C# führen grundlegende mathematische Operationen wie Addition, Subtraktion, Multiplikation, Division und Modulus aus. Diese Operatoren sind einfach und für jede Programmiersprache unerlässlich. Layla geht in ihrem Video nicht auf diese Funktionen ein, da es sich um einfache mathematische Operationen handelt, die genau dieselben Werte wie bei echten mathematischen Problemen liefern.

Vergleichsoperatoren

Vergleichsoperatoren in C# ermöglichen es uns, Werte zu vergleichen und auf der Grundlage dieser Vergleiche Entscheidungen zu treffen. Layla führt die Operatoren größer als (>), kleiner als (<), größer als oder gleich (>=), kleiner als oder gleich (<=), Gleichheit (==) und Ungleichheit (!=) ein.

Verwendung von Vergleichsoperatoren in bedingten logischen Anweisungen

In ihrem Video geht Layla Porter auf die Verwendung bedingter Logik in C# ein, um die Länge eines vom Benutzer eingegebenen Wortes zu bestimmen. Sie beginnt um 2:10 damit, die Grundstruktur einer if-Anweisung zu demonstrieren, um die Länge eines Strings mithilfe der Length-Eigenschaft des String-Typs zu überprüfen. Diese Eigenschaft gibt die Anzahl der Zeichen in der Zeichenkette zurück.

if (word.Length < 6)
{
    Console.WriteLine("That's a short word.");
}

if (word.Length < 6)
{
    Console.WriteLine("That's a short word.");
}

If word.Length < 6 Then
    Console.WriteLine("That's a short word.")
End If

If word.Length < 6 Then
    Console.WriteLine("That's a short word.")
End If

Die erste bedingte Überprüfung verwendet den kleiner als (<)-Operator, um zu sehen, ob die Länge des Wortes weniger als sechs Zeichen ist. Wenn die Bedingung erfüllt ist, gibt das Programm aus: "Das ist ein kurzes Wort" Dieser Teil des Codes hilft, kürzere Wörter effektiv zu kategorisieren.

Als nächstes führt Layla Porter um 4:00 das Konzept der Verwendung einer else if-Anweisung mit kombinierten Bedingungen ein, die den größer als oder gleich (>=)-Operator und den logischen UND (&&)-Operator nutzen. Die kombinierte Bedingung prüft, ob die Wortlänge mindestens sechs, aber weniger als elf Zeichen beträgt. Wenn beide Bedingungen erfüllt sind, gibt das Programm aus: "Das ist ein Wort mittlerer Länge." Dies zeigt, wie mehrere Bedingungen kombiniert werden können, um feinere Entscheidungen auf der Grundlage der Wortlänge zu treffen.

else if (word.Length >= 6 && word.Length < 11)
{
    Console.WriteLine("That's a medium length word.");
}

else if (word.Length >= 6 && word.Length < 11)
{
    Console.WriteLine("That's a medium length word.");
}

ElseIf word.Length >= 6 AndAlso word.Length < 11 Then
    Console.WriteLine("That's a medium length word.")
End If

ElseIf word.Length >= 6 AndAlso word.Length < 11 Then
    Console.WriteLine("That's a medium length word.")
End If

Schließlich erklärt Layla bei 4:40 die Verwendung der else-Anweisung, um alle anderen Fälle zu behandeln, die die vorherigen Bedingungen nicht erfüllen. Dieser Teil des Codes gibt "Das ist ein langes Wort" für Wörter aus, die elf Zeichen oder länger sind. Durch die Verwendung der else-Anweisung wird sichergestellt, dass alle Eingaben, die nicht von den vorangegangenen Bedingungen erfasst werden, entsprechend behandelt werden.

else
{
    Console.WriteLine("That's a long word.");
}

else
{
    Console.WriteLine("That's a long word.");
}

Else
    Console.WriteLine("That's a long word.")
End If

Else
    Console.WriteLine("That's a long word.")
End If

Nun führt Layla das Programm aus (5:15) und gibt einige Wörter ein, die mit den oben genannten bedingten Anweisungen und Vergleichsoperatoren kategorisiert werden sollen:

Logische Operatoren

Logische Operatoren &&, ||, ! ermöglichen die Kombination mehrerer Bedingungen in C#, um komplexere Entscheidungslogik zu erstellen. Layla erklärt bei 6:24, wie diese Operatoren zusammenarbeiten, um bedingte Anweisungen zu erstellen.

In ihrem Video stellt Layla Porter ein Minispiel vor, bei dem der Benutzer aufgefordert wird, das ungerade Wort aus einer Liste von Tieren zu identifizieren: "Hund", "Katze" und "Goldfisch" Der Goldfisch gilt als das ungerade Wort, weil er im Wasser lebt und kein Säugetier ist. Layla (6:55) beginnt damit, den Benutzer zu bitten, seine Wahl unter Verwendung von Console.ReadLine() einzugeben und stellt dann sicher, dass die Eingabe durch die Methode ToLower() in Kleinbuchstaben umgewandelt wird, um Probleme mit der Groß- und Kleinschreibung beim Vergleich von Strings zu vermeiden:

Console.WriteLine("Pick the odd one out - dog, cat, goldfish");
string oddOne = Console.ReadLine().ToLower();

Console.WriteLine("Pick the odd one out - dog, cat, goldfish");
string oddOne = Console.ReadLine().ToLower();

Console.WriteLine("Pick the odd one out - dog, cat, goldfish")
Dim oddOne As String = Console.ReadLine().ToLower()

Console.WriteLine("Pick the odd one out - dog, cat, goldfish")
Dim oddOne As String = Console.ReadLine().ToLower()

Layla erklärt bei 7:32 die Verwendung der Vergleichsoperatoren, um die Eingaben des Benutzers mit dem System und einer vordefinierten Liste von Tieren zu vergleichen.

if (oddOne != "dog" && oddOne != "cat")
{
    Console.WriteLine("You chose the odd one out!");
}

if (oddOne != "dog" && oddOne != "cat")
{
    Console.WriteLine("You chose the odd one out!");
}

If oddOne <> "dog" AndAlso oddOne <> "cat" Then
    Console.WriteLine("You chose the odd one out!")
End If

If oddOne <> "dog" AndAlso oddOne <> "cat" Then
    Console.WriteLine("You chose the odd one out!")
End If

Der Code verwendet den nicht gleich (!=)-Operator, um zu überprüfen, ob die Eingabe nicht "dog" und "cat" entspricht. Durch die Kombination dieser Bedingungen mit dem logischen UND (&&)-Operator wird sichergestellt, dass beide Bedingungen wahr sein müssen, damit die Anweisung erfüllt wird. Wenn die Eingabe weder "Hund" noch "Katze" ist, muss es "Goldfisch" sein, und das Programm gibt aus: "Sie haben das Ungerade gewählt!"

else
{
    Console.WriteLine("Better luck next time!");
}

else
{
    Console.WriteLine("Better luck next time!");
}

Else
    Console.WriteLine("Better luck next time!")
End If

Else
    Console.WriteLine("Better luck next time!")
End If

Wenn die Eingabe des Benutzers diese Bedingung nicht erfüllt, d. h. die Eingabe entweder "Hund" oder "Katze" ist, wird der else-Block ausgeführt und das Programm gibt aus: "Mehr Glück beim nächsten Mal!"

Layla (8:30) führt weiter aus, wie wichtig es ist zu verstehen, wie logische Operatoren in bedingten Anweisungen funktionieren. Der UND-Operator (&&) erfordert, dass beide Bedingungen wahr sind, während der ODER-Operator (||) erfordert nur eine Bedingung, um wahr zu sein. Sie (9:05) demonstriert, wie die Verwendung dieser Operatoren das Verhalten des Programms verändern kann, und zeigt die Feinheiten und potenziellen Fallstricke bei der Verwendung logischer Operatoren in C# auf. Diese Erklärung hilft den Zuschauern zu verstehen, wie sie bedingte Logik in ihren Programmen effektiv einsetzen können.

Einführung in C# Switch Case Anweisungen

Switch-Anweisungen bieten eine alternative Möglichkeit zur Implementierung von Entscheidungen mit mehreren Verzweigungen in C#, die oft lesbarer und effizienter sind als mehrere if-else-Anweisungen. In C# wird "case c" zur Angabe von Bedingungen innerhalb von switch-Anweisungen verwendet, um sicherzustellen, dass der Vergleich auf Werte desselben Typs angewendet wird.

In ihrem Video (12:38) geht Layla Porter von einer if-else-Anweisung zu einer switch-Anweisung über, um die Längenkategorie eines bestimmten Wortes zu bestimmen. Sie erklärt, dass die Verwendung einer switch-Anweisung den Code sauberer und effizienter machen kann.

Der Codeschnipsel sieht wie folgt aus:

switch (word.Length)
{
    case < 6:
        Console.WriteLine("That's a short word!");
        break;
    case int length when 6 <= length && length < 11:
        Console.WriteLine("That's a medium length word!");
        break;
    default:
        Console.WriteLine("That's a long word!");
        break;
}

switch (word.Length)
{
    case < 6:
        Console.WriteLine("That's a short word!");
        break;
    case int length when 6 <= length && length < 11:
        Console.WriteLine("That's a medium length word!");
        break;
    default:
        Console.WriteLine("That's a long word!");
        break;
}

Select Case word.Length
    Case Is < 6
        Console.WriteLine("That's a short word!")
    Case 6 To 10
        Console.WriteLine("That's a medium length word!")
    Case Else
        Console.WriteLine("That's a long word!")
End Select

Select Case word.Length
    Case Is < 6
        Console.WriteLine("That's a short word!")
    Case 6 To 10
        Console.WriteLine("That's a medium length word!")
    Case Else
        Console.WriteLine("That's a long word!")
End Select

Layla erklärt, dass eine Switch-Anweisung aus mehreren Fällen besteht, von denen jeder einen möglichen Wert oder Wertebereich für die zu bewertende Variable darstellt. In diesem Fall ist die Variable word.Length.

1. Case < 6: Im ersten Fall wird geprüft, ob die Länge des Wortes weniger als 6 beträgt. Ist diese Bedingung erfüllt, gibt das Programm "That's a short word!" aus und verlässt dann den Switch-Block mit der Break-Anweisung. Denken Sie daran, dass der Fall mehrere Aussagen haben kann.

2. Case int length when 6 <= length && length < 11: Der zweite Fall ist komplexer. Es verwendet eine Musterabgleich-Funktion, die in C# 7.0 eingeführt wurde. Der Fall wird mit int length definiert, gefolgt von einer when-Klausel, die zusätzliche Bedingungen spezifiziert: Die Länge muss größer oder gleich 6 und kleiner als 11 sein. Wenn die Muster übereinstimmen, gibt das Programm "That's a medium length word!" aus und beendet dann den switch-Block.

3. Standard: Wenn keiner der vorherigen Fälle erfüllt ist, wird der Standardfall ausgeführt. Dies funktioniert wie die else-Anweisung in einer if-else-Struktur. In diesem Fall gibt das Programm die Meldung "That's a long word!" aus und verlässt den Switch-Block.

Layla (15:45) hebt hervor, dass die Verwendung einer switch-Anweisung anstelle einer if-Anweisung vorteilhaft sein kann, da sie den Code lesbarer und einfacher zu handhaben macht, insbesondere wenn es um mehrere Bedingungen geht. Außerdem erwähnt sie, dass Switch-Anweisungen effizienter sein können, weil der C#-Compiler sie anders optimiert und dadurch schneller ausführt.

Switch-Ausdrücke (Mustervergleiche)

Switch-Ausdrücke sind eine neuere Funktion in C#, die eine prägnantere Syntax für einfache wertbasierte Entscheidungen bietet. Im Video von Layla Porter (ca. 16:25) stellt sie eine moderne Switch-Anweisung vor, die als "switch expression" oder "pattern matching switch" in C# bezeichnet wird. Diese Art von Switch-Anweisung gibt direkt einen Wert zurück, was den Code übersichtlicher und lesbarer macht.

Sie (ca. 17:00) beginnt damit, dass sie zeigt, wie man eine if-else-Anweisung mit der switch-Ausdrucksyntax umschreibt. Anstatt Aktionen auszuführen, weist der Switch-Ausdruck einer Variablen einen Wert zu, der auf Bedingungen basiert. Zum Beispiel, dieses Beispiel:

// Example of Switch Expression
string message = word.Length switch
{
    < 6 => "That's a short word!",
    < 11 and >= 6 => "That's a medium length word!",
    _ => "That's a long length word!"
};

Console.WriteLine(message);

// Example of Switch Expression
string message = word.Length switch
{
    < 6 => "That's a short word!",
    < 11 and >= 6 => "That's a medium length word!",
    _ => "That's a long length word!"
};

Console.WriteLine(message);

' Example of Switch Expression
Dim message As String = word.Length Select Case
    Case < 6
        "That's a short word!"
    Case < 11 AndAlso >= 6
        "That's a medium length word!"
    Case Else
        "That's a long length word!"
End Select

Console.WriteLine(message)

' Example of Switch Expression
Dim message As String = word.Length Select Case
    Case < 6
        "That's a short word!"
    Case < 11 AndAlso >= 6
        "That's a medium length word!"
    Case Else
        "That's a long length word!"
End Select

Console.WriteLine(message)

Hier ist, was Layla (17:31) über den obigen Code erklärt:

1. String message = word.Length switch: Initialisiert eine String-Variable message und startet einen Switch-Ausdruck basierend auf word.Length.

2. < 6 => "That's a short word!": Wenn word.Length kleiner als 6 ist, gibt es "That's a short word!" unter Verwendung des kleiner als (<) Operators zurück.

3. < 11 and >= 6 => "That's a medium length word!": Wenn word.Length zwischen 6 und 10 einschließlich liegt, gibt es "That's a medium length word!" zurück, um and zur besseren Lesbarkeit zu verwenden.

4. _ => "Das ist ein langes Wort!": Der Unterstrich dient als Standardfall und gibt "Das ist ein langes Wort!" zurück, wenn keine der vorherigen Bedingungen erfüllt ist.

Layla betont, dass diese Syntax Teil der modernen C#-Funktionen ist, die die Lesbarkeit und Effizienz verbessern sollen. Der switch-Ausdruck wird gegenüber herkömmlichen if-else-Anweisungen bevorzugt, um mehrere Bedingungen prägnant zu behandeln.

Sie führt den Code um 19:30 Uhr aus und die Ausgabe ist die gleiche wie bei if-else:

Abschluss

Layla Porters Video bietet Anfängern eine solide Grundlage für die C#-Programmierung und behandelt grundlegende Konzepte wie Operatoren, bedingte Anweisungen und Switch-Anweisungen. Anhand ihrer Erklärungen und Beispiele können Anfänger praktische Einblicke in die effektive Manipulation von Daten und Steuerung des Programmablaufs in C# gewinnen.

Durch das Verständnis dieser grundlegenden Konzepte und das Üben mit den mitgelieferten Beispielen können C#-Neulinge eine solide Grundlage für komplexere Programmieraufgaben schaffen. Weitere C#-Videos finden Sie auf ihrem YouTube-Kanal.