Switch Case Anweisung

adel /pixelio.de

 

Die Switch Case Anweisung kann man nutzen, wenn man aus einer festen Menge von möglichen Kandidaten auswählt. Sie könnte zum Beispiel eingesetzt werden wenn auf einem Telefon eine entsprechende Taste gedrückt wurde. Wenn die 1 gedrückt wurde, könnte man zum Beispiel eine Weiterleitung an einen anderen Service implementieren. Wenn die 2 gedrückt wurde, könnte man die Weiterleitung mit einem Servicemitarbeiter umsetzen und so weiter.

Jede Switch Case Anweisung ließe sich auch mit einer „If elseif“ Anweisung umsetzen. Der Vorteil der Switch Case Anweisung ist, dass sie besser lesbar ist, da sie nicht so tief verschachtelt ist.

Der Aufbau ist recht einfach erklärt:

  1. Es startet mit dem Switch Keyword
  2. In den Klammern nach dem Keyword die Variable die überprüft wird
  3. In geschweiften Klammern, die Case Klausel gefolgt von
  4. Dem bedingten Wert und einem Doppelpunkt
  5. Dann kommt die eigentliche Anweisung die ausgeführt werden soll, wenn die Variable diesen Wert enthält.
  6. Am Ende eines Caseblocks steht das Schlüsselwort „break“. Es verhindert ein weiteres Ausführen des nachfolgenden Codes.
  7. Am Ende das optionale Schlüsselwort „default“ der hierauf folgende Code wird ausgeführt, wenn keiner der vorherigen Bedingungen wahr ist, oder bei der vorherigen Anweisung das Schlüsselwort „break“ nicht benutzt wurde.

Zum Beispiel C#, Java und weitere

Zum Beispiel C#, Java und weitere

      int number = 1;
      
      switch (number)
      {
          case 1:
              //Auszuführender Code wenn Number = 1 ist
              break;
          case 2:
              //Auszuführender Code wenn Number = 2 ist
              break;
          default:
              //Wird ausgeführt wenn andere Bedingungen nicht wahr sind
              break;
      }

VB:

Dim number As Integer = 8
 Select Case number
 Case 1
 //Auszuführender Code wenn die Number = 1 ist
 Case 2
 //Auszuführender Code wenn die Number = 2 ist
 Case Else
 //Wird ausgeführt wenn andere Bedingungen nicht wahr sind
End Select

In C# 7 wurde die Switch Anweisung weiterentwickelt. Es ist nun möglich auf jede Art von Typ ein Switch auszuführenden, zum Beispiel auf komplexe Objekte. Es können weiterführende Vergleiche (Pattern) in der Case Klausel benutzt werden. Hier findest du weiterführende Information von Microsoft. 

Um das Ganze noch ein bisschen greifbarer zu machen möchte ich gerne noch ein bisschen zusätzlichen Code mit euch teilen. Nachfolgend findet ihr Code für einen etwas erweiterten Taschenrechner, er kann auch Wurzeln ziehen und quadrieren (wenn W bzw. Q als Operator eingegeben wird). Auch Kommazahlen kann er verarbeiten, allerdings nur Zahlen zwischen -28000 und +28000. Wenn dich das stört, ändere es doch einfach ;). Wenn du Fragen hast nutze bitte die Kommentarfunktion.

using System;

namespace Rechnen
{

    class Program
    {


        static void Main(string[] args)
        {
            string strOperator;
            double dblZahl1;
            double dblZahl2;
            double dblErgebnis = 0;


            Console.WriteLine("\t\t*****\terweiterter Taschenrechner\t*****\n\n");
            Console.Write("Geben Sie die erste Zahl ein:\t\t\t\t\t");
            dblZahl1 = Convert.ToDouble(Console.ReadLine());

            if (dblZahl1 < -28000 | dblZahl1 > 28000)
            {
                Console.WriteLine("\n\nFehler: Bitte geben Sie eine Zahl zwischen -28.000 und 28.000 (achtundzwanzigtausend) ein.");
                Console.Read();
            }
            else
            {
                Console.Write("Geben Sie +, -, *, /, Q, oder W für die Rechenart ein:\t\t");
                strOperator = Console.ReadLine();

                if (strOperator == "+" || strOperator == "-" || strOperator == "*" || strOperator == "/" || strOperator == "W" || strOperator == "Q")
                {

                    switch (strOperator)
                    {
                        case "Q":

                            dblErgebnis = Math.Pow(dblZahl1, 2);
                            break;

                        case "W":

                            if (dblZahl1 < 0)
                            {
                                Console.WriteLine("\n\nFehler: Eine Wurzel aus einer negativen Zahl zu ziehen, ist leider nicht möglich, bitte geben Sie eine Zahl die <= 0 ist ein.");
                                Console.Read();
                            }
                            else
                            {
                                dblErgebnis = Math.Sqrt(dblZahl1);
                            }
                            break;

                        default:

                            Console.Write("Geben Sie die zweite Zahl ein:\t\t\t\t\t");
                            dblZahl2 = Convert.ToDouble(Console.ReadLine());

                            if (dblZahl2 < -28000 | dblZahl2 > 28000)
                            {
                                Console.WriteLine("\n\nFehler: Bitte geben Sie eine Zahl zwischen -28.000 und 28.000 (achtundzwanzigtausend) ein.");
                                Console.Read();
                            }
                            else
                            {
                                if (strOperator == "/" && dblZahl2 == 0)
                                {
                                    Console.WriteLine("------------------------------------------------------------------");
                                    Console.WriteLine("\nFehler: Eine Division durch Null ist mathematisch nicht möglich, nehmen Sie eine andere Zahl!");
                                    Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by Kai Fischer\"");
                                    Console.Read();
                                }
                                else
                                {

                                    switch (strOperator)
                                    {

                                        case "+":

                                            dblErgebnis = dblZahl1 + dblZahl2;
                                            break;

                                        case "-":

                                            dblErgebnis = dblZahl1 - dblZahl2;
                                            break;

                                        case "*":

                                            dblErgebnis = dblZahl1 * dblZahl2;
                                            break;

                                        case "/":

                                            dblErgebnis = dblZahl1 / dblZahl2;
                                            break;

                                    }
                                    if (strOperator == "+" | strOperator == "-" | strOperator == "*" | strOperator == "/" | strOperator == "W" | strOperator == "Q")
                                    {
                                        Console.WriteLine("------------------------------------------------------------------");
                                        Console.WriteLine("\nDas Ergebnis ihrer Rechnung lautet:\t\t\t\t{0}", Math.Round(dblErgebnis, 2));
                                        Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by https://lerne-programmieren.com/blog\"");
                                        Console.Read();
                                    }
                                }

                            }
                            break;

                    }
                }
                else
                {
                    Console.WriteLine("------------------------------------------------------------------");
                    Console.WriteLine("\nDies war keine gültige Eingabe für einen Operanden.\nBitte geben Sie +, -, *, /, Q oder W ein.");
                    Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by https://lerne-programmieren.com/blog\"");
                    Console.Read();
                }
            }
        }

    }
}



Empfohlene weiterführende Literatur:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java

Taschenrechner

Konstantin Gastmann / pixelio.de

eine erste C# consolenapplication (Konsolenanwendung) habt ihr bereits erstellt, wenn ihr meinem Beitrag HelloWorld gefolgt seid. Außerdem habe ich euch gezeigt, wo ihr die Entwicklungsumgebung Visual Studio kostenlos bekommt und wie ihr eine erste Konsolenanwendung schreibt.
Dieser Beitrag soll euch zeigen wie ihr nun die nächste Konsolenapplikation erstellt. Diese Anwendung soll 2 ganzahlige Zahlen, einen Operator der Grundrechenarten: Addition (+), Subtraktion (-), Division (/), oder Multiplikation (x) einlesen Und das zugehörige Ergebnis ausgeben. Wenn du sowas noch nie gemacht hast, wirst du eine ganze Menge dabei lernen.
Als erstes musst du in Visual Studio wieder ein neues Projekt, vom Typ „Konsolenanwendung“ anlegen.
Deine Entwicklungsumgebung sollte jetzt wie folgt aussehen:

Jetzt gibst du der Anwendung einen Titel dazu rufst du wieder das Console Objekt auf und weißt der Eigenschaft Title einen Wert vom Datentyp string  zu, nämlich den Titel den dein Programm haben soll.

Console.Title = "Grundrechenarten";

Danach rufst du die Methode WriteLine auf um eine Zeile in die Konsole zu schreiben. Du schreibst jetzt am besten die Überschrift und Namen des Programms in die Konsole und ggf. kannst du die Ausgabe auch ein bisschen formatieren zum Beispiel so:

Console.WriteLine("Mein einfacher Taschenrechner von https://lerne-programmieren.com");          Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------\n");

Als nächstes wollen wir dem Benutzer deiner Anwendung ermöglichen Zahlen einzugeben. Dazu fordern wir den Benutzer auf, damit er weiß wie er dein Programm zu bedienen hat dies geschieht mit der Write Methode auf dem Console Objekt:

Console.Write("Bitte gib die erste ganzzahlige Zahl ein:\t\t ");

Vielleicht fällt dir auf dass sich die Methode/Funktion von der zuvor genutzten etwas unterscheidet. Sie heißt jetzt Write anstatt WriteLine. Bei WriteLine springt der Cursor nach dem Ausführen des Befehls in eine neue Zeile. Bei Write bleibt er in der gleichen Zeile.

Jetzt brauchen wir noch eine Variable in der wir die Benutzereingabe speichern können. Wir werden der Einfachheit halber den Datentyp integer nutzen mit dem nur ganze Zahlen gespeichert werden können. Ihr könnt es aber auch mit einem Datentyp der Kommazahlen zulässt probieren, wie zum Beispiel double.

int ersteEingabe = 0;

Im nächsten Schritt wollen wir die Benutzereingabe auslesen. Dazu dient der Befehl ReadLine, der auf dem Console Objekt ausgeführt wird. Allerdings könnte man ja auch ungültige Zeichen wie Buchstaben oder Sonderzeichen eingeben, das würde zu einem Fehler führen. Um das zu verhindern, gibt es die Methode Int32.TryParse diese versucht einen Wert vom Datentyp string (in diesem Fall die Eingabe des Benutzers) in den Datentyp integer zu konvertieren, das bedeutet umzuwandeln. Als Parameter muss dieser Methode die Quelle, also in diesem Fall die Eingabe des Benutzers, und ein Ziel, in diesem Fall unsere grade erstellte Variable ersteEingabe angegeben werden.

Das sieht dann so aus:

Int32.TryParse(Console.ReadLine(), out ersteEingabe);

Durch den Befehl Console.ReadLine() wird außerdem die Anwendung solange gestoppt bis der Benutzer die Enter Taste betätigt und die Eingabe zurückgegeben.

Das Gleiche wollen wir für eine 2. Zahl tun:

Console.Write("Bitte gib die zweite ganzzahlige Zahl ein:\t\t ");
 int zweiteEingabe = 0;
 Int32.TryParse(Console.ReadLine(), out zweiteEingabe);

Man könnte jetzt noch den Rückgabewert der TryParse Methode abfragen um dann eine Fehlermeldung auszugeben, falls ein Wert eingegeben wurde der keine Zahl ist, aber der Einfachheit halber sehen wir hier davon ab.

Jetzt haben wir 2 Zahlen aber das Programm weiß noch nicht was es damit anfangen soll, der Operator fehlt noch, also wird dieser auch eingelesen:

Console.Write("Bitte gib einen gültigen Operator ein (+,-,*,/):\t ");
char numerischerOperator;
char.TryParse(Console.ReadLine(), out numerischerOperator);

Als Datentyp wurde hier character gewählt, also ein einzelnes Zeichen, der der Operator immer nur ein Zeichen hat.

Jetzt haben wir 2 Zahlen und einen Operator im Speicher, wir müssen also als nächstes das Ergebnis berechnen, dazu braucht man natürlich wieder eine Variable, gut verständliche Namen sind übrigens sehr wichtig beim Programmieren, also gewöhne es dir direkt an:

double ergebnis = 0;

Jetzt müssen wir entscheiden welche Rechenoperation ausgeführt werden muss. Hierzu müssen wir den Wert abfragen und dann entscheiden ob wir entweder die eine oder die andere Rechenoperation ausführen.

Der Befehl dazu heißt

if(Bedingung)
 {
 //Code der ausgeführt wird, wenn Bedingung erfüllt
 }
Else
 {
 //Code der ausgeführt wird, wenn Bedingung nicht erfüllt
 }

Ich habe es folgendermaßen umgesetzt:

if (numerischerOperator.Equals('+'))
{
     ergebnis = ersteEingabe + zweiteEingabe;
}
else if (numerischerOperator.Equals('-'))
{
    ergebnis = ersteEingabe - zweiteEingabe;
}
else if (numerischerOperator.Equals('*'))
{
   ergebnis = ersteEingabe * zweiteEingabe;
}
else if (numerischerOperator.Equals('/'))
{
  ergebnis = ersteEingabe / zweiteEingabe;
}
else
{                Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
Console.WriteLine("Fehler, du hast keinen gültigen Operanden eingegeben!");
Console.WriteLine("Beliebige Taste zum Beenden drücken!");                Console.ReadKey();
Environment.Exit(0);
}

 

Die Rechenoperation wird ausgeführt und das Ergebnis in die ergebnisvariable geschrieben. Der letzte Elseblock wird ausgeführt wenn keine der vorherigen Bedingungen erfüllt wurde, also wenn im Operator ein Zeichen steht das weder +,-,* noch / ist. Der Befehl Environment.Exit(0); beendet das Programm und die 0 als Parameter teilt dem Betriebssystem mit, dass das Programm ordnungsgemäß heruntergefahren wurde.

Danach kommt der Code um das Ergebnis in der Konsole auszugeben:

Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
Console.WriteLine("Das Ergebnis ist:\t\t\t\t\t {0}", ergebnis);
Console.WriteLine("Beliebige Taste zum Beenden drücken!");            Console.ReadKey();

Die Zeichenfolge {0} ist ein Platzhalter für den Wert einer Varibale, der dort ausgegeben werden soll. In diesem Fall das Ergebnis. Man gibt diese Variable nach einem Komma an. Man könnte auch mehrere Platzhalter einfügen dies kann man dann durchnummerieren {0}{1} {2} usw. und die Variablenwerte werden in der angegebenen Reihenfolge eingesetzt. Hast du noch Fragen, dann lass es mich in den Kommentaren wissen?!

Übrigens, wenn ihr Visual Studio nutzt eine Klasse, Methode, oder Objekt markiert und dann F1 drückt öffnet sich die Microsoft Dokumentation dazu.

Hier der gesamte Quellcode:

using System;

namespace Grundrechenarten
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Grundrechenarten";
            Console.WriteLine("Mein einfacher Taschenrechner von https://lerne-programmieren.com");
            Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------\n");

            Console.Write("Bitte gib die erste ganzzahlige Zahl ein:\t\t ");
            int ersteEingabe = 0;
            Int32.TryParse(Console.ReadLine(), out ersteEingabe);

            Console.Write("Bitte gib die zweite ganzzahlige Zahl ein:\t\t ");
            int zweiteEingabe = 0;
            Int32.TryParse(Console.ReadLine(), out zweiteEingabe);

            Console.Write("Bitte gib einen gültigen Operator ein (+,-,*,/):\t ");
            char numerischerOperator;
            char.TryParse(Console.ReadLine(), out numerischerOperator);

            double ergebnis = 0;
            if (numerischerOperator.Equals('+'))
            {
                ergebnis = ersteEingabe + zweiteEingabe;
            }
            else if (numerischerOperator.Equals('-'))
            {
                ergebnis = ersteEingabe - zweiteEingabe;
            }
            else if (numerischerOperator.Equals('*'))
            {
                ergebnis = ersteEingabe * zweiteEingabe;
            }
            else if (numerischerOperator.Equals('/'))
            {
                ergebnis = ersteEingabe / zweiteEingabe;
            }
            else
            {
                Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
                Console.WriteLine("Fehler, du hast keinen gültigen Operator eingegeben!");
                Console.WriteLine("Beliebige Taste zum Beenden drücken!");
                Console.ReadKey();
                Environment.Exit(0);
            }
            Console.WriteLine("-----------------------------------------------------------------------------------------------------------------------");
            Console.WriteLine("Das Ergebnis ist:\t\t\t\t\t {0}", ergebnis);
            Console.WriteLine("Beliebige Taste zum Beenden drücken!");
            Console.ReadKey();
        }
    }
}

 

Weiterführende Literatur, für Anfänger gut geeignet in C# oder in C:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken