Øvelse – Opret kode med metoder

10 minutter

Metoder er nyttige til at organisere kode, genbruge kode og til at løse problemer effektivt. Du kan tænke på en metode som et sort felt, der tager input, udfører den navngivne opgave og returnerer output. Med denne antagelse kan du hurtigt strukturere programmer blot ved at navngive dine opgaver som metoder og derefter udfylde logikken, når du har identificeret alle de nødvendige opgaver.

Når du bruger almindeligt sprog til at beskrive trin i kode, uden at du nøje overholder syntaksregler, bruger du "pseudokode". Kombination af metoder og pseudokode er en god måde hurtigt at styrke gennem enhver udfordrende programmeringsopgave.

Brug metoder til at strukturere kode

Forestil dig, at du er kandidat i et kodningsinterview. Intervieweren vil gerne have, at du skriver et program, der kontrollerer, om en IPv4-adresse er gyldig eller ugyldig. Du får følgende regler:

En gyldig IPv4-adresse består af fire tal adskilt af prikker
Hvert tal må ikke indeholde foranstillede nuller
Hvert tal skal være mellem 0 og 255

1.1.1.1 og 255.255.255.255 er eksempler på gyldige IP-adresser.

IPv4-adressen angives som en streng. Du kan antage, at den kun består af cifre og prikker (der er ingen bogstaver i den angivne streng).

Hvordan vil du nærme dig denne opgave?

Seddel

Selvom du ikke kender IP-adresser, skal du ikke bekymre dig! Du kan stadig fuldføre koden i denne øvelse ved at følge trinnene.

Opdel problemet

I denne opgave skal du identificere de trin, der er nødvendige for at løse problemet. Hvis du ser nærmere på reglerne, kan du se, at det kun tager tre trin at afgøre, om en IPv4-adresse er gyldig eller ej.

Slet eventuel eksisterende kode fra de forrige øvelser i Visual Studio Code Editor.
Angiv følgende pseudokode i editoren:
```
/*
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
*/
```
Pseudo-kode er en god måde at begynde at løse ethvert problem på. Ved hjælp af denne kommentarblok kan du bygge bro mellem promptreglerne og programkoden, hvilket tydeliggør de vigtigste opgaver, som din kode vil udføre. Pseudokode behøver ikke at være funktionel eller overholde syntaksregler, men det skal være en klar forklaring på, hvad koden vil gøre. Lad os nu forvandle dette til ægte kode!
Angiv en ny tom kodelinje, og skriv derefter følgende kode i Editor:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
I dette trin skal du transformere if-sætninger fra din pseudokode til kaldbare metoder og sende resultaterne. Du skal ikke bekymre dig om at definere metoderne endnu. du kan antage, at hver metode udfører den opgave, som dens navn beskriver. Du skal snart rette kompileringsfejlene og oprette metodelogikken, men fokusere på det store billede indtil videre. Når du begynder at arbejde på et nyt program, hjælper fokus på det overordnede design dig med at holde styr på og udvikle dit program hurtigere.
Angiv en ny tom kodelinje under den eksisterende kode, og skriv derefter følgende kode i Editor:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Bemærk, hvordan brug af pladsholdermetoder gav dig mulighed for hurtigt at gribe problemet an og strukturere din kode for at udvikle løsningen. Nu, hvor du har en struktureret plan på plads, kan du fortsætte med at løse problemet ved at udfylde kodestykket for stykke.

Udvikl din løsning

Nu, hvor du har alle de pladsholdermetoder, der er nødvendige for at løse problemet, kan du begynde at fokusere på detaljerne i din løsning. Vær opmærksom på, at inputformatet for IPv4-adressen vil være en streng, der består af cifre adskilt af prikker. Lad os komme i gang!

I starten af dit program skal du oprette variabler for at gemme input- og valideringsstatusser:

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

Opdater din løsningskode for at bruge valideringsvariabler på følgende måde:

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

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

Opdater metoden ValidateLength på følgende måde:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
Den første regel angiver, at IPv4-adressen skal have fire tal. Så i denne kode bruger du string.Split til at adskille cifrene og kontrollere, at der er fire af dem.
Opdater metoden ValidateZeroes på følgende måde:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

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

    validZeroes = true;
}
```
Brug et øjeblik på at overveje, hvordan reglen oversættes til kode.

Den anden regel angiver, at tallene i IPv4-adressen ikke må indeholde foranstillede nuller. Metoden skal derfor kontrollere tal for foranstillede nuller, samtidig med at 0 accepteres som et gyldigt tal. Hvis alle tallene har gyldige nuller, skal validZeroes være lig med true, og false ellers. Så i denne kode skal du kontrollere, at hvert tal med mere end ét ciffer ikke starter med et nul.

Hvis du ser nøje efter, kan du se, at validZeroes er angivet til true, når den foreach løkke er fuldført. Du vil dog kun angive validZeroes til true, hvis der ikke findes foranstillede nuller. Du kan rette denne fejl ved at angive validZeroes = true, før foreach-løkken kører. Du kan dog også rette denne fejl ved hjælp af en returnere-sætning.
Opdater din kode til følgende:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
Den returnerer-sætningen afslutter udførelsen af metoden og returnerer kontrolelementet til method caller. Tilføjelse af en return-sætning, når validZeroes = false afslutter metoden, når det første ugyldige nul er fundet. Hvis der ikke findes et ugyldigt nul, afsluttes metoden, når validZeroes er angivet til true. Lad os gå videre til den næste metode.
Opdater metoden ValidateRange på følgende måde:
```
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;
}
```
Den tredje regel angiver, at hvert tal i IPv4-adressen skal være mellem 0 og 255. Så i denne kode skal du kontrollere, at hvert tal er mindre end 255, og hvis ikke, skal du afslutte udførelsen efter at have angivet validRange til false. Da inputstrengen kun indeholder cifre og prikker, behøver du ikke at kontrollere, om der er negative tal.

Der kan dog være et tilfælde, hvor der ikke er nogen cifre mellem prikker. For eksempel "255...255". I dette tilfælde returnerer string.Split(".") tomme poster, hvilket medfører, at int.Parse mislykkes. Du kan forhindre dette ved at angive StringSplitOptions.
Opdater din kode på følgende måde:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
Brug StringSplitOptions.RemoveEmptyEntries udelader tomme poster fra matrixen address og forhindrer forsøg på at fortolke tomme strenge.

Fuldfør din løsning

Nu, hvor du har fuldført alle metoderne for at validere en IP-adresse, er det tid til at vende tilbage til din oprindelige løsning. I denne opgave skal du tilføje flere inputværdier og forberede dig på at teste din kode.

Find følgende kode, du skrev tidligere i programmet:
```
string ipv4Input = "107.31.1.5";
```
Opdater koden på følgende måde:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Når du udvikler en løsning, er det vigtigt at teste din kode med forskellige inputcases. I denne kode angiver du et anstændigt interval af testværdier. Nu, hvor du har opdateret dit testinput, skal du opdatere din kode for at bruge de nye værdier. Da værdierne er i en matrix, skal du opdatere din kode for at teste hver enkelt ved hjælp af en løkke.

Opdater din kode på følgende måde:

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

Endelig skal du rette de inputdata, som hver metode bruger, siden du opdaterede ipv4Input fra en streng til en matrix. Da hver metode bruger string.Split, kan du deklarere en variabel for at gemme resultatet af string.Split og bruge den i hver metode i stedet.

Tilføj en variabel for at gemme den aktuelle IPv4-adresse, som hver metode refererer til:

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;

Initialiser address ved hjælp af string.Split på følgende måde:

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

Fjern referencer til string.Split fra hver af valideringsmetoderne, så de i stedet bruger variablen global address. For eksempel:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Kontrollér dit arbejde

I denne opgave skal du køre dit program fra den integrerede terminal og kontrollere, at din kode fungerer korrekt. Lad os komme i gang.

Sammenlign din kode med følgende for at sikre, at den er korrekt:

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

Gem dit arbejde ved hjælp af Ctrl + S eller ved hjælp af menuen Filer i Visual Studio Code.
Åbn om nødvendigt Visual Studio Codes integrerede terminalpanel.

Højreklik på TestProjecti panelet EXPLORER for at åbne en Terminal på mappen TestProject, og vælg derefter Åbn i integreret terminal.
I kommandoprompten Terminal skal du angive dotnetkørsel
Kontrollér, at din kode producerer følgende output:
```
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
```
Hvis din kode viser forskellige resultater, skal du gennemse din kode for at finde fejlen og foretage opdateringer. Kør koden igen for at se, om du har løst problemet. Fortsæt med at opdatere og køre din kode, indtil din kode giver de forventede resultater.

Resumé

Her er, hvad du har lært om at bruge metoder indtil videre:

Metoder kan bruges til hurtigt at strukturere programmer
Nøgleordet return kan bruges til at afslutte udførelsen af metoden
Hvert trin i et problem kan ofte oversættes til sin egen metode
Brug metoder til at løse små problemer for at opbygge din løsning

Feedback

Var denne side nyttig?