jueves, 4 de septiembre de 2014

9.- Los métodos

Como dijimos, los métodos son las acciones realizadas por el objeto. En la cuarta entrega, escribíamos con el “lenguaje der Waki” la clase Vehículo con los métodos Avanzar, Arrancar o Parar. En el método Avanzar le añadíamos la velocidad hasta la que queríamos que nuestro vehículo llegara.
El valor velocidad es el parámetro del método, es el que aparece en el método, mientras que el argumento es el valor pasado una vez creado el objeto. Ejemplo.
C#
/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo              
* Historial:           
* Comentarios:
*
****************************************************/
using System;
namespace MyNameSpace
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Console.WriteLine ("Comienza la App ==>");
            Vehiculo miVehiculo = new Vehiculo();

            miVehiculo.Avanzar(50); // esto hace avanzar el vehículo hasta los 50km/h. 50 es el ARGUMENTO
            Console.WriteLine ("Pulse una tecla para frenar el vehículo...");
            Console.ReadLine();

            miVehiculo.Avanzar(0); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine("Pulse INTRO para finalizar..");
            Console.ReadLine();
       }
    }

    class Vehiculo
    {
        public Vehiculo()
        {
            // código utilizado al instanciar la clase
        }

        public void Avanzar(int kmHora)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            Console.WriteLine("La velocidad del vehículo es de " + kmHora.ToString() + " km/h");
        }
    }
}

VB.NET
' ************************************************
'* © WAKI 2014
'* PROYECTO:        Aprender a Programar.
'* Archivo:         Program.cs
'* Descripción:     Clase Main y Vehículo             
'* Historial:           
'* Comentarios:
'*
'***************************************************

Namespace MyNameSpace
    Class MyApp
        Private Shared Sub Main(args As String())
            Console.WriteLine("Comienza la App ==>")
            Dim miVehiculo As New Vehiculo()

            miVehiculo.Avanzar(50)
            ' esto hace avanzar el vehículo hasta los 50km/h. 50 es el ARGUMENTO
            Console.WriteLine("Pulse una tecla para frenar el vehículo...")
            Console.ReadLine()

            miVehiculo.Avanzar(0)
            ' esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine("Pulse INTRO para finalizar..")
            Console.ReadLine()
        End Sub
    End Class

    Class Vehiculo
        ' código utilizado al instanciar la clase
        Public Sub New()
        End Sub

        Public Sub Avanzar(kmHora As Integer)
            ' kmHora es el parámetro tipo número entero del método Avanzar
            Console.WriteLine("La velocidad del vehículo es de " & kmHora.ToString() & " km/h")
        End Sub
    End Class
End Namespace

Analizando código…
  1. Escribimos en  la consola “Comienza App ==>”
  2. Creamos el objeto miVehiculo
  3. Llamamos al método Avanzar de miVehículo pasando el argumento 50
  4. Se visualiza en la consola “La velocidad del vehículo es de 50 Km/h”
  5. Escribimos en la consola “Pulse una tecla para frenar el vehículo...”
  6. Al pulsar INTRO, llamamos de nuevo al método Avanzar de miVehículo pasando el argumento 0
  7. Se visualiza en la consola “La velocidad del vehículo es de 0 Km/h”
  8. Al pulsar INTRO finalizamos.
Nota: Solo hay detalle nuevo que se nos pasa por alto y es que en C# ¿se suman las palabras?. El texto se concatena en C# mediante el signo + mientras que en VB.NET es mediante el signo &. Estos son operadores y los hay a miles (no tantos Waki!).
Un método puede contener  múltiples parámetros y de cualquier índole. Podría crear una clase a la que pasará como un argumento un objeto tipo Vehículo, cualquier objeto admite, ahora si, si la clase o el método tiene como parámetros un objetos tipo Vehículo, solo y exclusivamente podemos pasarle este tipo de objeto y no un número del tipo int, Integer o entero, un string o cadena, boolean o booleano, etc.
Más cosas con los métodos, podemos crear métodos con el mismo nombre pero con distinto tipo de parámetros.  Esto se llama sobrecarga y permite utilizar un mismo método de diferente forma como en la vida misma o ¿nosotros caminamos siempre del mismo modo?,  a pesar de que el método caminar es el mismo, podemos hacerlo calzados o descalzados (con lo que variaría la velocidad), el tipo de calzado, hacia atrás, hacia adelante, etc. Expongo un ejemplo.
C#
public void Avanzar(int kmHora)
{
      // kmHora es el parámetro tipo número entero del método Avanzar
      Console.WriteLine("La velocidad del vehículo es de " +          KmHora.ToString() + " km/h");
}

public void Avanzar()
{
     // avanza hasta los 50 Km/h como valor predeterminado
     Console.WriteLine("La velocidad del vehículo es de 50 km/h");
}

public void Avanzar(int kmHora, bool limitarA120)
{
       // kmHora es el parámetro tipo número entero del método Avanzar
// limitarA120 no permite que pase de 120 km/h
if (limitarA120 && kmHora > 120)
{
kmHora = 120;
}
       Console.WriteLine("La velocidad del vehículo es de " + kmHora.ToString() + " km/h");
}

 VB.NET
Public Sub Avanzar(kmHora As Integer)
    ' kmHora es el parámetro tipo número entero del método Avanzar
    Console.WriteLine("La velocidad del vehículo es de " & kmHora.ToString() & " km/h")
End Sub

Public Sub Avanzar()
    ' avanza hasta los 50 Km/h como valor predeterminado
    Console.WriteLine("La velocidad del vehículo es de 50 km/h")
End Sub

Public Sub Avanzar(kmHora As Integer, limitarA120 As Boolean)
    ' kmHora es el parámetro tipo número entero del método Avanzar
    ' limitarA120 no permite que pase de 120 km/h
    If limitarA120 AndAlso kmHora > 120 Then
        kmHora = 120
    End If

    Console.WriteLine("La velocidad del vehículo es de " & kmHora.ToString() & " km/h")
End Sub

Tres métodos Avanzar pero con distintos parámetros. El primero permite llevar al vehículo a una velocidad concreta, el segundo lleva al vehículo a una velocidad predeterminada y el tercero lleva un parámetros que nos va a permitir limitar la velocidad a 120 Km/h.  Si el segundo argumento pasado  (parámetro limitarA120), tiene un valor false, (falso), se comporta como el método primero, pero si el argumento pasado tiene un valor true, (verdadero), el método limitará la velocidad a 120. ¿Cómo?  Mediante el fragmento if o If…

La instrucción if para C# o If…Then para VB.NET tiene muchas variantes, pero esta es la más sencilla. Lo primero que hace es efectuar una comparación booleana, quiere decir que se obtendrá un Sí o un No, un Verdadero o un Falso, un true o un false. Dentro de esta condición hacemos otra comparación mediante el operador && o AndAlso que es el operador equivalente a decir Y; en el método preguntamos, ¿es verdadero el argumento pasado  limitarA120? Y además ¿es verdadero que el argumento pasado de velocidad es mayor que 120? Pues si esto es verdadero, se limitará la velocidad a 120 Km/h, pero si alguno de las condiciones de la instrucción if no se cumple, el argumento limitar es falso o la velocidad es inferior a 120, pues no se limitará. ¿OK? Pues tan útil como ya he dicho se llama sobrecarga de métodos.

Por último, los métodos también pueden devolver valores. Si le pedimos a una calculadora que sume dos número, primero nos solicitará los dos números y luego el método suma, devolverá un resultado con las dos cantidades sumadas, bien, pues a un método por ejemplo le pasamos dos argumentos y este, devuelve la suma de ambos. En VB.NET los métodos que devuelven valores se llaman funciones. Ejemplos es lo que nos hace falta!. Vamos a convertir los tres métodos del ejemplo anterior pero devolviendo el texto que escribimos en la consola, evitando incluir Console.WriteLine en cada método.

C#
/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo         
* Historial:         
* Comentarios:
*
****************************************************/

using System; 
namespace MyNameSpace
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Console.WriteLine ("Comienza la App");
            Vehiculo miVehiculo = new Vehiculo();
 
            string textoDeSalida = miVehiculo.Avanzar(90); // esto hace avanzar el vehículo hasta los 90km/h. 90 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine ("Pulse una tecla para frenar el vehículo...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(0); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para activar velocidad predeterminada...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para limitar velocidad...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(150,true); // velocidad a 150 km/h y limitador activado
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse INTRO para finalizar..");
            Console.ReadLine();
        }
    }
 
    class Vehiculo
    {
        public Vehiculo()
        {
            // código utilizado al instanciar la clase
        }

        public string Avanzar(int kmHora)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            return "La velocidad del vehículo es de " + kmHora.ToString() + " km/h";
        } 

        public string Avanzar()
        {
            // avanza hasta los 50 Km/h como valor predeterminado
            return "La velocidad del vehículo es de 50 km/h";
        } 

        public string Avanzar(int kmHora, bool limitarA120)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            // limitarA120 no permite que pase de 120 km/h 
            string textoDeSalida = "La velocidad del vehículo es de "; 

            if (limitarA120 && kmHora > 120)
            {
                textoDeSalida = "La velocidad del vehículo era de " + kmHora + " Km/h, pero ahora es de ";
                kmHora = 120;
            }
            return  textoDeSalida + kmHora.ToString() + " km/h";
        }
    }
}

VB.NET 

/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo
* Historial:           
* Comentarios:
*
****************************************************/
using System;
namespace MyNameSpace
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Console.WriteLine ("Comienza la App");
            Vehiculo miVehiculo = new Vehiculo();
 
            string textoDeSalida = miVehiculo.Avanzar(90); // esto hace avanzar el vehículo hasta los 90km/h. 90 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine ("Pulse una tecla para frenar el vehículo...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(0); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para activar velocidad predeterminada...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para limitar velocidad...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(150,true); // velocidad a 150 km/h y limitador activado
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse INTRO para finalizar..");
            Console.ReadLine();
        }
    }

    class Vehiculo
    {
        public Vehiculo()
        {
            // código utilizado al instanciar la clase
        }

        public string Avanzar(int kmHora)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            return "La velocidad del vehículo es de " + kmHora.ToString() + " km/h";
        }

        public string Avanzar()
        {
            // avanza hasta los 50 Km/h como valor predeterminado
            return "La velocidad del vehículo es de 50 km/h";
        } 

        public string Avanzar(int kmHora, bool limitarA120)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            // limitarA120 no permite que pase de 120 km/h 

            string textoDeSalida = "La velocidad del vehículo es de ";

            if (limitarA120 && kmHora > 120)
            {
                textoDeSalida = "La velocidad del vehículo era de " + kmHora + " Km/h, pero ahora es de ";
                kmHora = 120;
            }
            return  textoDeSalida + kmHora.ToString() + " km/h";
        }
    }
}

Analizando código… en el método Main, ocurre lo siguiente:
  1. Escribimos en  la consola “Comienza App ==>”
  2. Creamos el objeto miVehiculo
  3. Llamamos al método Avanzar(90) de miVehículo pasando el argumento 90
  4. Se visualiza en la consola “La velocidad del vehículo es de 90 Km/h”
  5. Escribimos en la consola “Pulse una tecla para frenar el vehículo...”
  6. Al pulsar INTRO, llamamos de nuevo al método Avanzar(0) de miVehículo pasando el argumento 0
  7. Se visualiza en la consola “La velocidad del vehículo es de 0 Km/h”
  8. Escribimos en la consola “Pulse una tecla para activar velocidad predeterminada...”
  9. Al pulsar INTRO, llamamos de nuevo al método Avanzar() sin argumentos de miVehiculo.
  10. Se visualiza en la consola “La velocidad del vehículo es de 50 Km/h”
  11. Escribimos en la consola “Pulse una tecla para limitar velocidad...”
  12. Al pulsar INTRO, llamamos de nuevo al método Avanzar(150) de miVehículo pasando el argumento 150
  13. Se visualiza en la consola “La velocidad del vehículo era de 150 Km/h, pero ahora es de 120 Km/h.”
  14. Al pulsar INTRO finalizamos.
En el último método Avanzar creamos una variable textoDeSalida, a la cual le damos un valor u otro dependiendo si se limita la velocidad o no y para devolver los valores al lugar desde los hemos llamado es mediante la instrucción return que retorna o devuelve el valor calculado.
Para la sobrecarga de métodos, lo único que no podemos hacer es crear dos métodos con el mismo número de parámetros y del mismo tipo, lo que provocaría una ambigüedad y el compilador no sabría cual ejecutar.
Como ya sabemos compilar, practica y crea, que no duele!
Saludos “der Waki”
Publicado por en No hay comentarios:

miércoles, 3 de septiembre de 2014

8.- Nuestro primer programa "ereeh la caña illo!!!”


Ahora que ya sabemos cómo crear una clase, vamos a intentar crear nuestra primera aplicación.
En todos los libros que he leído, la primera aplicación que se desarrolla es la típica en “Hello world!!” o un “Hola Mundo!!” en la que se imprime o se obtiene en pantalla el mismo texto y tiene su historia; la más antigua de ellas y que yo conozca es la de un tejedor (“muuuu espabilao”) llamado Joseph Marie Jacquard que allá por 1801, le daba instrucciones a un telar mediante tarjetas perforadas y consiguió escribir “hello word” en uno de sus tapices, después dicen que Bill Gates  inició Windows 1 con la misma frase, o un libro de C por los años 70 que imprimía lo mismo y … hasta hoy que se sigue usando por todos los begginers o principiantes . Pero para cambiar y siendo este un blog “andalú”, nuestra primera aplicación va a escribir un mensaje que diga “ereeh la caña illo!!!” (Traducido a eres la caña chiquillo, cosas de los andaluces!), ¿ok?, bueno, vamos allá.

Antes de nada, quiero decir que toda aplicación tiene un método llamado Main tanto para C# como VB.NET. Da igual en que clase lo pongamos que el compilador se encargará de buscarlo e iniciar todo desde ahí, desde Main. Este método tiene además dos modificadores, uno public y otro static. El modificador público es para acceder a la aplicación desde el exterior y el static lo explico ahora mismo.

Cuando creamos un clase y la instanciamos, se genera un nuevo objeto, si instanciamos esta clase mil veces, tendremos 1000 objetos, pero si una clase o un miembro de clase es static, lo primero es que no hace falta instanciarla y lo segundo, que solo se crea una solo objeto.

Ejemplo. Si tenemos un clase vehículo estática y queremos que arranque el vehículo, no haría falta crear un nuevo vehículo, sino que escribiríamos el nombre de la clase seguido de punto y el método a usar, Vehículo.Arrancar, pero con el inconveniente de que solo habrá un solo objeto. Pasemos a un ejemplo:
C#
/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo 
* Historial:           
* Comentarios:
*
****************************************************/
using System;

namespace MyNameSpace
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Vehiculo miVehiculo = new Vehiculo();
            miVehiculo.Arrancar();
            ClaseEstatica.MetodoEstatico();
        }
    }

    static class ClaseEstatica
    {
        static public ClaseEstatica()
        {           

        } 

        static public void MetodoEstatico()
        {
            // código cuando se accede al método estático
        }
    }

 

    class Vehiculo
    {
        public Vehiculo()
        {
            // código utilizado al instanciar la clase
        } 

        public void Arrancar()
        {
            // código necesario para arrancar
        }
    }
}

VB.NET
' ************************************************
'* © WAKI 2014
'* PROYECTO:        Aprender a Programar.
'* Archivo:         Program.vb
'* Descripción:     Clase Main y Vehículo 
'* Historial:          
'* Comentarios:
'*
'***************************************************
 
Namespace MyNameSpace
    Class MyApp
        Private Shared Sub Main(args As String())
            Dim miVehiculo As New Vehiculo()
            miVehiculo.Arrancar()
            ClaseEstatica.MetodoEstatico()
        End Sub
    End Class

    NotInheritable Class ClaseEstatica
        Private Sub New()
        End Sub

        Public Shared Sub MetodoEstatico()
            ' código cuando se accede al método estático
        End Sub
    End Class

    Class Vehiculo
        ' código utilizado al instanciar la clase
        Public Sub New()
        End Sub

        Public Sub Arrancar()
            ' código necesario para arrancar
        End Sub
    End Class
End Namespace

Analicemos el código; tenemos un espacio de nombres llamado MyNameSpace  con tres clases, una pública y estática MyApp que contiene el método Main, otra Vehiculo  y otra pública y estática llamada ClaseEstatica. La primera es desde donde accederemos desde Windows, (donde pone  string[] args, son parámetros enviados como argumentos y los veremos con más detalle) y en su método Main hacemos lo siguiente:
Creamos un objeto Vehículo al que llamamos miVehiculo (el nombre es elección del usuario, podría haberle llamado coche, micoche, etc) e instanciamos uno nuevo (new Vehiculo). A partir de este momento, cada vez que nos referimos a miVehiculo nos referimos a el que hemos creado y ahora que ya tenemos un objeto, invocamos el método Arrancar desde este mismo objeto. Ahora nos referimos a la clase estática pero sin hacer referencia a new ClaseEstatica , directamente escribiendo la clase y seguido del método estático. Fácil, ¿no?
En VB.NET las clases se instancia primero con Dim, luego el nombre y posteriormente As New nombre de la clase

Volviendo a nuestra primera aplicación y centrándonos en ella. Abrimos el Bloc de Notas o Notepad++, creamos un nuevo archivo de texto y escribimos (aconsejo escribir) o copiamos y pegamos el código de nuestra primera Aplicación. Guardamos donde queramos el archivo, eso si, guardando con extensión .cs para C# o .vb para VB.NET. Si no vemos las extensiones, hay que habilitar su visualización.
(En W7, desde una ventana del explorador de Windows, Organizar, Opciones de carpeta y búsqueda, Pestaña Ver y casi al final de la lista desmarcamos Ocultar las Extensiones de Archivos ...)
C#
/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo             
* Historial:           
* Comentarios:
*
****************************************************/
using System;
namespace MyConsoleApplication
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Console.WriteLine ("ereeh la caña illo!!!");
            Console.WriteLine("Pulse una tecla para cerrar");
            Console.ReadLine();
        }
    }
}

VB.NET
'* ************************************************
'* © WAKI 2014
'* PROYECTO:        Aprender a Programar.
'* Archivo:         Module1.vb
'* Descripción:     Clase Main y Vehículo             
'* Historial:           
'* Comentarios:
'*
'****************************************************

Module Module1
    Class MyApp
       Public Shared Sub Main(args As String())
            Console.WriteLine("ereeh la caña illo!!!")
            Console.WriteLine("Pulse Intro para cerrar")
            Console.ReadLine()
        End Sub
    End Class
End Module

Nota: (Una instrucción Module define un tipo de referencia disponible en su espacio de nombres. Un módulo es similar a una clase pero con algunas distinciones importantes. Cada módulo tiene exactamente una instancia y no necesita ser creado ni asignado a una variable. Los módulos no admiten la herencia ni implementan interfaces. No es  una clase y no puede declarar.)
Analicemos este nuevo código. Vemos que hemos escrito la clase Console que procede del espacio de nombre System que lo tenemos importado, esta clase tiene múltiples métodos, pero hemos escogido WriteLine y ReadLine. El primero escribe una línea en la consola (pantalla negra) y el segundo espera una entrada del teclado y una vez recibida cierra el programa. La parte que va incluida entre los paréntesis de los métodos se llama argumento y tiene un tipo, es decir si el método dice que solo puede recibir un texto, no podemos pasarle un número (aunque ya veremos que también se puede), pero en definitiva, el método decide que recibir.
Una vez que recibe el argumento tipo string (texto), se visualiza en pantalla.
Ahora vamos a crear el programa. Dijimos que necesitábamos un compilador que lo encontraremos en C:\Windows\Microsoft.NET\Framework\(Versión de .NET) yo en mi caso voy a compilar con la versión .NET Framework 4.0 por tanto yo tengo el compilador en C:\Windows\Microsoft.NET\Framework\v4.0.30319.
En W7, abro el símbolo del sistema como administrador (Inicio-Todos los Programas-Accesorios- Símbolo del Sistema y le damos con el botón derecho “Ejecutar como Administrador”.
Una vez en la pantalla oscura, escribimos cd\ e INTRO de modo que el símbolo del sistema se irá a C: \>, en esta ruta se creará nuestro programa y después de esto, escribo la ruta donde se encuentra el compilador seguido del archivo que queremos compilar, en mi caso C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe C:\Desarrollo\ConsoleApplication1\Program.cs, pulsamos INTRO y et voilá, compilado, ya tenemos nuevo programa!, en C:\ tendremos un ejecutable llamado program.exe. Lo ejecutamos y … ahí lo llevas

 
Saludos “der Waki”
Publicado por en No hay comentarios:

lunes, 1 de septiembre de 2014

7.- Un modo de tener el código ordenado


Como ya dije en el Post 5, el coste llevado a cabo para el mantenimiento del software es muy costoso, por lo que sería muy conveniente escribir un código muy comentado, claro y estructurado, esto nos daría limpieza y efectividad pudiendo detectar y minimizar los ERRORES (porque haberlos, haylos)
Para comentar el código, escribimos en C# // Aquí van los comentarios o en VB.NET ’Aquí van los comentarios. Este texto en Visual Studio se torna verde cuando se trata de un comentario.

Si en vez de dos barras, escribimos tres, podemos escribir comentarios continuamente al pulsar ENTER y cambiar de línea, escribiéndose automáticamente otras tres barras (C#) o comillas simples(''').

 Si estamos programando en Visual Studio y escribimos estas tres barras o comillas simples encima de un método, variable, propiedad, etc., es decir sobre un miembro de clase, se inserta automáticamente una etiqueta llamada <summary> con otra etiqueta de cierre </summary> y el contenido que escribamos entre estas dos etiquetas se visualizará automáticamente con IntelliSense que es una herramienta de ayuda de Visual Studio con la cual según vamos escribiendo, se van visualizando los miembros de clase disponibles en esta; además visualiza la información escrita entre las dos etiquetas <summary>Esto describe el miembro de clase</summary>.
 

 
Una vez comentado el código, existe otra forma de tener el código ordenado mediante bloques y esto se hace escribiendo

C#

#region MyRegion
 
        // aquí podemos poner todos los
        // miembros de clase que queramos

#endregion

VB.NET

#Region "MyRegion"

        ' aquí podemos poner todos los
        ' miembros de clase que queramos

#End Region 

Esto no se compila y simplemente nos permite mantener los miembros de clase ordenaditos y enclaustrados entre regiones o bloques de código, por ejemplo, podemos crear una región llamada propiedades y variables donde incluyamos solo exclusivamente estos miembros u otra donde incluya los métodos asociados a controles y dentro de esta más bloques de código separándolos por tipo de control, de modo que cuando quiera visualizar un método asociado a un evento click de un botón, me iré a la región Controles y dentro de esta a otra región llamada Botones y en su interior estará el método que busco evitando dar muchas vueltas con la rueda del ratón o efectuando búsquedas de texto.

Debemos pensar que el código será revisado por otra persona o por nosotros mismos miles de años después, por tanto, ordena!!! (¿miles? jajajaja dejémoslo en cientos)

Además, imaginemos una clase con 1000 líneas, al incluir el código entre regiones, es posible contraer o expandir las regiones, evitando mantener las mil líneas desplegadas con el consiguiente lio.

Otra forma de de mantener claro el código es escribir con mucha sencillez los métodos, espaciados y con pocas líneas (A ser posible).

 Otro aspecto muy importante es la nomenclatura de los nombres de las clases y miembros de clase, ¿por qué es importante? Pues si recuerdan cuando en el lenguaje “der waki” asignábamos los nombres a las características y métodos de la clase vehículo, los nombrábamos con Velocidad, Potencia, Matrícula, Número de Bastidor, Arrancar, Parar, Avanzar, etc., pues eso, cuando quiero asignarle la matrícula a la propiedad Matrícula debo hacerlo con sentido común; si le hubiéramos puesto como nombre Abrigo, diría ¿para qué le he puesto el nombre Abrigo a la propiedad Matrícula? Menuda tontería no!! Pues por ahí van los tiros. 

Existen múltiples notaciones para nombrar los miembros de clase, pero nos centramos en dos, notación Pascal y Camello ( que nombres!!). La notación Pascal utiliza la primera letra de cada palabra con mayúscula, de modo que si nombramos la propiedad NumeroBastidor, iniciamos cada palabra con mayúsculas sin espacios y si usamos la notación camello es igual que la Pascal pero iniciando con minúsculas y dándole ese aspecto de jorobas de camello subiendo y bajando. Microsoft utiliza este método para crear sus aplicaciones y dependiendo del miembro de  clase que sea, adaptaremos el nombre de un modo u otro y que a continuación detallo: 
  • Espacios de nombres. Para los espacios de nombres se usa el nombre de la compañía o el nombre del producto con la primera letra en mayúscula y resto en minúsculas, por ejemplo Microsoft tiene un espacio de nombres Microsoft de alto nivel y según van creando productos, le agregan un nuevo espacio de nombres,  Microsoft.Win32,  System.Windows.Forms, etc.
  • Para las clases, utilizamos sustantivos con notación Pascal. Otra manía que tengo y que aprendí de dos buenos programadores, es encabezar las clases con comentarios, nombre del archivo de la clase, que hace la clase, quien la ha creado y cuando, si le introduzco modificaciones, que modificaciones se han realizado y cuando, en definitiva, una serie de datos que me informen de la clase.
  • Para los métodos también Notación Pascal, pero como los métodos hacen cosas, actúan, llevan a cabo una labor, interesa que describan los que hacen mediante verbos acompañados de objeto sobre el que recae la acción. Por ejemplo ImprimirFactura, CalcularSalario, AbrirBaseDeDatos, ObtenerUsuario, etc. Yo personalmente, uso en castellano los métodos privados y los métodos públicos los pongo en inglés para globalizar la clase, si estos métodos los hiciera públicos, les daría PrintInvoice, CalculatePay,OpenDataBase, GetUser, etc. Debo hacer hincapié en que existen métodos que además de hacer algo obtienen algo, como el último ejemplo ObtenerUsuario que se encargaría de buscar en algún sitio el usuario que está activo en el momento, bueno pues existen métodos que comprueban algo por ejemplo EstaLaPuertaAbierta y si lo está, devolvería un valor verdadero y si no lo está devolvería un valor falso, este tipo se llaman boolean de Boole el matemático que estudio el algebra de su mismo nombre sobre el sistema binario, pues este tipo de métodos deben comenzar con la tercera persona del verbo ser o estar, en inglés Is, por ejemplo IsOpenDoor, de modo que si utilizamos este método con alguna condición, sería mucho más claro de entender, en el lenguaje “der Waki”
           Si está abierta la puerta, ciérrala
           En C#

if (IsOpenDoor())
             {
                   // cerrar puerta
             }
           En VB.NET

If IsOpenDoor() Then
                   ' cerrar puerta
End If
  • Las propiedades. Estilo Pascal (primera en mayúscula de cada palabra)
  • Variables. Sobre las variables o campos, hay tema para todos los gustos. Vamos a ver, si una clase se llama Autor y creamos un campo que identifique al autor, no vamos a ponerle el mismo nombre de la clase, le ponemos por ejemplo NombreAutor con notación Pascal y cuando accedamos a esta variable los haremos mediante Autor.NombreAutor. Para las variables privadas o de menor entidad, yo utilizo la notación Camello (primera en minúsculas) y en algunos casos (para gustos los colores) le incluyo a la notación camello un guión bajo al inicio, así de un primer vistazo introduciendo un guión, echo un vistazo sobre estas.
De todos modos, los IDE (Entornos de Desarrollo Integrado) como Visual Studio, Eclipse, etc.., cambian de color (como los comentarios que los ponía en verde) cada elemento dependiendo del tipo que sea.

En resumen, para todo programador es importantísimo el orden, tengo la experiencia de crear aplicaciones con pocas líneas de código y que al volver a modificar algún detalle, volverse en un trabajo tedioso, por tanto el tiempo invertido inicialmente es fundamental para futuras modificaciones o ampliaciones.

Saludos "der Waki"
Publicado por en No hay comentarios:
Suscribirse a: Entradas (Atom)