Esercizio - Compilare codice con i metodi

10 minuti

I metodi sono utili per organizzare il codice, riutilizzare il codice e per affrontare in modo efficiente i problemi. È possibile pensare a un metodo come a una black box che accetta l'input, esegue l'attività denominata e restituisce l'output. Con questo presupposto, è possibile strutturare rapidamente i programmi semplicemente assegnando un nome alle attività come metodi e quindi compilando la logica dopo aver identificato tutte le attività necessarie.

Quando si usa il linguaggio normale per descrivere i passaggi nel codice, senza attenersi rigorosamente alle regole di sintassi, si usa "pseudocodice". La combinazione di metodi e pseudocodice è un ottimo modo per alimentare rapidamente qualsiasi attività di programmazione complessa.

Usare metodi per strutturare il codice

Si supponga di essere un candidato in un colloquio di scrittura del codice. L'intervistatore vuole scrivere un programma che controlla se un indirizzo IPv4 è valido o non valido. Vengono fornite le regole seguenti:

Un indirizzo IPv4 valido è costituito da quattro numeri separati da punti
Ogni numero non deve contenere zeri iniziali
Ogni numero deve essere compreso tra 0 e 255

1.1.1.1 e 255.255.255.255 sono esempi di indirizzi IP validi.

L'indirizzo IPv4 viene fornito come stringa. Si può presupporre che sia costituito solo da cifre e punti (non sono presenti lettere nella stringa specificata).

Come si può affrontare questa attività?

Nota

Anche se non si ha familiarità con gli indirizzi IP, non c’è da preocupparsi! È comunque possibile completare il codice in questo esercizio seguendo i passaggi.

Analizzare il problema

In questa attività verranno identificati i passaggi necessari per risolvere il problema. Se si esaminano attentamente le regole, è possibile rendersi conto che sono necessari solo tre passaggi per determinare se un indirizzo IPv4 è valido o meno.

Nell'editor di Visual Studio Code eliminare qualsiasi codice esistente dagli esercizi precedenti.
Immettere lo pseudocodice seguente nell'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
*/
```
Lo pseudocodice è un ottimo modo per iniziare ad affrontare qualsiasi problema. Usando questo blocco di commenti, è possibile colmare il divario tra le regole di richiesta e il codice del programma, chiarendo le attività principali che verranno eseguite dal codice. Lo pseudocodice non deve essere funzionale o conforme alle regole di sintassi, ma deve essere una spiegazione chiara delle operazioni che il codice eseguirà. Ora bisogna trasformarlo in un vero codice!
Immettere una nuova riga di codice vuota, quindi digitare il codice seguente nell'editor:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
In questo passaggio si trasformano le istruzioni if dallo pseudocodice in metodi chiamabili e vengono restituiti i risultati. Non è necessario preoccuparsi ancora di definire i metodi; è possibile presupporre che ogni metodo esegua la descrizione dell'attività. Si correggeranno gli errori di compilazione e si creerà presto la logica del metodo, ma ci si concentrerà sul quadro generale per il momento. Quando si inizia a lavorare su un nuovo programma, concentrarsi sulla progettazione complessiva consente di rimanere organizzati e sviluppare l'applicazione più velocemente.
Immettere una nuova riga di codice vuota sotto il codice esistente, quindi digitare il codice seguente nell'editor:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Si noti che l'uso di metodi segnaposto consente di affrontare rapidamente il problema e strutturare il codice per sviluppare la soluzione. Ora che è disponibile un piano strutturato, è possibile continuare a risolvere il problema compilando il codice frammento per frammento.

Sviluppare la soluzione

Ora che sono disponibili tutti i metodi segnaposto necessari per risolvere il problema, è possibile iniziare a concentrarsi sui dettagli della soluzione. Tenere presente che il formato di input dell'indirizzo IPv4 sarà una stringa costituita da cifre separate da punti. Iniziamo!

All'inizio del programma creare variabili per archiviare gli stati di input e convalida:

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

Aggiornare il codice della soluzione per usare le variabili di convalida come indicato di seguito:

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

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

Aggiornare il metodo ValidateLength come segue:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
La prima regola indica che l'indirizzo IPv4 deve avere quattro numeri. Quindi, in questo codice si usano string.Split per separare le cifre e verificare che ci siano quattro di esse.
Aggiornare il metodo ValidateZeroes come segue:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

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

    validZeroes = true;
}
```
Prendere in considerazione il modo in cui la regola viene convertita nel codice.

La seconda regola indica che i numeri nell'indirizzo IPv4 non devono contenere zeri iniziali. Pertanto, il metodo deve controllare i numeri per verificare che non siano presenti zeri iniziali durante l'accettazione di 0 come numero valido. Se tutti i numeri hanno zeri validi, validZeroes deve essere uguale a true e in caso contrario a false. In questo codice si verifica quindi che ogni numero con più di una cifra non inizi con zero.

Se si osserva attentamente, si noterà che validZeroes è impostato su true dopo il completamento del ciclo foreach. Tuttavia, si vuole impostare validZeroes su true solo se non vengono trovati zeri iniziali. È possibile correggere questo bug impostando validZeroes = true prima dell'esecuzione del ciclo foreach. Tuttavia, è anche possibile correggere questo bug usando un'istruzione return .
Aggiornare il codice come segue:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
L'istruzione return termina l'esecuzione del metodo e restituisce il controllo al chiamante del metodo. L'aggiunta di un'istruzione return dopo validZeroes = false termina il metodo dopo che è stato trovato il primo zero non valido. Se non viene trovato alcuno zero non valido, il metodo termina dopo aver impostato validZeroes su true. Si passerà ora al metodo successivo.
Aggiornare il metodo ValidateRange come segue:
```
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;
}
```
La terza regola indica che ogni numero nell'indirizzo IPv4 deve essere compreso tra 0 e 255. In questo codice si verifica quindi che ogni numero sia minore di 255 e, in caso contrario, si termina l'esecuzione dopo aver impostato validRange su false. Poiché la stringa di input contiene solo cifre e punti, non è necessario verificare la presenza di numeri negativi.

Tuttavia, potrebbe verificarsi un caso in cui non siano presenti cifre tra i punti. Ad esempio, "255...255". In questo caso, string.Split(".") restituirà voci vuote, causando l'errore di int.Parse. È possibile evitare questo problema specificando StringSplitOptions.
Aggiornare il codice come segue:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
L'uso di StringSplitOptions.RemoveEmptyEntries omette le voci vuote dalla matrice address e impedisce i tentativi di analizzare stringhe vuote.

Completare la soluzione

Dopo aver completato tutti i metodi per convalidare un indirizzo IP, è possibile rivedere la soluzione iniziale. In questa attività si aggiungeranno altri valori di input e ci si preparerà a testare il codice.

Individuare il codice seguente scritto in precedenza nel programma:
```
string ipv4Input = "107.31.1.5";
```
Aggiornare il codice come segue:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Quando si sviluppa una soluzione, è importante testare il codice con casi di input diversi. In questo codice viene fornito un intervallo decente di valori di test. Dopo aver aggiornato l'input di test, è necessario aggiornare il codice per usare i nuovi valori. Poiché i valori si trovano in una matrice, è necessario aggiornare il codice per testarne ognuno usando un ciclo.

Aggiornare il codice come segue:

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

Infine, è necessario correggere i dati di input usati da ogni metodo dopo l'aggiornamento di ipv4Input da una stringa a una matrice. Poiché ogni metodo usa string.Split, è possibile dichiarare una variabile per archiviare il risultato di string.Split e usarlo in ogni metodo.

Aggiungere una variabile per archiviare l'indirizzo IPv4 corrente a cui farà riferimento ogni metodo:

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;

Inizializzare address usando string.Split come segue:

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

Rimuovere i riferimenti a string.Split da ognuno dei metodi di convalida in modo che usino la variabile globale address. Ad esempio:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Controllare il lavoro svolto

In questa attività si eseguirà l'applicazione dal terminale integrato e si verificherà che il codice funzioni correttamente. Iniziamo.

Confrontare il codice con quanto segue per assicurarsi che sia corretto:

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

Salvare il lavoro usando CTRL + S o il menu File di Visual Studio Code.
Se necessario, aprire il pannello Terminale integrato di Visual Studio Code.

Nel pannello EXPLORER, per aprire un terminale nel percorso della cartella TestProject, fare clic con il pulsante destro del mouse su TestProject e quindi scegliere Apri nel terminale integrato.
Al prompt dei comandi del terminale immettere dotnet run
Verificare che il codice produca l'output seguente:
```
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
```
Se il codice visualizza risultati diversi, è necessario esaminarlo per trovare l'errore e apportare aggiornamenti. Eseguire di nuovo il codice per verificare se il problema è stato risolto. Continuare ad aggiornare ed eseguire il codice fino a quando non produce i risultati previsti.

Riepilogo

Ecco quanto appreso finora sull'uso dei metodi:

I metodi possono essere usati per strutturare rapidamente le applicazioni
La parola chiave return può essere usata per terminare l'esecuzione del metodo
Ogni passaggio di un problema spesso può essere convertito nel proprio metodo
Usare i metodi per risolvere piccoli problemi per creare la soluzione

Commenti e suggerimenti

Questa pagina è stata utile?