Exercício – Compilar código com métodos

10 minutos

Os métodos são úteis para organizar código, reutilizar código e lidar com problemas com eficiência. Você pode pensar em um método como uma caixa preta que usa entrada, executa a tarefa nomeada e retorna a saída. Com essa suposição, você pode estruturar programas rapidamente apenas nomeando suas tarefas como métodos e preenchendo a lógica depois de identificar todas as tarefas necessárias.

Quando você usa linguagem simples para descrever as etapas no código, sem aderir estritamente às regras de sintaxe, você está usando "pseudocódigo". Combinar métodos e pseudocódigo é uma ótima maneira de impulsionar rapidamente qualquer tarefa de programação complicada.

Usar métodos para estruturar código

Vamos supor que você seja um candidato em uma entrevista de codificação. O entrevistador deseja que você escreva um programa que verifique se um endereço IPv4 é válido ou inválido. Você recebe as seguintes regras:

Um endereço IPv4 válido consiste em quatro números separados por ponto
Cada número não deve conter zeros à esquerda
Cada número deve variar de 0 a 255

1.1.1.1 e 255.255.255.255 são exemplos de endereços IP válidos.

O endereço IPv4 é fornecido como uma cadeia de caracteres. Você pode supor que ele consiste apenas em dígitos e ponto (não há letras na cadeia de caracteres fornecida).

Como você abordaria essa tarefa?

Observação

Mesmo que você não esteja familiarizado com endereços IP, não se preocupe! Você ainda pode concluir o código neste exercício seguindo as etapas.

Dividir o problema

Nesta tarefa, você identificará as etapas necessárias para resolver o problema. Se você examinar de perto as regras, poderá perceber que são necessárias apenas três etapas para determinar se um endereço IPv4 é válido ou não.

No Editor do Visual Studio Code, exclua qualquer código existente dos exercícios anteriores.
Digite o seguinte pseudocódigo no 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
*/
```
Pseudocódigo é uma ótima maneira de começar a lidar com qualquer problema. Usando esse bloco de comentários, você faz a ponte entre as regras de prompt e o código do programa, esclarecendo as principais tarefas que seu código executará. O pseudocódigo não precisa ser funcional ou seguir as regras de sintaxe; no entanto, deve ser uma explicação clara do que o código fará. Agora vamos transformar isso em código real!
Insira uma nova linha de código em branco e digite o seguinte código no Editor:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
Nesta etapa, você transforma as instruções if de seu pseudocódigo em métodos chamáveis e gera os resultados. Não se preocupe em definir os métodos ainda; você pode supor que cada método executa a tarefa que seu nome descreve. Você corrigirá os erros de compilação e criará a lógica do método em breve, mas se concentre no quadro geral por enquanto. Quando você começa a trabalhar em um novo programa, focar no design geral ajuda você a se manter organizado e desenvolver seu aplicativo mais rapidamente.
Insira uma nova linha de código em branco abaixo do código existente e digite o seguinte código no editor:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Observe como o uso de métodos de espaço reservado permitiu que você abordasse rapidamente o problema e estruturasse seu código para desenvolver a solução. Agora que você tem um plano estruturado, pode continuar a resolver o problema preenchendo o código.

Desenvolver sua solução

Agora que você tem todos os métodos de espaço reservado necessários para resolver o problema, comece a se concentrar nos detalhes da solução. Tenha em mente que o formato de entrada do endereço IPv4 será uma cadeia de caracteres que consiste em dígitos separados por pontos. Vamos começar!

No início do programa, crie variáveis para armazenar os status de entrada e validação:

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

Atualize o código da solução para usar as variáveis de validação da seguinte maneira:

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

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

Atualize o método ValidateLength da seguinte maneira:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
A primeira regra afirma que o endereço IPv4 precisa ter quatro números. Portanto, nesse código, você usa string.Split para separar os dígitos e verificar se há quatro deles.
Atualize o método ValidateZeroes da seguinte maneira:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

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

    validZeroes = true;
}
```
Dedique um momento para pensar como a regra se traduz em código.

A segunda regra afirma que os números no endereço IPv4 não devem conter zeros à esquerda. Portanto, o método precisa verificar números para zeros à esquerda ao aceitar 0 como um número válido. Se todos os números tiverem zeros válidos, validZeroes deverá ser igual a true e false, caso contrário. Portanto, nesse código, você verifica se cada número com mais de um dígito não começa com um zero.

Se você olhar atentamente, observará que validZeroes está definido como true após a conclusão do loop foreach. No entanto, você só deseja definir validZeroes como true se nenhum zero à esquerda for encontrado. Você pode corrigir esse bug definindo validZeroes = true antes que o loop foreach seja executado. No entanto, você também pode corrigir esse bug usando uma instrução return.
Atualize seu código para o seguinte:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
A instrução return encerra a execução do método e retorna o controle para o chamador do método. Adicionar uma instrução return depois de validZeroes = false encerra o método depois que o primeiro zero inválido for encontrado. Se nenhum zero inválido for encontrado, o método será encerrado após a configuração de validZeroes como true. Vamos passar para o próximo método.
Atualize o método ValidateRange da seguinte maneira:
```
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;
}
```
A terceira regra afirma que cada número no endereço IPv4 deve variar de 0 a 255. Portanto, nesse código, você verifica se cada número é menor que 255 e, caso contrário, encerre a execução após definir validRange como false. Como a cadeia de caracteres de entrada contém apenas dígitos e pontos, você não precisa verificar se há números negativos.

No entanto, pode haver um caso em que nenhum dígito esteja presente entre os pontos. Por exemplo, "255...255". Nesse caso, string.Split(".") retornaria entradas vazias, causando falha em int.Parse. Você pode impedir isso especificando StringSplitOptions.
Atualize seu código desta maneira:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
O uso de StringSplitOptions.RemoveEmptyEntries omite entradas vazias da matriz address e impede tentativas de analisar cadeias de caracteres vazias.

Concluir sua solução

Agora que você tem todos os métodos concluídos para validar um endereço IP, é hora de revisitar sua solução inicial. Nesta tarefa, você adicionará mais valores de entrada e se preparará para testar seu código.

Localize o seguinte código que você escreveu anteriormente no programa:
```
string ipv4Input = "107.31.1.5";
```
Atualize o código da seguinte maneira:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Ao desenvolver uma solução, é importante testar seu código com diferentes casos de entrada. Nesse código, você fornece um intervalo decente de valores de teste. Agora que você atualizou sua entrada de teste, precisará atualizar seu código para usar os novos valores. Como os valores estão em uma matriz, você precisará atualizar seu código para testar cada um usando um loop.
Atualize seu código desta maneira:
```
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");
    }
}
```
Por fim, você precisa corrigir os dados de entrada que cada método usa desde que você atualizou ipv4Input de uma cadeia de caracteres para uma matriz. Como cada método usa string.Split, você pode declarar uma variável para armazenar o resultado de string.Split e usá-lo em cada método.

Adicione uma variável para armazenar o endereço IPv4 atual que cada método referenciará:

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;

Inicialize address usando string.Split da seguinte maneira:

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

Remova referências a string.Split de cada um dos métodos de validação para que eles usem a variável global address. Por exemplo:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Verificar seu trabalho

Nesta tarefa, você executará o aplicativo no Terminal Integrado e verificará se o código está funcionando corretamente. Vamos começar.

Compare o código com o seguinte para garantir que ele esteja correto:

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

Salve o trabalho usando Ctrl + S ou usando o menu Arquivo no Visual Studio Code.
Se necessário, abra o painel Terminal Integrado do Visual Studio Code.

No painel EXPLORER, para abrir o Terminal no local da pasta TestProject, clique com o botão direito do mouse em TestProject e selecione Abrir no Terminal Integrado.
No prompt de comando Terminal, insira dotnet run
Verifique se o código produz a seguinte saída:
```
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 o código exibir resultados diferentes, você precisará examinar o código para encontrar o erro e fazer atualizações. Execute o código novamente para ver se você corrigiu o problema. Continue atualizando e executando o código até que ele produza os resultados esperados.

Recapitulação

Aqui está o que você aprendeu sobre como usar métodos até agora:

Os métodos podem ser usados para estruturar aplicativos rapidamente
A palavra-chave return pode ser usada para encerrar a execução do método
Cada etapa de um problema geralmente pode ser convertida em seu próprio método
Usar métodos para resolver pequenos problemas para criar sua solução

Comentários

Esta página foi útil?