Übung: Erstellen von Code mit Methoden

10 Minuten

Methoden sind nützlich, um Code zu organisieren, Code wiederzuverwenden und Probleme effizient anzugehen. Sie können sich eine Methode wie ein Blackbox vorstellen, die Eingaben übernimmt, die benannte Aufgabe ausführt und eine Ausgabe zurückgibt. Mit dieser Annahme können Sie Programme schnell strukturieren, indem Sie Ihre Aufgaben als Methoden benennen und dann die Logik einfügen, nachdem Sie alle erforderlichen Aufgaben identifiziert haben.

Wenn Sie einfache Sprache verwenden, um Schritte im Code zu beschreiben, ohne sich strikt an Syntaxregeln zu halten, verwenden Sie „Pseudocode“. Die Kombination von Methoden und Pseudocode ist eine großartige Möglichkeit, jede anspruchsvolle Programmieraufgabe schnell zu bewältigen.

Verwenden von Methoden zum Strukturieren von Code

Angenommen, Sie sind ein*e Bewerber*in bei einem Vorstellungsgespräch. Sie werden aufgefordert, ein Programm zu schreiben, das überprüft, ob eine IPv4-Adresse gültig oder ungültig ist. Sie erhalten die folgenden Regeln:

Eine gültige IPv4-Adresse besteht aus vier durch Punkte getrennten Zahlen.
Jede Zahl darf keine führenden Nullen enthalten.
Jede Zahl muss zwischen 0 und 255 liegen.

1.1.1.1 und 255.255.255.255 sind Beispiele für gültige IP-Adressen.

Die IPv4-Adresse wird als Zeichenfolge angegeben. Sie können davon ausgehen, dass sie nur aus Ziffern und Punkten besteht (in der bereitgestellten Zeichenfolge sind keine Buchstaben vorhanden).

Wie würden Sie diese Aufgabe angehen?

Hinweis

Auch wenn Sie nicht mit IP-Adressen vertraut sind, besteht kein Grund zur Sorge. Sie können den Code in dieser Übung problemlos vervollständigen, indem Sie die Schritte ausführen.

Aufschlüsseln des Problems

In dieser Aufgabe identifizieren Sie die Schritte, die zum Beheben des Problems erforderlich sind. Wenn Sie sich die Regeln genau ansehen, werden Sie möglicherweise feststellen, dass nur drei Schritte erforderlich sind, um zu bestimmen, ob eine IPv4-Adresse gültig ist oder nicht.

Löschen Sie im Visual Studio Code-Editor vorhandenen Code aus den vorherigen Übungen.
Geben Sie den folgenden Pseudocode in den Editor ein:
```
/*
if ipAddress consists of 4 numbers
and
if each ipAddress number has no leading zeroes
and
if each ipAddress number is in range 0 - 255

then ipAddress is valid

else ipAddress is invalid
*/
```
Pseudocode ist eine großartige Möglichkeit, um jedes Problem anzugehen. Mit diesem Kommentarblock schließen Sie die Lücke zwischen den Eingabeaufforderungsregeln und dem Programmcode, um die wichtigsten Aufgaben zu verdeutlichen, die Ihr Code ausführen wird. Pseudocode muss nicht funktionsfähig sein oder Syntaxregeln einhalten, sollte jedoch eine klare Erklärung dafür sein, was der Code tut. Im Folgenden wenden Sie diesen Ansatz auf echten Code an.
Fügen Sie eine neue leere Codezeile hinzu, und geben Sie dann den folgenden Code im Editor ein:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
In diesem Schritt transformieren Sie die if-Anweisungen aus Ihrem Pseudocode in aufrufbare Methoden und geben die Ergebnisse aus. Machen Sie sich noch keine Gedanken über die Definition der Methoden. Sie können davon ausgehen, dass jede Methode die Aufgabe ausführt, die ihr Name beschreibt. Sie beheben die Kompilierungsfehler und erstellen die Methodenlogik bald, konzentrieren sich aber vorerst auf die Gesamtsituation. Wenn Sie mit der Arbeit an einem neuen Programm beginnen, hilft Ihnen der Fokus auf das Gesamtkonzept, um organisiert zu bleiben und Ihre Anwendung schneller zu entwickeln.
Fügen Sie unter dem vorhandenen Code eine neue leere Codezeile hinzu, und geben Sie dann den folgenden Code im Editor ein:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Beachten Sie, wie Sie mithilfe von Platzhaltermethoden schnell an das Problem herangehen und Ihren Code strukturieren konnten, um die Lösung zu entwickeln. Nachdem Sie nun über einen strukturierten Plan verfügen, können Sie mit der Problembehandlung fortfahren, indem Sie den Code Stück für Stück einfügen.

Entwickeln Ihrer Lösung

Nachdem Sie nun über alle Platzhaltermethoden verfügen, die zum Beheben des Problems erforderlich sind, können Sie sich auf die Details Ihrer Lösung konzentrieren. Beachten Sie, dass das Eingabeformat der IPv4-Adresse eine Zeichenfolge ist, die aus durch Punkte getrennten Ziffern besteht. Fangen wir an!

Erstellen Sie zu Beginn Ihres Programms Variablen, um den Eingabe- und Validierungsstatus zu speichern:

string ipv4Input = "107.31.1.5";
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Aktualisieren Sie Ihren Lösungscode so, dass die Validierungsvariablen wie folgt verwendet werden:

ValidateLength(); 
ValidateZeroes(); 
ValidateRange();

if (validLength && validZeroes && validRange) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}

Aktualisieren Sie die ValidateLength-Methode wie folgt:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
Die erste Regel besagt, dass die IPv4-Adresse vier Zahlen aufweisen muss. In diesem Code verwenden Sie string.Split also, um die Ziffern zu trennen und zu überprüfen, ob vier Ziffern vorhanden sind.
Aktualisieren Sie die ValidateZeroes-Methode wie folgt:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
        }
    }

    validZeroes = true;
}
```
Nehmen Sie sich einen Moment Zeit, um zu überlegen, wie die Regel in Code übersetzt wird.

Die zweite Regel besagt, dass die Zahlen in der IPv4-Adresse keine führenden Nullen enthalten dürfen. Daher muss die Methode Zahlen auf führende Nullen überprüfen, während sie 0 als gültige Zahl akzeptiert. Wenn alle Zahlen gültige Nullen aufweisen, sollte validZeroestrue entsprechen (andernfalls false). In diesem Code überprüfen Sie also, ob jede Zahl mit mehr als einer Ziffer nicht mit einer Null beginnt.

Bei genauerer Betrachtung werden Sie feststellen, dass validZeroes auf true festgelegt ist, nachdem die foreach-Schleife abgeschlossen ist. Sie möchten validZeroes jedoch nur auf true festlegen, wenn keine führenden Nullen gefunden werden. Sie können diesen Fehler beheben, indem Sie validZeroes = true festlegen, bevor die foreach-Schleife ausgeführt wird. Sie können diesen Fehler jedoch auch mithilfe einer return-Anweisung beheben.
Aktualisieren Sie Ihren Code wie folgt:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
Die return-Anweisung beendet die Ausführung der Methode und gibt die Kontrolle zurück an den Methodenaufrufer. Durch das Hinzufügen einer return-Anweisung nach validZeroes = false wird die Methode beendet, nachdem die erste ungültige Null gefunden wurde. Wenn keine ungültige Null gefunden wird, wird die Methode nach dem Festlegen von validZeroes auf true beendet. Fahren nun Sie mit der nächsten Methode fort.
Aktualisieren Sie die ValidateRange-Methode wie folgt:
```
void ValidateRange() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}
```
Die dritte Regel besagt, dass jede Zahl in der IPv4-Adresse zwischen 0 und 255 liegen muss. In diesem Code überprüfen Sie also, ob jede Zahl kleiner als 255 ist. Andernfalls beenden Sie die Ausführung, nachdem Sie validRange auf false festgelegt haben. Da die Eingabezeichenfolge nur Ziffern und Punkte enthält, müssen Sie nicht nach negativen Zahlen suchen.

Es kann jedoch vorkommen, dass zwischen Punkten keine Ziffern vorhanden sind. Beispiel: "255...255". In diesem Fall gibt string.Split(".") leere Einträge zurück, weshalb int.Parse fehlschlägt. Sie können dies verhindern, indem Sie StringSplitOptions angeben.
Aktualisieren Sie den Code wie folgt:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
Durch die Verwendung von StringSplitOptions.RemoveEmptyEntries werden leere Einträge aus dem address-Array ausgelassen, und es wird verhindert, dass leere Zeichenfolgen analysiert werden.

Vervollständigen Ihrer Lösung

Nachdem Sie nun über alle Methoden zum Überprüfen einer IP-Adresse verfügen, ist es an der Zeit, Ihre ursprüngliche Lösung erneut zu überprüfen. In dieser Aufgabe fügen Sie weitere Eingabewerte hinzu und bereiten den Test Ihres Codes vor.

Suchen Sie den folgenden Code, den Sie zuvor im Programm geschrieben haben:
```
string ipv4Input = "107.31.1.5";
```
Aktualisieren Sie den Code wie folgt:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Beim Entwickeln einer Lösung ist es wichtig, Ihren Code mit verschiedenen Eingabefällen zu testen. In diesem Code stellen Sie einen angemessenen Bereich von Testwerten bereit. Nachdem Sie Ihre Testeingabe aktualisiert haben, müssen Sie Ihren Code so aktualisieren, dass die neuen Werte verwendet werden. Da sich die Werte in einem Array befinden, müssen Sie Ihren Code aktualisieren, um jeden Wert mithilfe einer Schleife zu testen.
Aktualisieren Sie den Code wie folgt:
```
foreach (string ip in ipv4Input) 
{
    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}
```
Schließlich müssen Sie die Eingabedaten korrigieren, die jede Methode verwendet, da Sie ipv4Input von einer Zeichenfolge auf ein Array aktualisiert haben. Da jede Methode string.Split verwendet, können Sie eine Variable zum Speichern des Ergebnisses von string.Split deklarieren und sie stattdessen in jeder Methode verwenden.

Fügen Sie eine Variable hinzu, um die aktuelle IPv4-Adresse zu speichern, auf die jede Methode verweist:

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Initialisieren Sie address mithilfe von string.Split wie folgt:

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

Entfernen Sie Verweise auf string.Split aus den einzelnen Validierungsmethoden, damit sie stattdessen die globale address-Variable verwenden. Beispiel:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Überprüfen Ihrer Arbeit

In dieser Aufgabe führen Sie Ihre Anwendung über das integrierte Terminal aus und überprüfen, ob Ihr Code ordnungsgemäß funktioniert. Fangen wir also an.

Vergleichen Sie Ihren Code mit dem folgenden Code, um sicherzustellen, dass er richtig ist:

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}

void ValidateLength() 
{
    validLength = address.Length == 4;
};

void ValidateZeroes() 
{
    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
            return;
        }
    }

    validZeroes = true;
}

void ValidateRange() 
{
    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}

Speichern Sie Ihre Arbeit mithilfe von STRG + S oder über das Visual Studio Code-Menü „Datei“.
Öffnen Sie bei Bedarf das Visual Studio Code-Panel „Integriertes Terminal“.

Klicken Sie im Panel „Explorer“ mit der rechten Maustaste auf TestProject, und klicken Sie dann auf In integriertem Terminal öffnen, um ein Terminal am Speicherort des TestProject-Ordners zu öffnen.
Geben Sie an der Terminal-Eingabeaufforderung dotnet run ein.
Stellen Sie sicher, dass Ihr Code die folgende Ausgabe erzeugt:
```
107.31.1.5 is a valid IPv4 address
255.0.0.255 is a valid IPv4 address
555..0.555 is an invalid IPv4 address
255...255 is an invalid IPv4 address
```
Wenn Ihr Code unterschiedliche Ergebnisse anzeigt, müssen Sie ihn überprüfen, um den Fehler zu finden und Aktualisierungen vorzunehmen. Führen Sie den Code erneut aus, um festzustellen, ob Sie das Problem behoben haben. Fahren Sie mit dem Aktualisieren und Ausführen Ihres Codes fort, bis der Code die erwarteten Ergebnisse generiert.

Zusammenfassung

Bisher haben Sie Folgendes über die Verwendung von Methoden gelernt:

Methoden können verwendet werden, um Anwendungen schnell zu strukturieren.
Das return-Schlüsselwort kann verwendet werden, um die Methodenausführung zu beenden.
Jeder Schritt eines Problems kann häufig in eine eigene Methode übersetzt werden.
Durch die Verwendung von Methoden können Sie kleine Probleme beim Erstellen Ihrer Lösung beheben.

Feedback

War diese Seite hilfreich?