Aprendiendo .NET sobre la marcha (iii)

<<Aprendiendo .NET sobre la marcha (ii)
Aprendiendo .NET sobre la marcha (iv)>>
Aprendiendo .NET sobre la marcha (v)>>

Viendo el código de nuestro método Operando, nos damos cuenta que hay varias cosas por explicar.

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

Firma:

se compone de los modificadores, tipo de dato a devolver, nombre del método y argumentos.

• Los modificadores indican el alcance del método.
  
  • public: puede ser utilizado desde métodos ajenos a nuestra clase.
  • privare: (por default, si no especificamos, todos tienen este alcance) pueden ser utilizados únicamente dentro de nuestra clase, y si se definen dentro del método, solo al interior de este.
  • protected: pueden ser utilizados por la clase y las clases heredadas (veremos luego a qué refiere esto).

Tipo Resultado

El tipo de dato puede ser void si no va a regresar resultado directamente el método o cualquier otro tipo de dato.

Argumentos

Son elementos que permiten enviar (en su mayoría) datos al método para que trabaje, y recibir resultados, además del resultado en sí del método. Hay de dos tipos, por valor (en su mayoría asociados con los tipos más básicos) y por referencia (asociados con tipos que refieren a elementos complejos). Sin embargo, podemos pasar parámetros por referencia relacionados con tipos básicos, para ello usamos la palabra reservada out en la declaración del parámetro. Con esto, cada que invoquemos al método tenemos que especificarle que el argumento será de salida con la misma palabra.

Ahora explicare algunas cosas que estamos usando y que utilizaremos en breve.

Métodos estáticos: Ya había mencionado algo al respecto. Son métodos que podemos ejecutar directamente desde el tipo de dato al que pertenecen. Aclaro que a la definición de los tipos se le llama clases, así que todo aquí son clases, y de aquí en adelante ya no diré tipo, sino clase para referirme a un tipo de dato. Por otro lado, cuando definimos una variable de alguna clase, tenemos que instanciarla, es decir, crear un objeto a partir de esa clase para poder utilizarlo, a excepción de los elementos estáticos definidos en la clase. En nuestro código tenemos int.TryParse, donde int es la clase de número entero y TryParse es un método estático que intenta la conversión de una cadena con apariencia de número entero hacia un número entero verdadero.

switch: Permite elegir entre varias opciones las cuales deberán corresponder con tipos de datos discretos, como por ejemplo: enumeraciones, constantes, números enteros.

Enumeraciones: Son conjuntos de valores, normalmente asociados a valores enteros, que podemos referenciar por un nombre para mayor practicidad.

Constantes: Son elementos cuyo valor no cambia durante la ejecución del sistema. Permiten utilizar un nombre más práctico, además de que al utilizar en varios puntos del código la constante, basta con cambiar en su definición el valor para que en todos los lugares donde se utiliza se cambie automáticamente.

El proceso de desarrollo siempre es una espiral donde a cada vuelta encuentras algo qué mejorar, por eso es importante tener un plan y apegarse, y antes de meterte en otras cuestiones conviene anotarlas para que al terminar la etapa construyas un nuevo plan para esas mejoras que detectaste.

Continuamos reorganizando nuestra aplicación (Como puedes ver, aún no ejecutamos el programa como tal, estamos haciendo pruebas y desarrollos). Para ello, antes de nuestro método principal agregamos el siguiente código y luego el método Operando lo modificamos a como sigue.

public enum eOperaciones {
  suma = 1,
  resta = 2,
  multiplica = 3,
  divide = 4
};
  

public static int Operando(string _a, string _b, eOperaciones _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 eOperaciones.suma:
      r = a + b;
    break;
    case eOperaciones.resta:
      r = a - b;
    break;
    case eOperaciones.multiplica:
      r = a * b;
    break;
    case eOperaciones.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;
}
  

De esta forma estamos incluyendo una enumeración que nos servirá de referencia a cuantas operaciones matemáticas deseemos: raíces, potencias, logaritmos, etc. (aunque no los vamos a implementar). Así no dependemos de una cadena de caracteres que podemos escribir equivocadamente y no podríamos detectar el error tan fácil. El ajuste lo tenemos que hacer también en donde mandemos a llamar al método.

Por ejemplo, en nuestro método principal lo haremos de esta forma.

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

  int.TryParse(so, out so_int);

  resultado = Operando(sa, sb, (eOperaciones)so_int, out msg);

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

Hay que observar la línea (eOperaciones)so_int que hace una conversión por técnica de boxing. Además de que previamente convertimos en entero el dato capturado. Además, en nuestras pruebas cambiamos int r = Program.Operando("1", "2", "suma", out Msg); por int r = Program.Operando("1", "2", eOperaciones.suma, out Msg); de acuerdo con la operación que estemos probando.

Hasta aquí dejo esta parte. En posteriores publicaciones seguiré explicando los aspectos de la programación en .NET y ejecutaremos por fin nuestra aplicación. Además comenzaré por plantear la construcción de una aplicación (tal como mencioné al final de la publicación anterior, organizando todo desde el inicio y explicando las ventajas de tal organización), también matemática (por las capacidades de ésta para implementar mecanismos de POO). Aunque no todo será así y veremos en otros proyectos otro enfoque en construcción de sistemas.

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