Ejercicio: Compilar código con métodos

10 minutos

Los métodos son útiles para organizar el código, reutilizarlo y abordar los problemas de un modo eficiente. Se puede decir que un método es como una caja negra que toma la entrada, realiza la tarea con nombre y devuelve la salida. Con esta suposición, puede estructurar rápidamente los programas simplemente asignando un nombre a las tareas como métodos y rellenando la lógica después de haber identificado todas las tareas necesarias.

Cuando se usa lenguaje sin formato para describir pasos en el código sin cumplir estrictamente las reglas de sintaxis, se usa "pseudocódigo". Combinar métodos y pseudocódigo es una excelente manera de impulsar rápidamente cualquier tarea de programación compleja.

Uso de métodos para estructurar código

Supongamos que es un candidato en una entrevista para un puesto de programador. El entrevistador quiere que escriba un programa que compruebe si una dirección IPv4 es válida o no. Se le dan las siguientes reglas:

Una dirección IPv4 válida consta de cuatro números separados por puntos.
Cada número no debe contener ceros iniciales.
Cada número debe oscilar entre 0 y 255.

1.1.1.1 y 255.255.255.255 son ejemplos de direcciones IP válidas.

La dirección IPv4 se proporciona como una cadena. Puede suponer que solo consta de dígitos y puntos (no hay letras en la cadena proporcionada).

¿Cómo abordaría esta tarea?

Nota

Incluso si no está familiarizado con las direcciones IP, no se preocupe. Todavía puede completar el código de este ejercicio siguiendo los pasos.

Desglose del problema

En esta tarea, identificará los pasos necesarios para resolver el problema. Si examina detenidamente las reglas, se dará cuenta de que solo son necesarios tres pasos para determinar si una dirección IPv4 es válida o no.

En el editor de Visual Studio Code, elimine cualquier código que haya de los ejercicios anteriores.
Escriba el siguiente pseudocódigo en el 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
*/
```
El pseudocódigo es una excelente manera de empezar a abordar cualquier problema. Con este bloque de comentarios, cierra la brecha entre las reglas PROMPT y el código del programa, con lo que aclara las tareas principales que realizará el código. El pseudocódigo no necesita ser funcional ni cumplir las reglas de sintaxis, pero debe ser una explicación clara de lo que hará el código. Ahora vamos a convertir esto en código real.
Agregue una nueva línea de código en blanco y escriba el siguiente código en el editor:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
En este paso, transforma las instrucciones if del pseudocódigo en métodos invocables y genera los resultados. No se preocupe todavía por definir los métodos. Puede suponer que cada método realiza la tarea que su nombre indica. Pronto corregirá los errores de compilación y creará la lógica del método, pero céntrese en la visión general por ahora. Cuando empieza a trabajar en un nuevo programa, centrarse en el diseño general le ayuda a mantenerse organizado y a desarrollar la aplicación con más rapidez.
Agregue una nueva línea de código en blanco debajo del código actual y escriba el siguiente código en el editor:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Observe cómo el uso de métodos de marcador de posición le permite abordar rápidamente el problema y estructurar el código para desarrollar la solución. Ahora que tiene un plan estructurado, puede seguir resolviendo el problema rellenando el código fragmento a fragmento.

Desarrollo de la solución

Ahora que tiene todos los métodos de marcador de posición necesarios para resolver el problema, puede centrarse en los detalles de la solución. Tenga en cuenta que el formato de entrada de la dirección IPv4 será una cadena que consta de dígitos separados por puntos. ¡Comencemos!

Al principio del programa, cree variables para almacenar los estados de entrada y validación:

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

Actualice el código de la solución para usar las variables de validación de la siguiente manera:

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

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

Actualice el método ValidateLength de la manera siguiente:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
La primera regla indica que la dirección IPv4 debe tener cuatro números. Por tanto, en este código usa string.Split para separar los dígitos y comprobar que hay cuatro.
Actualice el método ValidateZeroes de la manera siguiente:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

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

    validZeroes = true;
}
```
Dedique un momento a pensar en cómo la regla lo convierte en código.

La segunda regla indica que los números de la dirección IPv4 no deben contener ceros iniciales. Por tanto, el método debe comprobar si hay ceros iniciales en los números mientras acepta 0 como un número válido. Si todos los números tienen ceros válidos, validZeroes debe ser true; de lo contrario, false. Por tanto, en este código, comprueba que cada número con más de un dígito no comienza con un cero.

Si lo observa detenidamente, verá que validZeroes se establece en true después de completarse el bucle foreach. Sin embargo, solo quiere establecer validZeroes en true si no se encuentran ceros iniciales. Puede corregir este error estableciendo validZeroes = true antes de que se ejecute el bucle foreach. Sin embargo, también puede corregir este error con una instrucción return.
Actualice el código a lo siguiente:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
La instrucción return finaliza la ejecución del método y devuelve el control al llamador del método. Agregar una instrucción return después de validZeroes = false finaliza el método cuando se encuentra el primer cero no válido. Si no se encuentra ningún cero no válido, el método finaliza después de establecer validZeroes en true. Continuemos con el siguiente método.
Actualice el método ValidateRange de la manera siguiente:
```
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 tercera regla indica que cada número de la dirección IPv4 debe oscilar entre 0 y 255. Por tanto, en este código, comprueba si cada número es menor que 255 y, si no es así, finaliza la ejecución después de establecer validRange en false. Puesto que la cadena de entrada solo contiene dígitos y puntos, no es necesario comprobar si hay números negativos.

Sin embargo, puede haber un caso en el que no haya dígitos entre puntos. Por ejemplo, "255...255". En este caso, string.Split(".") devolvería entradas vacías y int.Parse daría error. Para evitarlo, especifique StringSplitOptions.
Actualice el código de la manera siguiente:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
El uso de StringSplitOptions.RemoveEmptyEntries omite las entradas vacías de la matriz address y evita los intentos de analizar cadenas vacías.

Finalización de la solución

Ahora que ha completado todos los métodos para validar una dirección IP, es el momento de volver a la solución inicial. En esta tarea, agrega más valores de entrada y se prepara para probar el código.

Busque el siguiente código que escribió antes en el programa:
```
string ipv4Input = "107.31.1.5";
```
Actualice el código de la siguiente manera:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Al desarrollar una solución, es importante probar el código con diferentes casos de entrada. En este código, proporciona un buen intervalo de valores de prueba. Ahora que ha actualizado la entrada de prueba, deberá actualizar el código para usar los nuevos valores. Dado que los valores están en una matriz, deberá actualizar el código para probar cada uno usando un bucle.
Actualice el código de la manera siguiente:
```
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 último, debe corregir los datos de entrada que usa cada método, ya que ha actualizado ipv4Input de una cadena a una matriz. Dado que cada método usa string.Split, puede declarar una variable para almacenar el resultado de string.Split y usarla en cada método en su lugar.

Agregue una variable para almacenar la dirección IPv4 actual a la que hará referencia cada método:

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;

Inicialice address con string.Split del siguiente modo:

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

Quite las referencias a string.Split de cada uno de los métodos de validación para que usen la variable address global en su lugar. Por ejemplo:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Comprobación del trabajo

En esta tarea, ejecutará la aplicación desde el terminal integrado y comprobará que el código funciona correctamente. Empecemos.

Compare el código con lo siguiente para asegurarse de que es correcto:

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

Guarde el trabajo con Ctrl + S o use el menú archivo de Visual Studio Code.
Si es necesario, abra el panel del terminal integrado de Visual Studio Code.

En el panel EXPLORADOR, para abrir un terminal en la ubicación de la carpeta TestProject, haga clic con el botón derecho en TestProject y, luego, seleccione Abrir en el terminal integrado.
En el símbolo del sistema del terminal, escriba dotnet run.
Compruebe que el código genera la salida siguiente:
```
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
```
Si el código muestra resultados diferentes, deberá revisarlo para encontrar el error y realizar las actualizaciones correspondientes. Vuelva a ejecutar el código para ver si ha corregido el problema. Continúe actualizando y ejecutando el código hasta que genere los resultados esperados.

Resumen

Esto es lo que ha aprendido sobre el uso de métodos hasta ahora:

Los métodos se pueden usar para estructurar rápidamente las aplicaciones.
Se puede usar la palabra clave return para finalizar la ejecución de un método.
Cada paso de un problema se puede convertir a menudo en su propio método.
Usar métodos para resolver pequeños problemas para crear una solución.

Comentarios

¿Le ha resultado útil esta página?