Exerciții - Generare cod cu metode

10 minute

Metodele sunt utile pentru organizarea codului, reutilizarea codului și pentru abordarea eficientă a problemelor. Vă puteți gândi la o metodă precum o casetă neagră care preia intrări, efectuează activitatea numită și returnează rezultatul. Cu această presupunere, puteți structura rapid programele pur și simplu numindu-vă activitățile ca metode, apoi completând logica după ce ați identificat toate activitățile necesare.

Atunci când utilizați un limbaj simplu pentru a descrie pașii din cod, fără a respecta strict regulile de sintaxă, utilizați "pseudo-cod". Combinarea metodelor și a pseudo-codului este o modalitate foarte bună de a alimenta rapid orice activitate de programare dificilă.

Utilizarea metodelor de structurare a codului

Să presupunem că ești candidat într-un interviu de codificare. Intervievatorul vrea să scrie un program care verifică dacă o adresă IPv4 este validă sau nevalidă. Vi se oferă următoarele reguli:

O adresă IPv4 validă constă din patru numere separate prin puncte
Fiecare număr nu trebuie să conțină zerouri inițiale
Fiecare număr trebuie să fie cuprins între 0 și 255

1.1.1.1 și 255.255.255.255 sunt exemple de adrese IP valide.

Adresa IPv4 este furnizată ca șir. Puteți presupune că este format doar din cifre și puncte (nu există litere în șirul furnizat).

Cum vă apropiați de această activitate?

Notă

Chiar dacă nu sunteți familiarizat cu adresele IP, nu vă faceți griji! Puteți finaliza în continuare codul în acest exercițiu, urmând pașii.

Împărțiți problema

În această activitate, veți identifica pașii necesari pentru a rezolva problema. Dacă vă uitați atent la reguli, este posibil să vă dați seama că durează doar trei pași pentru a determina dacă o adresă IPv4 este validă sau nu.

În Visual Studio Code Editor, ștergeți orice cod existent din exercițiile anterioare.
Introduceți următorul pseudo-cod în Editor:
```
/*
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-codul este o modalitate foarte bună de a începe să rezolvați orice problemă. Utilizând acest bloc de comentarii, reduceți decalajul dintre regulile de solicitare și codul programului, clarificând activitățile majore pe care le va efectua codul dvs. Pseudo-codul nu trebuie să fie funcțional sau să respecte regulile de sintaxă, însă ar trebui să fie o explicație clară a ceea ce va face codul. Acum să transformăm asta în cod real!
Introduceți o nouă linie de cod necompletată, apoi tastați următorul cod în Editor:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
În acest pas, transformați instrucțiunile if din pseudo-cod în metode apelabile și obțineți rezultatele. Nu vă faceți griji în legătură cu definirea metodelor încă; puteți presupune că fiecare metodă efectuează activitatea pe care o descrie numele său. Veți remedia erorile de compilare și veți crea logica metodei în curând, dar vă veți concentra pe imaginea de ansamblu pentru moment. Când începeți să lucrați la un program nou, concentrarea asupra proiectării generale vă ajută să rămâneți organizat și să dezvoltați mai rapid aplicația.
Introduceți o nouă linie de cod necompletată sub codul existent, apoi tastați următorul cod în Editor:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Observați cum utilizarea metodelor substituent vă permite să abordați rapid problema și să structurați codul pentru a dezvolta soluția. Acum că aveți un plan structurat pe loc, puteți continua să rezolvați problema completând fragmentul de cod.

Dezvoltați-vă soluția

Acum că aveți toate metodele substituent necesare pentru a rezolva problema, puteți începe să vă concentrați asupra detaliilor soluției. Rețineți că formatul de intrare al adresei IPv4 va fi un șir format din cifre separate prin puncte. Să începem!

La începutul programului, creați variabile pentru a stoca stările de intrare și validare:

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

Actualizați codul soluției pentru a utiliza variabilele de validare după cum urmează:

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

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

Actualizați metoda ValidateLength după cum urmează:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
Prima regulă spune că adresa IPv4 trebuie să aibă patru numere. Prin urmare, în acest cod, utilizați string.Split pentru a separa cifrele și a verifica dacă există patru dintre ele.
Actualizați metoda ValidateZeroes după cum urmează:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

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

    validZeroes = true;
}
```
Luați un moment pentru a lua în considerare modul în care regula se traduce în cod.

A doua regulă menționează că numerele din adresa IPv4 nu trebuie să conțină zerouri inițiale. Așadar, metoda trebuie să verifice numerele pentru zerourile inițiale în timp ce acceptă 0 ca număr valid. Dacă toate numerele au zerouri valide, validZeroes trebuie să fie egale cu trueși false altfel. Așadar, în acest cod, verificați dacă fiecare număr cu mai multe cifre nu începe cu un zero.

Dacă vă uitați atent, veți observa că validZeroes este setată să true după ce se termină bucla de foreach. Cu toate acestea, doriți să setați validZeroes să true dacă nu se găsește zerouri inițiale. Puteți corecta această eroare setând validZeroes = true înainte de rulează bucla de foreach. Totuși, puteți corecta această eroare și utilizând o instrucțiune de returnare a .
Actualizați codul la următoarele:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
Instrucțiunea returnează încheie executarea metodei și returnează controlul apelantului metodei. Adăugarea unei instrucțiuni de return după ce validZeroes = false închide metoda după ce se găsește primul zero nevalid. Dacă nu se găsește niciun zero nevalid, metoda se va termina după setarea validZeroes la true. Să trecem la următoarea metodă.
Actualizați metoda ValidateRange după cum urmează:
```
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;
}
```
Regula terță menționează că fiecare număr din adresa IPv4 trebuie să fie cuprins între 0 și 255. Prin urmare, în acest cod, verificați că fiecare număr este mai mic de 255 și, dacă nu, opriți executarea după setarea validRange să false. Deoarece șirul de intrare conține doar cifre și puncte, nu trebuie să verificați numerele negative.

Totuși, poate exista un caz în care nu sunt prezente cifre între puncte. De exemplu, "255...255". În acest caz, string.Split(".") ar returna intrări goale, cauzând ca int.Parse să nu reușească. Puteți preveni acest lucru specificând StringSplitOptions.
Actualizați codul după cum urmează:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
Utilizarea StringSplitOptions.RemoveEmptyEntries omite intrările goale din matricea address și împiedică încercările de analiză a șirurilor goale.

Finalizați soluția

Acum, că aveți toate metodele finalizate pentru a valida o adresă IP, este timpul să revizuiți soluția inițială. În această activitate, veți adăuga mai multe valori de intrare și veți fi pregătit să testați codul.

Găsiți următorul cod pe care l-ați scris anterior în program:
```
string ipv4Input = "107.31.1.5";
```
Actualizați codul după cum urmează:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Atunci când dezvoltați o soluție, este important să testați codul cu diferite cazuri de intrare. În acest cod, furnizați un interval decent de valori de test. Acum, că ați actualizat intrarea de test, va trebui să actualizați codul pentru a utiliza noile valori. Deoarece valorile se află într-o matrice, va trebui să actualizați codul pentru a le testa pe fiecare utilizând o buclă.
Actualizați codul după cum urmează:
```
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");
    }
}
```
În sfârșit, trebuie să remediați datele de intrare utilizate de fiecare metodă, deoarece ați actualizat ipv4Input dintr-un șir într-o matrice. Deoarece fiecare metodă utilizează string.Split, puteți declara o variabilă pentru a stoca rezultatul string.Split și a-l utiliza în fiecare metodă.

Adăugați o variabilă pentru a stoca adresa IPv4 curentă la care va face referire fiecare metodă:

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;

Inițializați address utilizând string.Split după cum urmează:

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

Eliminați referințele la string.Split din fiecare dintre metodele de validare, astfel încât să utilizeze variabila globală address. De exemplu:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Verificați-vă lucrul

În această activitate, veți rula aplicația de la Terminalul integrat și veți verifica dacă codul funcționează corect. Să începem.

Comparați codul cu următoarele pentru a vă asigura că este corect:

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

Salvați lucrul utilizând Ctrl + S sau utilizând meniul Fișier de cod Visual Studio.
Dacă este necesar, deschideți panoul Terminal integrat visual Studio Code.

În panoul EXPLORER, pentru a deschide un Terminal la locația folderului TestProject, faceți clic dreapta pe TestProject, apoi selectați Deschidere în terminal integrat.
În linia de comandă Terminal, introduceți run dotnet
Verificați dacă codul dvs. generează următoarea ieșire:
```
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
```
Dacă codul afișează rezultate diferite, va trebui să revizuiți codul pentru a găsi eroarea și a face actualizări. Rulați codul din nou pentru a vedea dacă ați remediat problema. Continuați actualizarea și rularea codului până când codul produce rezultatele așteptate.

Recapitula

Iată ce ați învățat despre utilizarea metodelor de până acum:

Metodele pot fi utilizate pentru a structura rapid aplicațiile
Cuvântul cheie return poate fi utilizat pentru a termina executarea metodei
Fiecare pas al unei probleme poate fi tradus adesea în propria metodă
Utilizați metode pentru a rezolva mici probleme pentru a construi soluția

Feedback

Această pagină a fost utilă?