[005] Nomenclatura de las variables

Sobre las convenciones de nombres

He leído bastante sobre este tema. En lo referente a C Sharp todo el mundo dice que no hace falta indicar el tipo de las variables en su nombre. Existen excepciones como los interfaces que como sabéis empiezan por I, y algunos otros tipos más, pero mi experiencia me dice que aplique la lógica y actue en consecuencia.

La razón que dan los Gurús por la cual no es necesario tipificar las variables es que los actuales IDE ya se encargan de eso y por lo tanto el código se vuelve estéticamente mas legible, pero yo al aplicar la lógica les preguntaría a tan honorables señores... ¿ y que pasa cuando el código está impreso en papel ?

A día de hoy los papeles no tienen << Intellsense >> o la posibilidad de autocompletar código o mostrar tooltips informativos, así que mientras no sea de esta forma yo etiquetaré las variables como siempre lo he hecho.

Volviendo a la lógica antes mencionada si que es cierto que podemos simplificar la notación que utilizábamos en Foxpro para con C Sharp. Yo la he bautizado Notación CSF.

La Notación CSF (CSharpFox)

Una de las cosas que tenemos que tener muy claras es que no podemos abusar de las variables públicas como lo hacíamos en Fox. Tampoco va a ser necesario ponerle nomenclatura a todos los tipos de C Sharp, ya que son más que en Fox y además del tipo de variable, también deberíamos indicar el ámbito de actuación de la misma ( Lo que en Fox era publica, local, etc. )

Donde no pondremos notación...

• En las variables públicas, puesto que serán pocas y además sabremos de un vistazo que son públicas ya que empiezan con el nombre de la clase Prg.

         Prg.TestMode = true;

• En las variables de las clases estáticas que podamos crear ni en el nombre de las mismas, ya que serán muy utilizadas y aquí si que se necesita cierta estética en código... osea que en este caso estoy deacuerdo con los Gurús.

          static class Prg { }

• En las variables de ámbito público de las clases instanciables.
• En los nombre de los enumeradores.
• En los nombre de las estructuras.
• En los nombre de los delegados.

Donde pondremos notación y cual...

• Utilizaremos siempre la notación Pascal (primer carácter de todas las palabras se escribe en Mayúsculas  menos en aquellas variables donde indiquemos el tipo al principio, aquí utilizaremos la notación Camell (Primera palabra en minúsculas siguientes en Mayúsculas).
• No utilizar nunca el carácter _ en cualquier definición de C sharp (Varialbes, clases, etc.).  
• Los nombres de todas las clases que creemos, menos las estáticas, empezarán con T mayúscula, esto lo heredamos de Delphi y nos sirve para diferenciarlas de sus objetos. No he utilizado la c, ya que me la reservo para los string. Ejemplo: TConfig
• Al igual que en Fox todas las variable de objeto que creemos empezarán por la o minúscula: oConfig
• Los tipos Buildstring, string y char empezarán con una c (ce) minúscula de caracteres al igual que en fox.
• Los tipos int, decimal, double, float, long, short, uint, ulong, ushort, byte, sbyte empezarán con n (ene) minúscula. 
• Los tipos bool con la l (ele) minúscula de logic, esto para las variables locales ( de clase o método) para las globales (las de la clase Prg. utilizaremos la palabra Is por ejemplo IsDemo.
• Los tipos datetime con una d (de) minúscula).
• En la definición de objetos gráficos utilizaremos 3 letras minúsculas y luego empezaremos por mayúsculas. Estas 3 letras pueden ser las típicas utilizadas en fox o las que crea automáticamente el C sharp, para mi es indiferente. Ejemplo: lblNombre, btnSalir, etc.
• las variables de clase privadas podremos una p por ejemplo: pnEstado (Esta es privada y númerica).

Así de simple, ni más ni menos. Por otra parte me gustaría aprovechar este artículo para aclarar un concepto importante que suele llevar a confusión a los programadores de Foxpro.

En las clases de Foxpro las variables de las mismas las llamamos propiedades. En Foxpro 9 hay dos tipos de propiedades. Uno las que se comportan como simples variables (osea que se tiene acceso a ellas directamente)  y dos las que se les puede asignar los métodos Access y Assign.

En C Sharp las propiedades de una clase que se comportan como simples variables (osea que se tiene acceso a ellas directamente) se les llama CAMPOS y las propiedades con el método Access y Assign se les llama PROPIEDADES, con la diferencia de que los métodos Access y Assign se llaman get y set.

[003] Inicio, La clase Prg

Vamos a ver como podemos empezar nuestros proyectos de C Sharp si perder de vista la forma de programar que utilizábamos en VisualFoxpro. 

En este artículo vamos a tratar sobre el .NET FRAMEWORK con el que tenemos que trabajar ( Sí un determinado proyecto no nos lo impide) y sobre el Prg de inicio, en este caso el fichero que contiene el método Main en Visual Studio, llamado  [ program.cs ].

Actualmente deberíamos programa con el .NET FRAMEWORK 2.0, y a continuación os argumentaré el porqué de esta decisión. Las razones podrían ser la siguientes, aunque puedes decidir trabajar con otros .NET FRAMEWORK, ya que en el código del fichero principal  [ program.cs ] no hay nada que impida esta decisión:

• Si excluimos XP, Windows 7 (32 y 64) y posteriores incorporan por defecto como mínimo el .NET FRAMEWORK 2.0.
• Su peso para XP no supera los 40 Megas, en el momento de la instalación.
• Esta muy documentado en internet y depurado por Microsoft.

Para mi son suficientes, no se para vosotros. Veamos ahora el código a incorporar en el fichero [ program.cs ]:

01. using System;

02. using System.Collections.Generic;

03. using System.Windows.Forms;

04. using System . IO;

06. 

07. namespace NuestrpPrograma

08.{

09.  static class Prg

10.  { 

11.       public static bool TestMode = false;

12.       public static string LastText = "";

13.       public static string CurDir = "";

14. 

15.       [STAThread]

16.       static void Main()

17.       {

18.          CurDir = Application.ExecutablePath.Substring(0, Application.ExecutablePath.LastIndexOf("\\"));

19. 

20.          if ( File.Exists( CurDir + "\\Logger.Txt" ))  File.Delete( CurDir + "\\Logger.Txt" );

21.          TestMode = ( File . Exists ( CurDir + "\\Test.ON" )  ); 

22.     

23.         Application.EnableVisualStyles();

24.         Application.SetCompatibleTextRenderingDefault(false);

25.         Application.Run(new _screen());

26.       

27.       }

28. 

29.       public static bool Log( string cIn, string cTx )

30.      {

31.         if ( !TestMode )                          { return false; }

32.         if ( cIn + cTx == Prg.LastText )  { return true; }

33.  

34.         try

35.        {

36.

37.        StreamWriter oWriter = File.AppendText(ExecPath + "\\Logger.Txt");

38.        oWriter.WriteLine( "[" + DateTime.Now.Millisecond.ToString("0000") + "] " + cIn + " [ " + cTx + " ]" 39.);

40.        oWriter.Close();

41.

42.        }

43.        catch { return false; }

44.     

45.        Prg.LastText = cIn + cTx;

46.       return true;

47.

48.      }

49.

50.      public static bool Log( string cIn, string cTx, string cFile )

51.     {

52.         if ( !TestMode )                         { return false; }

53.         if ( cIn + cTx == Prg.LastText ) { return true; }

54.  

55.        try

56.       {

57.

58.       StreamWriter oWriter = File.AppendText(ExecPath + "\\" + cFile.Trim() + ".txt");

59.       oWriter.WriteLine( "[" + DateTime.Now.Millisecond.ToString("0000") + "] <" + cIn + " [ " + cTx + " ]" 60.);

61.       oWriter.Close();

62.

63.       }

64.       catch { return false; }

65.  

66.      Prg.LastText = cIn + cTx;

67.      return true;

68.

69.     }

70.  }

71.}

Ok, vamos a desgranar el código expuesto anteriormente...

Lo primero es declarar 3 variables públicas (a parte de todas las que interesen en nuestra aplicación). 

• [Línea 11] La primera es la que yo llamo TestMode, y como el nombre dice nos indicará si estamos en Modo Test. La variable se pondrá a true si existe un fichero al al lado del ejecutable llamado [ Test.ON ], vacío o con contenido, es irrelevante.
• [Línea 12] La segunda LastText contendrá el último texto enviado al fichero [ Logger.Txt ], para evitar que se repitan las entradas en este fichero y facilitar así la lectura del mismo.
• [Línea 13] La tercera es CurDir y contendrá la ruta de nuestro ejecutable la cual nos servirá, de seguro, en múltiples ocasiones.

Ahora vamos a ver lo mínimo y necesario para el contenido del método Main, a la búsqueda de nuestra filosofía Foxpro.

• [Línea 18] Lo primero es cargar la variable CurDir con su correspondiente ruta, la del ejecutable una vez compilado.
• [Línea 20] En esta línea comprobamos si ya existe el fichero [ Logger.Txt ], si es así lo eliminamos para empezar siempre a cargarlo con datos de nuevo.
• [Línea 21] Aquí ponemos la variable TestMode a true si comprobamos que existe, al lado del ejecutable, el fichero [ Test.ON ].
• [Línea 23] y [Línea 24] y [Línea 25] Ejecutamos el formulario _screen, para los programadores de Foxpro esta será la ventana principal de Foxpro y de nuestras Aplicaciones.

Después del método Main tenemos dos métodos más, en realidad uno sobrecargado ( Esto en Fox no se podía realizar ) el método se llama Log, y cuando lo utilicemos en la aplicación lo podemos hacer de dos maneras diferentes.

En la primera cargaremos datos en el fichero [ Logger.Txt ] y en la segunda cargaremos datos en el fichero que queramos. Vamos a ver varios ejemplos:

namespace Application

{

  static class Prg

  {

  public static string CurDir = "";

  public static string LastText = "";

  public static string CurDir = "";

  [STAThread]

  static void Main()

  {

  

  CurDir = Application.ExecutablePath.Substring(0, Application.ExecutablePath.LastIndexOf("\\"));

  Log( "Prg.Main()", + "Path: " + CurDir  );

  if ( File.Exists( CurDir + "\\Logger.Txt" ))  File.Delete( CurDir + "\\Logger.Txt" );

  TestMode = ( File . Exists ( CurDir + "\\Test.ON" )  ); 

 Log( "Prg.Main()", + "Run :screen" );

     

  Application.EnableVisualStyles();

  Application.SetCompatibleTextRenderingDefault(false);

  Application.Run(new _screen());

  }

 }

}

En este caso utilizamos el Log para documentar puntos del arranque de la aplicación. Ten en cuenta que si utilizas el método Log fuera de la clase Prg deberás hacerlo de esta manera:

Prg.Log( "Clase.Metodo()", + "Parametros..." );

La otra forma de utilizar el método Log es indicarle en un parámetro más el nombre del fichero particular donde queremos separar parte de los datos, por ejemplo todo el código relacionado con un determinado formulario (Lo veremos más adelante).

NOTA: No aconsejo, para nada, cargar la clase Prg con más métodos que los que he definido en la misma. 

NEWS [ Futuro de C# ]

Futuras y presentes reflexiones para un programador .NET

Microsoft lleva de calle a todos los "informáticos" que trabajan sobre sus tecnologías. No para de sacar novedades continuas e importantes en todos sus productos, especialmente a los programamdores. Ya que, no solamente la evolución ha sido constante en lo que a las herramientas se refiere, sino que aún han sido más vertiginosas en las posibilidades y capacidades de los diferentes lenguajes de programación que incorpora la plataforma .NET.

Hagamos una reflexión sobre el incierto pero apasionado futuro laboral para los programadores que estamos haciendo aplicaciones informáticas en nuestro trabajo, o como hobby.

Realmente, No importa qué lenguaje aprendas hoy en día. La programación es sobre la implementación de algoritmos. Por lo tanto esa es la habilidad que hay que desarrollar. Así que sólo debes elegir el lenguaje que más te acomode, aprender a usarlo y obtener experiencia en la realización de programas cada vez más complejos.

C# vs el resto de los lenguajes

Aunque nadie lo quiera reconocer, C# empieza a ser la niña bonita en los lenguajes de .NET. Por otr parte no se quiere reconocer que C# es un Java. Eso sí, ya nació genéticamente mejorado en relación a su padre putativo. El paso del tiempo lo ha convertido en un lenguaje mucho más robusto, flexible y que no deja de crecer.

.NET es una plataforma de programación con un horizonte muy lejano y mantiene un ritmo incansable de evolución. Aumentando el nivel de productividad que lo hace muy rentable para ser utilizado en desarrollos profesionales.

Pero no solamente de C# vive .NET y, en una política excelente, se ha implementado en la plataforma más de 50 lenguajes de programación diferentes. Y entre ellos destacar Pyhton, Ruby, Pascal, PHP, etc.

Además sólo hay que seguir el indice TIOBE para comprobar como, de una manera muy estable, va acaparando el mercado de la programación.

Ventajas de utilizar C#

Su facilidad de uso y considerable capacidad para acelerar el tiempo de desarrollo . Por ejemplo, si usted fuera a codificar una calculadora para Windows con una interfaz gráfica totalmente funcional, es posible que tardase varias horas durante un día con C + +, sin embargo, si usted utiliza C # para codificar el mismo programa sólo necesitaría unos 30 minutos. Ese es el poder de C #.

Otra razón de para la utilización de C # son sus IDE, la mayoría vienen con un editor gráfico integrado. Esto le permite editar fácilmente la interfaz gráfica de usuario para programarla en poco tiempo.

Desventajas de utilizar C#

Puesto que C # tiene que cargar su CLR (Common Language Infrastructure) y el Framework. NET cada vez que se ejecuta un programa en C # la carga del mismo es considerablemente mayor que la carga de un programa equivalente en C ++. Por lo tanto, si es vital la velocidad del programa   entonces estarás mucho mejor programado con C o C + +.

Otro gran problema que C # tiene es el hecho de que estás irremediablemente obligado a usar el Framework .NET de Microsoft. Esto significa que es mucho más difícil de transferir su programa de Windows a otro sistema operativo. Sin embargo, la llegada del Proyecto Mono ha hecho esta mucho más fácil de lo que era antes, ahora se puede portar casi cualquier programa en C # que desea tanto Linux y Mac OS.

C # no permite el acceso directo al hardware de la computadora, esto se podría considerar a la vez como bueno y malo. Bueno, porque significa que hay menos de que preocuparse, no tienes que preocuparte de la gestión de memoria y no tienes que preocuparte de los accidentes. Es malo porque tienes mucha menos flexibilidad con tus programas y no los puedes optimizar para el hardware.