Mejorando tus presentaciones y exposiciones (Parte 1)

En esta nueva serie de posts, daré tips y recomendaciones para mejorar tus presentaciones, muchas de ellas las he ido aprendiendo a través del tiempo, formando así parte de mi experiencia como expositor e impartidor de sesiones de entrenamiento, sin más preámbulo, iniciemos.

Tip 1. Usa la Lupa que incorpora Windows 7 (Magnifier)

¿Cuántas veces no ha pasado, que teniendo una diapositiva expuesta en el proyecto, el público de atrás no alcanza a ver lo que está escrito en la misma?

Esto es un problema común, que veo muy a menudo con gente que no está acostumbrada a exponer, aquellos expositores con experiencia evita poner este tipo de cosas en sus diapositivas, sin embargo, si llegas a necesitar hacer zoom en un lugar en específico, sólo basta presionar la tecla Windows más la tecla +:

Demostración:

Bien, veamos un ejemplo del uso de la lupa, supongamos que debemos exponer un tema de desarrollo de software, mostrando algo de código, una presentación de ejemplo se vería algo así:

Si alguien sentado en la parte de atrás quisiera leer o copiar el ejemplo de la lámina, simplemente se sentiría frustrado al no poder leer todo de una manera rápida y sencilla, aplicaremos la lupa ahora:

Como podemos observar, el resultado es simplemente increíble =)

Nos vemos en la siguiente entrega

 

Salu2

Héctor Uriel Pérez Rojas

Tips para programar Orientado a Objetos con C#.- Tip #3: Ten un constructor central

Hola, tercera tip para programar Orientado a Objetos en C#, cualquier duda o comentario, háganmelo saber 🙂

Contexto:

Es muy común en las aplicaciones .Net, tener clases que tengan constructores de diversas firmas, es decir, que puedan ser llamadas de distintas formas. Un ejemplo, tomado de las clases del .NET Framework, es la clase SqlCommand, la cual tiene varios parámetros con los cuales puede ser inicializado:

Como puedes ver, cuando trabajas con esta clase, puedes llamar a la misma pasándole ningún parámetro, una cadena como parámetro, o bien un cadena y un objeto del tipo SqlConnection, para los que no lo sepan, a esto se le llama overloading (o sobrecarga en español), y nos sirve para tener un mismo método con el mismo nombre, pero que reciba diferentes parámetros.

Hagamos nosotros un ejemplo de esto, creemos una nueva clase, con 3 propiedades, y 1 constructor, que será básicamente lo que hemos visto en el tip # 2:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public decimal Efectivo { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, decimal _efectivo)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Efectivo = _efectivo;

  12:     }

  13: }

A esta clase, le agregaremos un nuevo constructor, el cual tendrá una sobrecarga de 2 parámetros, y en el cual, inicializaremos el valor efectivo a 0:

 

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public decimal Efectivo { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, decimal _efectivo)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Efectivo = _efectivo;

  12:     }

  13:  

  14:     public Cliente(string _nombre, int _edad)

  15:     {

  16:         this.Nombre = _nombre;

  17:         this.Edad = _edad;

  18:         this.Efectivo = 0.00M;

  19:     }

  20: }

¿Y si tuviéramos otro constructor que no recibiera parámetros y quisiéramos inicializar todo a 0? ¿Qué tal otro constructor que solo reciba un parámetro? Y si tuvieras un constructor que tuviera 10 parámetros y tuviéramos que inicializar cada propiedad mediante la asignación de estos parámetros? Tendríamos que empezar a copiar y a pegar el código de cada constructor. Se dice que cuando se empieza a repetir nuestro código, algo está mal.

Mucho lío ¿No?

Solución:

Crear un constructor central, que haga todo el trabajo, y que sea solamente llamado en los constructores que deriven de él.

Así es, en nuestro ejemplo, tomaremos como constructor base el primer constructor con 3 parámetros, y lo único que haremos, será usarlo en nuestro segundo constructor de la siguiente manera:

   1: public Cliente(string _nombre, int _edad) 

   2:             : this(_nombre, _edad, 0.00M)

Esa es la manera de crear constructores que usen a uno principal. Para que veas que tanto se simplifica el código, aquí dejo el código para crear los constructores con ninguno, uno, dos y tres parámetros.

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public decimal Efectivo { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, decimal _efectivo)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Efectivo = _efectivo;

  12:     }

  13:     

  14:     public Cliente(string _nombre, int _edad) 

  15:         : this(_nombre, _edad, 0.00M)

  16:     {

  17:     }

  18:     public Cliente(string _nombre)

  19:         : this(_nombre, 18, 0.00M)

  20:     {

  21:     }

  22:     public Cliente()

  23:         : this("Héctor", 18, 0.00M)

  24:     {

  25:     }

  26: }

Ahora sí, tenemos disponibles diferentes inicializaciones para nuestra clase:

Nada de copiar y pegar. Cool eh? 🙂

Link de la solución: Tip3.zip

Salu2

Héctor Uriel Pérez Rojas

Tips para programar Orientado a Objetos con C#.- Tip #2: Crea y Usa Constructores

 

Segundo Tip para programar Orientado a Objetos con C#, espero que a mas de uno le sirva 🙂

Contexto:

En el ejemplo del tip # 1, hemos creado una clase Cliente, el cual tiene 3 propiedades (Nombre, Edad y Cuenta). Cuando hemos hecho uso de esta clase, ha sido de la siguiente forma:

   1: static void Main(string[] args)

   2: {

   3:     Cliente cliente = new Cliente();

   4:     cliente.Nombre = "Héctor";

   5:     cliente.Edad = 23;

   6:     cliente.Cuenta = 22312;

   7:     System.Console.WriteLine(cliente);

   8: }

Como podemos ver, tenemos que inicializar explícitamente cada una de las propiedades (cliente.Nombre=”Héctor; ….).

Imagina que tienes que crear una lista de Clientes, e inicializarla desde el inicio, una posible solución sería esta:

   1: public List<Cliente> RellenarLista()

   2: {

   3:     List<Cliente> lista = new List<Cliente>();

   4:  

   5:     Cliente cliente1 = new Cliente();

   6:     cliente1.Nombre = "Héctor";

   7:     cliente1.Edad = 23;

   8:     cliente1.Cuenta = 1111;

   9:     lista.Add(cliente1);

  10:  

  11:     Cliente cliente2 = new Cliente();

  12:     cliente2.Nombre = "Vianey";

  13:     cliente2.Edad = 23;

  14:     cliente2.Cuenta = 1111;

  15:     lista.Add(cliente2);

  16:  

  17:     Cliente cliente3 = new Cliente();

  18:     cliente3.Nombre = "Anahí";

  19:     cliente3.Edad = 23;

  20:     cliente3.Cuenta = 1111;

  21:     lista.Add(cliente3);

  22:  

  23:     return lista;

  24: }

Ahora imagina, si fueran decenas de clientes los que tuvieras que inicializar, esto se vuelve cada vez mas complicado, con la sintaxis que hemos estado utilizando.

Solución:

El tip de este día es, crear constructores para inicializar los valores de las propiedades una vez creada la clase. ¿Cómo se hace esto?

A través de un constructor. Un constructor es un método que se ejecutará cuando la clase sea instanciada. Si no está declarado uno por nosotros, el .NET  Framework creará uno por nosotros.

Primero debemos modificar nuestra clase Clientes, creando un constructor. Un constructor tiene la forma:

   1: Class Cliente

   2: {

   3:     public Cliente()

   4:     {

   5:     }

   6: }

Como puedes ver, es parecido a un método, toma el mismo nombre que la clase, y no tiene ningún tipo de retorno. Este constructor será llamado cuando se utilice la palabra new.

Para nuestro ejemplo, debemos modificar nuestro constructor, de tal forma que podamos inicializar nuestras propiedades (Nombre, Edad y Cuenta), una vez que sea creada la instancia de la clase. Esto lo logramos de la siguiente manera:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public int Cuenta { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, int _cuenta)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Cuenta = _cuenta;

  12:     }

  13: }

Ahora bien, cuando queramos crear una nueva instancia de Cliente, se nos pedirá que le pasemos los parámetros solicitados por el constructor que hemos creado, si no, este marcará error:

Lo que el error nos dice, es que el constructor de Cliente, tiene 3 parámetros, y que está tratando de ser invocado, sin ninguno, por lo que nuestra inicialización quedaría:

   1: class ListaClientes

   2: {

   3:     public List<Cliente> RellenarLista()

   4:     {

   5:         List<Cliente> lista = new List<Cliente>();

   6:  

   7:         Cliente cliente1 = new Cliente("Héctor", 23, 1111);

   8:         lista.Add(cliente1);

   9:  

  10:         Cliente cliente2 = new Cliente("Vianey", 21, 2342);

  11:         lista.Add(cliente2);

  12:  

  13:         Cliente cliente3 = new Cliente("Anahí", 22, 8232);

  14:         lista.Add(cliente3);

  15:  

  16:         return lista;

  17:     }

  18: }

Como vemos, se ha simplificado muchísimo el código, haciéndolo mas fácil de leer, y de escribir. Cualquier duda o comentario, no duden en escribirlo 🙂

Link del ejemplo: Tip2.zip

Salu2

Héctor Uriel Pérez Rojas

Tips para programar Orientado a Objetos con C#.- Tip #1: Override ToString()

 

Hola! ¿Qué tal? Espero que todos anden bien 😉 En esta nueva colección de posts, mencionaré algunos tips que pueden ayudar a mas de uno, a sacar el mayor provecho mientras desarrolla en una programación Orientada  a Objetos. Espero que les gusten, como siempre, comentarios, preguntas son recibidos, así que empezamos.

Contexto:

Muchas veces, cuando somos nuevos programando, cometemos el error de trabajar con nuestras clases sin sobreescribir el método ToString que viene por defecto en la clase, a qué me refiero con esto? Pues a esto:

Supongamos que tenemos una clase Cliente, con la siguiente estructura:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public int Cuenta { get; set; }

   6: }

Para probarla, he creado una solución de tipo consola, sobre la cual creo una nueva instancia de la clase, le asigno vales a sus propiedades, y posteriormente la mando a llamar para su impresión a través del método WriteLine de la Consola:

   1: static void Main(string[] args)

   2: {

   3:     Cliente cliente = new Cliente();

   4:     cliente.Nombre = "Héctor";

   5:     cliente.Edad = 23;

   6:     cliente.Cuenta = 22312;

   7:     System.Console.WriteLine(cliente);

   8: }

Esto, nos tira el siguiente resultado:

Solución:

Ok, vamos con el tip, sobreescribir el método ToString que viene por defecto en cada clase, para especificar qué queremos imprimir cuando ésta sea llamada, lo único que tenemos que hacer, es agregar la siguiente sintaxis a nuestra clase:

   1: public override string ToString(){}

Con lo que, específicamente nuestra clase quedaría:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public int Cuenta { get; set; }

   6:  

   7:     public override string ToString()

   8:     {

   9:         return "Mi nombre es: " + Nombre

  10:             + " y tengo: " + Edad

  11:             + "y mi cuenta ficticia es: " + Cuenta;

  12:     }

Ahora, volvemos a llamar a nuestra clase desde nuestra aplicación de consola, con lo que nos retorna:

Ejemplo práctico:

Ahora bien, para que no se quede todo en una aplicación de consola, para probar esto mismo he creado un formulario en WPF(igual pudo haber sido una aplicación Windows Forms, ASP.NET, etc):

Básicamente, el concepto es el mismo, introduce el usuario un nombre, su edad y su cuenta, y posteriormente es agregado a la lista de los clientes.

   1: private void btnAgregar_Click(object sender, RoutedEventArgs e)

   2: {

   3:     Cliente cliente = new Cliente();

   4:     cliente.Nombre = txbNombre.Text;

   5:     cliente.Edad = int.Parse(txbEdad.Text);

   6:     cliente.Cuenta = int.Parse(txbCuenta.Text);

   7:     lsbCuentas.Items.Add(cliente);

   8: }

Ahora bien, si esto es usado sin el método sobreescrito de nuestra clase clientes, lo que se agrega es lo siguiente:

mientras, que sobreescribiendo el método ToString, obtenemos:

Les dejo el archivo de la solución en Visual Studio:

Tip1.zip

Salu2

Héctor Uriel Pérez Rojas