Oefening: code bouwen met methoden

10 minuten

Methoden zijn handig voor het ordenen van code, het hergebruik van code en het efficiënt oplossen van problemen. U kunt een methode beschouwen als een zwarte doos die invoer gebruikt, de benoemde taak uitvoert en uitvoer retourneert. Met deze aanname kunt u programma's snel structureren door uw taken als methoden te benoemen en vervolgens de logica in te vullen nadat u alle benodigde taken hebt geïdentificeerd.

Wanneer u gewone taal gebruikt om stappen in code te beschrijven, zonder strikt te onthouden van syntaxisregels, gebruikt u pseudocode. Het combineren van methoden en pseudocode is een uitstekende manier om snel een uitdagende programmeertaak te doorlopen.

Methoden gebruiken om code te structuren

Stel dat u kandidaat bent in een coderingsgesprek. De interviewer wil dat u een programma schrijft waarmee wordt gecontroleerd of een IPv4-adres geldig of ongeldig is. U krijgt de volgende regels:

Een geldig IPv4-adres bestaat uit vier getallen gescheiden door puntjes
Elk getal mag geen voorloopnullen bevatten
Elk getal moet variëren van 0 tot 255

1.1.1.1 en 255.255.255.255 zijn voorbeelden van geldige IP-adressen.

Het IPv4-adres wordt opgegeven als een tekenreeks. U kunt ervan uitgaan dat deze alleen bestaat uit cijfers en punten (er zijn geen letters in de opgegeven tekenreeks).

Hoe zou u deze taak benaderen?

Notitie

Zelfs als u niet bekend bent met IP-adressen, hoeft u zich geen zorgen te maken. U kunt de code in deze oefening nog steeds voltooien door de stappen te volgen.

Het probleem opsplitsen

In deze taak identificeert u de stappen die nodig zijn om het probleem op te lossen. Als u de regels goed bekijkt, realiseert u zich misschien dat er slechts drie stappen nodig zijn om te bepalen of een IPv4-adres geldig is.

Verwijder in de Visual Studio Code-editor alle bestaande code uit de vorige oefeningen.
Voer de volgende pseudocode in de editor in:
```
/*
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 is een uitstekende manier om elk probleem op te lossen. Met behulp van dit opmerkingenblok overbrugt u de kloof tussen de promptregels en de programmacode, waardoor de belangrijkste taken die door uw code worden uitgevoerd, worden verduidelijkt. Pseudocode hoeft niet functioneel te zijn of te voldoen aan syntaxisregels, maar het moet een duidelijke uitleg zijn van wat de code gaat doen. Laten we dit nu omzetten in echte code.
Voer een nieuwe lege coderegel in en typ vervolgens de volgende code in de editor:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
In deze stap transformeert u de if instructies van uw pseudocode naar aanroepbare methoden en voert u de resultaten uit. Maak u nog geen zorgen over het definiëren van de methoden; u kunt ervan uitgaan dat elke methode de naam van de taak uitvoert. U lost de compilatiefouten op en maakt binnenkort de methodelogica, maar richt u zich voorlopig op het grote geheel. Wanneer u aan een nieuw programma begint te werken, kunt u zich richten op het algehele ontwerp, zodat u uw toepassing sneller georganiseerd kunt houden en ontwikkelen.
Voer een nieuwe lege coderegel onder de bestaande code in en typ vervolgens de volgende code in de editor:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
U ziet hoe u met behulp van tijdelijke aanduidingen snel het probleem kunt benaderen en uw code kunt structuren om de oplossing te ontwikkelen. Nu u een gestructureerd plan hebt, kunt u het probleem blijven oplossen door het codefragment per stuk in te vullen.

Uw oplossing ontwikkelen

Nu u alle tijdelijke aanduidingen hebt die nodig zijn om het probleem op te lossen, kunt u zich richten op de details van uw oplossing. Houd er rekening mee dat de invoerindeling van het IPv4-adres een tekenreeks is die bestaat uit cijfers gescheiden door puntjes. Laten we aan de slag gaan.

Maak aan het begin van uw programma variabelen om de invoer- en validatiestatussen op te slaan:

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

Werk uw oplossingscode als volgt bij om de validatievariabelen te gebruiken:

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

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

Werk de ValidateLength methode als volgt bij:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
De eerste regel geeft aan dat het IPv4-adres vier getallen moet hebben. In deze code gebruikt string.Split u dus om de cijfers te scheiden en te controleren of er vier cijfers zijn.
Werk de ValidateZeroes methode als volgt bij:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

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

    validZeroes = true;
}
```
Neem even de tijd om na te gaan hoe de regel wordt omgezet in code.

De tweede regel geeft aan dat de getallen in het IPv4-adres geen voorloopnullen mogen bevatten. De methode moet dus getallen controleren op voorloopnullen terwijl deze 0 wordt geaccepteerd als een geldig getal. Als alle getallen geldige nullen hebben, validZeroes moet deze gelijk zijn aan trueen false anders. In deze code controleert u dus of elk getal met meer dan één cijfer niet begint met een nul.

Als u goed kijkt, ziet u dat validZeroes dit is ingesteld op true nadat de foreach lus is voltooid. U wilt echter alleen instellen validZeroestrue op als er geen voorloopnullen worden gevonden. U kunt deze fout corrigeren door in te stellen validZeroes = true voordat de foreach lus wordt uitgevoerd. U kunt deze fout echter ook corrigeren met behulp van een retourinstructie.
Werk uw code bij naar het volgende:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
De retourinstructie beëindigt de uitvoering van de methode en retourneert het besturingselement naar de aanroeper van de methode. Als u een return instructie toevoegt nadat validZeroes = false de methode is beëindigd nadat de eerste ongeldige nul is gevonden. Als er geen ongeldige nul wordt gevonden, wordt de methode beëindigd na het instellen validZeroes op true. We gaan verder met de volgende methode.
Werk de ValidateRange methode als volgt bij:
```
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;
}
```
De derde regel geeft aan dat elk getal in het IPv4-adres moet variëren van 0 tot 255. In deze code controleert u dus of elk getal kleiner is dan 255, en zo niet, beëindigt u de uitvoering na instelling validRange op false. Omdat de invoertekenreeks alleen cijfers en punten bevat, hoeft u niet te controleren op negatieve getallen.

Er kan echter een geval zijn waarin er geen cijfers tussen puntjes aanwezig zijn. Bijvoorbeeld '255...255'. In dit geval string.Split(".") worden lege vermeldingen geretourneerd, waardoor deze int.Parse mislukken. U kunt dit voorkomen door op te StringSplitOptionsgeven.
Werk uw code als volgt bij:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
Als u StringSplitOptions.RemoveEmptyEntries lege vermeldingen uit de address matrix weglaat en probeert te voorkomen dat lege tekenreeksen worden geparseerd.

Uw oplossing voltooien

Nu u alle methoden hebt voltooid om een IP-adres te valideren, is het tijd om terug te gaan naar uw eerste oplossing. In deze taak voegt u meer invoerwaarden toe en bereidt u zich voor om uw code te testen.

Zoek de volgende code die u eerder in het programma hebt geschreven:
```
string ipv4Input = "107.31.1.5";
```
Werk de code als volgt bij:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Bij het ontwikkelen van een oplossing is het belangrijk om uw code te testen met verschillende invoercases. In deze code geeft u een behoorlijk aantal testwaarden op. Nu u uw testinvoer hebt bijgewerkt, moet u uw code bijwerken om de nieuwe waarden te kunnen gebruiken. Omdat de waarden zich in een matrix bevinden, moet u uw code bijwerken om elke waarde te testen met behulp van een lus.
Werk uw code als volgt bij:
```
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");
    }
}
```
Ten slotte moet u de invoergegevens herstellen die door elke methode worden gebruikt, omdat u een tekenreeks hebt bijgewerkt ipv4Input naar een matrix. Aangezien elke methode gebruikmaakt string.Split, kunt u een variabele declareren om het resultaat ervan string.Split op te slaan en in elke methode te gebruiken.

Voeg een variabele toe om het huidige IPv4-adres op te slaan waarnaar elke methode verwijst:

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;

Initialiseer address als string.Split volgt:

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

Verwijder verwijzingen naar string.Split elk van de validatiemethoden, zodat ze in plaats daarvan de globale address variabele gebruiken. Voorbeeld:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Uw werk controleren

In deze taak voert u uw toepassing uit vanuit de Integrated Terminal en controleert u of uw code correct werkt. Laten we aan de slag gaan.

Vergelijk uw code met het volgende om te controleren of deze juist is:

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

Sla uw werk op met Ctrl + S of met het menu Visual Studio Code File.
Open zo nodig het geïntegreerde terminalpaneel van Visual Studio Code.

Klik in het deelvenster EXPLORER om een Terminal te openen op de locatie van de map TestProject met de rechtermuisknop op TestProject en selecteer Vervolgens Openen in geïntegreerde terminal.
Voer bij de Terminalcommando-prompt dotnet run in
Controleer of uw code de volgende uitvoer produceert:
```
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
```
Als uw code verschillende resultaten weergeeft, moet u uw code controleren om uw fout te vinden en updates aan te brengen. Voer de code opnieuw uit om te zien of u het probleem hebt opgelost. Ga door met het bijwerken en uitvoeren van uw code totdat uw code de verwachte resultaten produceert.

Samenvatting

Dit is wat u tot nu toe hebt geleerd over het gebruik van methoden:

Methoden kunnen worden gebruikt om snel toepassingen te structureren
Het return trefwoord kan worden gebruikt om de uitvoering van de methode te beëindigen
Elke stap van een probleem kan vaak worden omgezet in een eigen methode
Methoden gebruiken om kleine problemen op te lossen om uw oplossing op te bouwen

Feedback

Is deze pagina nuttig?