Mensajería única

Mensajería única
Estaba mejorando mi sistema de mensajería para mis aplicaciones y he pensado, ¿por qué no lo publicas?, pues ahí va. (Este en concreto es con WPF)
Cuando desarrollo mis aplicaciones, intento que todas tengan un sistema de mensajería con el que pueda comunicarse cualquier ventana de la aplicación con esta, de modo que generando un mensaje por ejemplo, “cargando caché de datos…” y una barra de progreso indique su estado, aparezca en la barra de estado o mediante un cuadro de dialogo, el mensaje “cargando caché de datos…” y la barra aumente su progreso, de modo que si tengo varias ventanas abiertas, podría visualizar los mismos mensajes en todas y esto mediante un ejemplo os lo voy a mostrar. Para comenzar creo una clase llamada Message que contiene cuatro propiedades, infoText que almacena el texto del mensaje principal, progress que almacena el valor del progreso, progressIsVisible que almacena si la barra de progreso es visible y por último infoText2 que almacena un segundo texto por si acaso lo necesito.
A esta clase le añado varios eventos, por si acaso los necesito, que son cuando cambia el texto del mensaje o cuando cambia el progreso. Extiendo varios EventArgs con EventArgsMessage para obtener los valores nuevo y antiguos y el valor del progreso EventArgsProgress. Contiene dos métodos, uno para asignar los valores de la propiedades y otro para borrarlos.
Por otra parte creo una colección del tipo ObservableCollection en la clase App de la aplicación de modo que cualquier ventana puede acceder a esta colección si la hacemos pública, la cual contiene un evento CollectionChanged el cual usaremos en cada ventana para capturar los mensajes.

public static ObservableCollection<Message>; messages = new ObservableCollection<Message>();

Y ahora solo nos queda capturar los eventos en cada ventana. Para ver esto, voy a crear una ventana principal que iniciará un hilo desde un botón con un proceso que suma desde 1 hasta 100 con un retardo de 50 ms y que en cada incremento, actualizará un control Textblock con el texto del mensaje y una barra de progreso con un valor. Al mismo tiempo, abriré otra ventana en la aplicación con un TextBlock y otra barra de progreso que deberían actualizarse de igual modo que lo hace la ventana principal y sin albergar ningún código en ella que le permita incrementar nada ni mostrar nada. Para mostrar el mensaje y actualizar las barras uso un delegado en cada ventana que se encargará de hacer este trabajo y para acceder a los controles sin errores, Dispatcher.Invoke(new MessageAddedHandler(setMessage), message) invocando al delegado y como argumento el nuevo mensaje. ¿Qué resultado obtendremos? Dos ventanas, la que contiene el botón y la que no. Al pulsar se inicia la carga y en ambas ventanas se actualizan tanto el texto como el valor de la barra de progreso al mismo tiempo.

Pasamos al código.

Clase Message

using System;
namespace WpfApplication1
{
    public class Message
    {
        #region Constructor
        public Message()
        {
            this.infoText = "";
            this.progress = 0;
            this.progressIsVisible = false;
        }
        public Message(string _text, bool _isVisible, int _progress)
        {
            setMessage(_text, _isVisible, _progress);
        }
        #endregion
        #region Properties
        private string _infotext;
        private int _progress;
        public int progress
        {
            get { return _progress; }
            set
            {
                if (_progress!=value)
                {
                }
                _progress = value;
            }
        }
        public string infoText
        {
            get { return _infotext; }
            set
            {
                if (_infotext!=value)
                {
                    EventArgsMessage eventArgsMessage = new EventArgsMessage(_infotext,value);
                }
                _infotext = value;
            }
        }
        public bool progressIsVisible { get; set; }
        public string infoText2 { get; set; }
        #endregion
        #region Events
        public event EventHandler<eventargsmessage> ChangedTextEventHandler;
        public event EventHandler<eventargsprogress> ChangedProgressEventHandler;
        #endregion
        #region Private Methods
        void OnChangedText(EventArgsMessage e)
        {
            if (ChangedTextEventHandler!=null)
            {
                ChangedTextEventHandler(this, e);
            }
        }
        void OnChangedProgress(EventArgsProgress e)
        {
            if (ChangedProgressEventHandler!=null)
            {
                ChangedProgressEventHandler(this, e);
            }
        }
        #endregion
        #region Public Methods
        ///
<summary>
        /// Asigna los valores al mensaje
        /// </summary>

        /// <param name="_text" />Texto del mensaje
        /// <param name="_isVisible" />Visibilidad del mensaje
        /// <param name="_progress" />Progreso
        public void setMessage(string _text, bool _isVisible, int _progress)
        {
            this.infoText = _text;
            this.progressIsVisible = _isVisible;
            this.progress = _progress;
        }
        ///
<summary>
        /// Borra los valores del mensaje
        /// </summary>

        public void Clear()
        {
            setMessage("", false, 0);
        }
        #endregion
    }
    public class EventArgsMessage:EventArgs
    {
        public EventArgsMessage() { }
        public EventArgsMessage (string _oldText, string _newText)
        {
            this.oldText = oldText;
            this.newText = _newText;
        }
        public string oldText { get; set; }
        public string newText { get; set; }
    }
    public class EventArgsProgress : EventArgs
    {
        public EventArgsProgress() { }
        public EventArgsProgress(int _newValue)
        {
            this.newValue = _newValue;
        }
        public int newValue { get; set; }
    }
}

Clase <code>App</code>

public partial class App : Application
    {
        public static ObservableCollection<message> messages = new ObservableCollection<message>();

        public App()
        {

        }
    }

Ventana principal con método de cálculo

Constructor

public MainWindow()
        {
            InitializeComponent();
            App.messages.CollectionChanged += Messages_CollectionChanged;
            Window1 w1 = new Window1();
            w1.Show();
        }

Propiedades. El delegado, un objeto CancellationTokenSource para cancelar el proceso y un flag para saber si la app está corriendo o no.

        delegate void MessageAddedHandler(Message _message);
        CancellationTokenSource cs;
        public bool isRunning { get; set; } = false;

Captura del evento. Ocurre cuando la colección cambia.

void Messages_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action==System.Collections.Specialized.NotifyCollectionChangedAction.Add)
            {
                foreach (var item in e.NewItems)
                {
                    Dispatcher.Invoke(new MessageAddedHandler(setMessage), (Message)item);
                }
            }
            else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset)
            {
                Dispatcher.Invoke(new MessageAddedHandler(setMessage), new Message());
            }

        }

Métodos. El primer método asigna un mensaje a los controles, el segundo inicia el proceso o lo cancela y el tercero suma 1 después de 50 ms: una vez que acaba, finaliza y borra los mensajes.

void setMessage(Message message)
        {
            this.textBlock.Text = message.infoText;
            this.pb.Value = message.progress;
            this.pb.Visibility = message.progressIsVisible ? Visibility.Visible : Visibility.Collapsed;
        }

         private void button_Click(object sender, RoutedEventArgs e)
        {
            if (isRunning)
            {
                this.button.Content = "Iniciar";
                cs.Cancel();
            }
            else
            {
                isRunning = true;
                cs = new CancellationTokenSource();
                this.button.Content = "Cancelar";
                var t = Task.Factory.StartNew(() => doSomeThing(cs.Token),cs.Token);

            }
        }
        void doSomeThing(CancellationToken ct)
        {
            try
            {
                for (int i = 0; i <= 100; i++)
                {
                    ct.ThrowIfCancellationRequested();
                    Thread.Sleep(50);
                    App.messages.Add(new Message(String.Format("Cargando {0}", i), true, i));
                }
                App.messages.Clear();
            }
            catch (OperationCanceledException ex)
            {
                isRunning = false;
                App.messages.Clear();
                return;
            }
        }

Ventana que captura mensajería. En esta ventana solo se captura el evento cuando la colección cambia y la asignación de los valores al mensaje.

public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
            App.messages.CollectionChanged += Messages_CollectionChanged; ;
        }
        delegate void MessageAddedHandler(Message _message);
        private void Messages_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
            {
                foreach (var item in e.NewItems)
                {
                    Dispatcher.Invoke(new MessageAddedHandler(setMessage), (Message)item);
                }
            }
            else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset)
            {
                Dispatcher.Invoke(new MessageAddedHandler(setMessage), new Message());
            }
        }
        void setMessage(Message message)
        {
            this.textBlock.Text = message.infoText;
            this.pb.Value = message.progress;
            this.pb.Visibility = message.progressIsVisible ? Visibility.Visible : Visibility.Collapsed;
        }
    }
}

y con todo funcionando, cada vez que iniciemos desde la ventana principal el proceso, las dos ventanas deben mostrar el mismo texto y el mismo progreso.Os dejo el proyecto completo en el enlace.

Saludos

Calculadora IP

Calculadora IP

Hola a tod@s

Aquí os muestro una pequeña calculadora de direcciones IP desarrollada en WPF y C# .NET 4.5 y con la que vemos una pequeña demostración de una clase y su funcionamiento.

CalIP01

El funcionamiento de la app es muy fácil, cuadros de texto para la IP y cuadro de texto para la máscara de subred con notación CIDR que quiere decir que el número introducido, indica el número de bits a 1 de la máscara de subred, es decir si introduzco 28, quiere decir que la máscara tiene 28 bit a 1, lo que sería:

11111111 11111111 11111111 11110000

el equivalente a 255.255.255.240.

A continuación adjunto la clase la cual no tiene ningún misterio (no he sido muy exquisito en cuanto a código, pero para aprender creo que está bien), propiedades públicas con los resultados y los métodos que si detallo:

CalIP02

Métodos públicos

  • SetNetAddress. Asigna la dirección de red
  • SetBroadCast. Asigna el Broadcast
  • SetIPt. Asigna la dirección ip
  • SetNetType. Asigna el tipo de red (A,B,C,D o E)
  • SetHostMin.Asigna a la propiedad el valor de host mínimo de la red
  • SetHostMax. Asigna a la propiedad el valor máximo de la red
  • GetIPToString. Obtiene la IP como un valor de cadena de la forma XXX.XXX.XXX.XXX
  • GetIPBinaryToString. Obtiene la IP como un valor de cadena en binario.

Métodos privados

  • NotifyPropertyChanged. Método delegado del evento cuando no es válida la IP. De esta manera, desde la clase donde instancio esta, puedo capturar si la IP no es válida e indicarlo.
  • BinaryToDecimal. Método sobrecargado para convertir números o direcciones ip de binario a decimal.
  • DecimalToBinary. Método sobrecargado para convertir números o direcciones ip de decimal a binario.
  • OperationOR. Operador OR sobre la dirección IP para obtener la máscara de entrada
  • OperationAND. Operador AND sobre la la dirección IP para obtener el broadcast
  • OperationNOT. Operador NOT sobre la la dirección IP para obtener el broadcast junto con el operador AND.
  • ValidateIP. Valida la IP, comprobando que sus valores son correctos y está bien formada.

Nota: Recordad que para obtener la dirección del red, se realiza la operación AND entre la IP y la máscara de subred y que para obtener el broadcast, se utiliza el operador OR entre la IP y la NOT de la máscara de subred (donde hay ceros, cambio a unos y viceversa).

OPERADOR AND
a
b
RESULTADO(Q)
0
0
0
0
1
0
1
0
0
1
1
1

 

OPERADOR OR
a
b
RESULTADO(Q)
0
0
1
0
1
1
1
0
1
1
1
0

 

OPERADOR NOT
a
RESULTADO(Q)
0
0
0
0

Si alguno ha dado el algebra de Boole, recordáis que a AND b= NOT (a OR b)?
solo hay que mirar la tabla AND y la OR, donde hay un 1 en la otra hay un 0!
y por último el símbolo de estos operadores (y de alguno más) es:
(una puerta NOR es una OR con una NOT, que es la que usamos para obtener el broadcast)

Para descargar la calculadora IP, pulsar aquí

Espero que os sirva y adjunto el código de la clase principal.

/* ************************************************************************************************************************************************
* © JOAQUIN MARTINEZ RUS 2015
* PROYECTO:         IpAddress Calculator
* Nombre:           AndrewWiles
* Archivo:          IpAddress.cs
* Descripción:      Clase principal
* Historial:
*                   1. Joaquin Martínez Rus - 13 ene 2016. Creación
*
* Comentarios:      Calculador de redes
*
*
**************************************************************************************************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.ComponentModel;

namespace AndrewWiles
{
    public class IpAddress:INotifyPropertyChanged
    {
        public IpAddress()
        {
            CreateArrays();
            this.IP = "0.0.0.0";

        }

        public IpAddress(string ip)
        {
            CreateArrays();
            this.IP = ip;

        }

        #region Propiedades, eventos

        public event PropertyChangedEventHandler PropertyChanged;

        private string _ip;

        public string IP
        {
            get { return _ip; }
            set
            {
                _ip = value;

                IsValidIP = this.ValidateIP();

                if (IsValidIP)
                {
                    ipNumbers = _ip.Split('.');

                    for (int i = 0; i < ipNumbers.Length; i++)
                    {
                        ipNumbersByte[i] = DecimalToBinary(ipNumbers[i]);
                    }
                }
            }
        }
        public string[] ipNumbers { get; set; }
        public string[] ipNumbersByte { get; set; }
        public string[] NetWorkAddress { get; set; }
        public string[] Broadcast { get; set; }
        public string[] NetMask { get; set; }
        public string[] HostMin { get; set; }
        public string[] HostMax { get; set; }

        public string IpClass { get; set; }
        public string NetID { get; set; }
        public string HostID { get; set; }
        public int Hosts { get; set; }

        private int netMaskCIDR;

        public int NetMaskCIDR
        {
            get { return netMaskCIDR; }
            set
            {
                netMaskCIDR = value;
                this.ConvertCIDRToNetMask();
            }
        }

        private bool isValidIP;

        public bool IsValidIP
        {
            get { return isValidIP; }
            set
            {
                isValidIP = value;
                NotifyPropertyChanged("ValidIP");
            }
        }

        #endregion

        #region Métodos públicos

        public void SetNetAddress()
        {
            this.NetWorkAddress = this.OperationAND(this.ipNumbers, this.NetMask);
        }

        public void SetBroadCast()
        {
            this.Broadcast= this.OperationOR(this.ipNumbers, this.OperationNOT(this.NetMask));
        }

        public void SetIP(string ip)
        {
            this.IP = ip;
        }

        public void SetNetType()
        {
            if (ipNumbersByte[0].Substring(0,1)=="0")
            {
                this.IpClass = "A";
            }
            if (ipNumbersByte[0].Substring(0, 2) == "10")
            {
                this.IpClass = "B";
            }
            if (ipNumbersByte[0].Substring(0, 3) == "110")
            {
                this.IpClass = "C";
            }
            if (ipNumbersByte[0].Substring(0, 4) == "1110")
            {
                this.IpClass = "D";
            }
            if (ipNumbersByte[0].Substring(0, 4) == "1111")
            {
                this.IpClass = "E";
            }

        }

        public void SetHostMin()
        {
            this.NetWorkAddress.CopyTo(this.HostMin,0);
            this.HostMin[3]= (Convert.ToInt16(this.HostMin[3]) + 1).ToString();
        }

        public void SetHostMax()
        {
            this.Broadcast.CopyTo(this.HostMax, 0);
            this.HostMax[3] = (Convert.ToInt16(this.HostMax[3]) - 1).ToString();
        }

        public string GetIPToString(string [] ip)
        {
            string ipToString = "";

            foreach (var item in ip)
         {
                ipToString += item + ".";
         }

            return ipToString.Substring(0, ipToString.Length - 1);
        }

        public string GetIPBinaryToString(string[] ip)
        {
            string ipToString = "";

            foreach (var item in ip)
            {
                ipToString += this.DecimalToBinary(item) + "  ";
            }

            return ipToString.Substring(0, ipToString.Length - 1);
        }

        #endregion

        #region Métodos privados

        #region Métodos de Eventos

        private void NotifyPropertyChanged(string property)
        {
            var handler = this.PropertyChanged;

            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(property));
            }
        }

        #endregion

        #region Operaciones Binarias

        private string[] BinaryToDecimal(string[] aByte)
        {
            string[] bytes = new string[4];

            for (int i = 0; i < aByte.Length; i++)
            {
                bytes[i] = BinaryToDecimal(aByte[i]);
            }

            return bytes;
        }

        private string BinaryToDecimal(string aByte)
        {
            double aux = 0;

            for (int i = 0; i < aByte.Length; i++)
            {
                double potencia = Math.Pow(2, i);
                double digito=Convert.ToInt16(aByte.Substring(aByte.Length-1-i,1));
                aux += (potencia * digito);
            }

            return aux.ToString();
        }

        private string[] DecimalToBinary(string[] aByte)
        {
            string[] bytes = new string[4];

            for (int i = 0; i < aByte.Length; i++)
            {
                bytes[i] = DecimalToBinary(aByte[i]);
            }

            return bytes;
        }

        private string DecimalToBinary(string aByte)
        {
            int entero=Convert.ToInt32(aByte);
            return Convert.ToString(entero,2).PadLeft(8,'0');
        }

        public string[] OperationOR(string[] ip1, string[] ip2)
        {
            string[] CalculoOR = new string[4];

            for (int i = 0; i < ip1.Length; i++)
            {
                int a= Convert.ToInt32(ip1[i]);
                int b= Convert.ToInt32(ip2[i]);
                string o = (a | b).ToString();
                CalculoOR[i] = o;
            }

            return CalculoOR;
        }

        public string[] OperationAND(string[] ip1, string[] ip2)
        {
            string[] CalculoAND = new string[4];

            for (int i = 0; i < ip1.Length; i++)
            {
                int a = Convert.ToInt32(ip1[i]);
                int b = Convert.ToInt32(ip2[i]);
                string o = (a &amp;amp;amp;amp;amp; b).ToString();
                CalculoAND[i] = o;
            }

            return CalculoAND;
        }

        public string[] OperationNOT(string[] ip)
        {
            string[] CalculoNOT = new string[4];

            for (int i = 0; i < ip.Length; i++)              {                  string number = this.DecimalToBinary(ip[i]);                   string notNumber = "";                  foreach (var item in number)                  {                      notNumber += item == '0' ? '1' : '0';                  }                  CalculoNOT[i] = this.BinaryToDecimal(notNumber);              }              return CalculoNOT;          }           #endregion          #region Cálculos con Direcciones          private void ConvertCIDRToNetMask()          {              string unos = "";              string ceros = "";              int resto = 32 - this.NetMaskCIDR;              string netmaskTemporal = unos.PadRight(this.NetMaskCIDR, '1') + ceros.PadRight(resto, '0');              string a = netmaskTemporal.Substring(0, 8);              string b = netmaskTemporal.Substring(8, 8);              string c = netmaskTemporal.Substring(16, 8);              string d = netmaskTemporal.Substring(24, 8);              this.NetMask[0] = BinaryToDecimal(a);              this.NetMask[1] = BinaryToDecimal(b);              this.NetMask[2] = BinaryToDecimal(c);              this.NetMask[3] = BinaryToDecimal(d);              this.Hosts = (int)Math.Pow(2, resto) - 2;          }          #endregion          #region Validaciones          private bool ValidateIP()          {              return ValidateIP(this.IP);          }          private bool ValidateIP(string ip)          {              bool isValid = false;              Regex regexip = new Regex(@"\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b");              MatchCollection result = regexip.Matches(ip);              if (result.Count > 0)
             {
                isValid = true;
             }
             else
             {
                isValid = false;
             }

            return isValid;
        }

        #endregion

        #region Genéricas

        private void CreateArrays()
        {
            ipNumbers = new string[4];
            ipNumbersByte = new string[4];
            NetWorkAddress = new string[4];
            Broadcast = new string[4];
            NetMask = new string[4];
            HostMin = new string[4];
            HostMax = new string[4];
        }

        #endregion

        #endregion
    }

    public class IPData
    {
        public IPData(string texto, string data, string binary)
        {
            this.Texto = texto;
            this.Data = data;
            this.Binary = binary;
        }

        public string Texto { get; set; }
        public string Data { get; set; }
        public string Binary { get; set; }

    }
}

Saludos

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

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”