Aprendiendo .NET sobre la marcha (ii)

<<Aprendiendo .NET sobre la marcha
Aprendiendo .NET sobre la marcha (iii)>>

Continuando con esta serie de publicaciones para aprender .NET, seguiremos trabajando sobre nuestra primera aplicación de consola. Para ello, y una vez abierto el proyecto, agregaremos a nuestras pruebas los siguientes tres casos y procedemos a ejecutar las pruebas para ver los resultados

[TestMethod()]
public void OperandoSumaTest1() {
    int r = Program.Operando("1", "-2", "suma");
    Assert.IsTrue(r == 3, "Error al realizar la suma");
}

[TestMethod()]
public void OperandoDivideTest() {
    int r = Program.Operando("2", "2", "divide");
    Assert.IsTrue(r == 1, "Error al realizar la división");
}

[TestMethod()]
public void OperandoDivideTest1() {
    int r = Program.Operando("2", "0", "divide");
    Assert.IsTrue(r == 1, "Error al realizar la división");
}
    

Se nos notificará que dos de las cuatro pruebas fueron satisfactorias ¿por qué? Pues porque para empezar, la suma de 1 y 2 es 3, la suma de 1 y -2 es -1, el resultado de dividir 2 entre 2 es 1 y la divsión de 2 entre cero no está definida. Las cuatro pruebas utilizan Assert.IsTrue para ser evaluadas, así que para OperandoSumaTest es cierto, para OperandoSumaTest1 es falso, para OperandoDivideTest es cierto y para OperandoDivideTest1 es falso, por lo que corregimos OperandoSumaTest1 de la siguiente forma

[TestMethod()]
public void OperandoSumaTest1() {
    int r = Program.Operando("1", "-2", "suma");
    Assert.IsFalse(r == 3, "Error al realizar la suma");
}
    

IsFalse hace la misma función que IsTrue pero con resultados en falso, a veces necesitaremos este tipo de evaluaciones, aunque podemos transformarlas en verdadero de alguna forma. Para OperandoDivideTest1 No existe un valor con el que podamos hacerlo verdadero o falso, de hecho noregresaría resultado, sino un error que llamaremos Excepción que provocará la interrupción de nuestro código, así que debemos manejarlo de alguna manera. Así que abrimos el código que define Operando para ajustarlo a estas condiciones.

Las Excepciones son situaciones que pueden escapar al control del sistema, y como son (así debería ser) excepcionales, entonces debe haber una forma de impedir que el fatídico resultado de interrumpir el programa se presente.

public static int Operando(string _a, string _b, string _o, out string _msg) {
    int r = 0;
    int a = 0, b = 0, c = 0;
    _msg = string.Empty;

    int.TryParse(_a, out a);
    int.TryParse(_b, out b);

    switch (_o) {
        case "suma":
            r = a + b;
            break;
        case "resta":
            r = a - b;
            break;
        case "multiplica":
            r = a * b;
            break;
        case "divide": // A propósito no estoy validando que b sea distinto de cero
            try {
                r = a / b;
            }catch (DivideByZeroException ex) {
                r = 0;
                _msg = ex.Message;
            }
            break;
    }
    return r;
}
    

Antes que nada, veremos que hice varios ajustes en el método, así que procederé a explicarlos puntualmente. Primero: agregamos un nuevo parámetro que dice out el cual sirve para que el método devuelva información adiciónal al resultado de la operación; este nos será útil para informar sobre la presencia de algún error u otro tipo de mensaje útil al proceso. Segundo: en el caso de la división ponemos los bloques try y catch que nos permiten tomar control al indicar que se intente ejecutar el primerbloque y si se presenta un error del tipo DivideByZeroException, entonces ejecute el segundo bloque.

Como hicimos cambio en nuestro método agregando un nuevo argumento,ahora tenemos que ajustar el método principal y todo donde utilicemos este método de Operando

static void Main(string[] args) {
    string sa = string.Empty, sb = string.Empty, so = string.Empty, msg= string.Empty;
    int resultado = 0;
    Console.Write("Primer número:");
    sa = Console.ReadLine();
    Console.Write("Segundo número:");
    sb = Console.ReadLine();
    Console.Write("Operación (suma, resta, multiplica, divide): ");
    so = Console.ReadLine();

    resultado = Operando(sa, sb, so, out msg);

    Console.WriteLine(string.Format("{0} , {1} => {2}", sa, sb, resultado));
    Console.ReadLine();
}
    

De esta forma estamos obteniendo un posible mensaje de error y el resultado de la operación, mismos que utilizamos para saber cuál fue el resultado y error al ejecutar nuestros métodos.

[TestMethod()]
public void OperandoSumaTest() {
    int r = Program.Operando("1", "2", "suma", out Msg);
    Assert.IsTrue(r == 3, "Error al realizar la suma");

    Console.WriteLine(string.Format("Operación {0} realizada correctamente. Resultado = {1}. Mensaje = {2}", "suma", r, Msg));
}

[TestMethod()]
public void OperandoSumaTest1() {
    int r = Program.Operando("1", "-2", "suma", out Msg);
    Assert.IsFalse(r == 3, "Error al realizar la suma");

    Console.WriteLine(string.Format("Operación {0} realizada correctamente. Resultado = {1}. Mensaje = {2}", "suma", r, Msg));
}

[TestMethod()]
public void OperandoDivideTest() {
    int r = Program.Operando("2", "2", "divide", out Msg);
    Assert.IsTrue(r == 1, "Error al realizar la división");

    Console.WriteLine(string.Format("Operación {0} realizada correctamente. Resultado = {1}. Mensaje = {2}", "divide", r, Msg));
}

[TestMethod()]
public void OperandoDivideTest1() {
    int r = Program.Operando("2", "0", "divide", out Msg);
    Assert.IsTrue(r == 1 || !string.IsNullOrEmpty(Msg), "Error al realizar la división");

    Console.WriteLine(string.Format("Operación {0} realizada correctamente. Resultado = {1}. Mensaje = {2}", "divide", r, Msg));
}
    

El manejo de los bloques try-catch son una muy buena práctica para manejar posibles errores en el sistema a causa de situaciones no contempladas o complejas que no siempre se han de presentar.

Finalmente, en nuetro método original damos clic con el botón secundario y elegimos Ejecutar pruebas unitarias, y nos mostrará el resultado en el panel del Explorador de Pruebas

Hasta aquí dejo esta parte. En posteriores publicaciones seguiré explicando los aspectos de la programación en .NET modificando nuestra aplicación y agregándole funcionalidades hasta concluirla, para luego pasar a otros tipos de proyectos procurando construir uno lo mejor estructurado posible desde un inicio, y explicando las ventajas de tal organización.

Agradezco los comentarios que puedan hacerme, así como el que se suscriban para recibir noticias y, si consideran útil, compartir mi blog.