Exercício - Criar código com métodos

10 minutos

Os métodos são úteis para organizar código, reutilizar código e resolver problemas de forma eficiente. Você pode pensar em um método como uma caixa preta que recebe 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, em seguida, preenchendo a lógica depois de identificar todas as tarefas necessárias.

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

Usar métodos para estruturar o código

Suponha que você seja um candidato em uma entrevista de programação. O entrevistador quer 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 pontos
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 pontos (não há letras na cadeia de caracteres fornecida).

Como abordaria esta tarefa?

Nota

Mesmo que 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.

Decomponha o problema

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

No Editor de Códigos do Visual Studio, exclua qualquer código existente dos exercícios anteriores.
Insira 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
*/
```
O pseudocódigo é uma ótima maneira de começar a resolver qualquer problema. Usando este bloco de comentários, você preenche a lacuna 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 aderir às 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 if instruções do seu pseudocódigo em métodos chamáveis e produz os resultados. Não se preocupe em definir os métodos ainda; Você pode supor que cada método executa a tarefa descrita pelo nome. Você corrigirá os erros de compilação e criará a lógica do método em breve, mas se concentrará no panorama 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 abordar rapidamente o problema e estruturar seu código para desenvolver a solução. Agora que você tem um plano estruturado, você pode continuar a resolver o problema preenchendo o código peça por peça.

Desenvolva a sua solução

Agora que você tem todos os métodos de espaço reservado necessários para resolver o problema, você pode começar a se concentrar nos detalhes da sua solução. Tenha em mente que o formato de entrada do endereço IPv4 será uma cadeia de caracteres composta por 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 ValidateLength método da seguinte maneira:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
A primeira regra estabelece que o endereço IPv4 precisa ter quatro números. Então, neste código, você usa string.Split para separar os dígitos e verificar se há quatro deles.
Atualize o ValidateZeroes método 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;
}
```
Reserve um momento para considerar como a regra se traduz em código.

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

Se você olhar com atenção, notará que está definido para validZeroes depois que true o foreach loop for concluído. No entanto, você só deseja definir validZeroes como true se nenhum zeros à esquerda for encontrado. Você pode corrigir esse bug definindo validZeroes = true antes que o foreach loop 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 return instrução depois validZeroes = false encerra o método depois que o primeiro zero inválido é encontrado. Se nenhum zero inválido for encontrado, o método será encerrado após a configuração validZeroes como true. Vamos passar para o próximo método.
Atualize o ValidateRange método 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 estabelece que cada número no endereço IPv4 deve variar de 0 a 255. Portanto, neste código, você verifica se cada número é menor que 255 e, se não, encerra a execução após a configuração validRange como false. Como a cadeia de caracteres de entrada contém apenas dígitos e pontos, não é necessário 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". Neste caso, string.Split(".") retornaria entradas vazias, causando int.Parse a falha. Você pode evitar isso especificando StringSplitOptions.
Atualize o seu código da seguinte forma:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
O uso StringSplitOptions.RemoveEmptyEntries omite entradas vazias da address matriz e impede tentativas de analisar cadeias de caracteres vazias.

Complete a sua solução

Agora que você tem todos os métodos concluídos para validar um endereço IP, é hora de rever 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 forma:
```
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. Neste 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 o seu código da seguinte forma:
```
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.Splito , você pode declarar uma variável para armazenar o resultado e string.Split usá-lo em cada método.

Adicione uma variável para armazenar o endereço IPv4 atual que cada método fará referência:

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 o seguinte:

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

Remova as referências de string.Split 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;
};
```

Verifique o seu trabalho

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

Compare seu 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 seu trabalho usando Ctrl + S ou usando o menu Arquivo de código do Visual Studio.
Se necessário, abra o painel Terminal integrado do Visual Studio Code.

No painel EXPLORER, para abrir um 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 do Terminal, digite 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 apresentar resultados diferentes, terá de rever 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 seu código até que seu código produza os resultados esperados.

Recapitulação

Aqui está o que você aprendeu sobre o uso de métodos até agora:

Os métodos podem ser usados para estruturar aplicações rapidamente
A return palavra-chave pode ser usada para encerrar a execução do método
Cada passo de um problema pode muitas vezes ser traduzido no seu próprio método
Use métodos para resolver pequenos problemas para construir sua solução

Comentários

Esta página foi útil?