Enumeraciones + manipulación de bits = FLAGS…

Primero, lo primero… qué son las enumeraciones?
Una enumeración (enum) es una forma especial de tipo de valor, que deriva de System.Enum y proporciona nombres alternos para los valores de un tipo primitivo subyacente. Un tipo de enumeración tiene un nombre, un tipo subyacente y un conjunto de campos. (corrección)

Ejemplo:

public enum MessageBoxButtons {
    OK,
    OKCancel,
    AbortRetryIgnore,
    YesNoCancel,
    YesNo,
    RetryCancel
}

MessageBoxButtons boton = MessageBoxButtons.YesNo;

if (boton == MessageBoxButtons.YesNo) {
    //comportamiento propio de YesNo
}
else if (boton == MessageBoxButtons.YesNoCancel) {
    //comportamiento propio de YesNoCancel
}

En el ejemplo muestro la enumeración de MessageBoxButtons, que se utiliza en MessageBox, esta enumeración hace que cada cadena toma un valor (en este caso implícito) empezando por 0. Cada uno de los valores tiene un funcionamiento individual.

Si lo que necesitamos es permitir ingresar combinaciones de valores de la enumeración, lo que debemos usar es una enumeración del tipo Flags.
Las enumeraciones Flags se basan en la utilización de operaciones entre bits de sus valores. En las operaciones de manipulación de bits se utilizan muy frecuentemente los operadores & (AND), | (OR), ^ (XOR) y ~ (NOT). Si no saben como utilizar estos operadores, en este link pueden encontrar una guía en inglés muy interesante.
De antemano les puedo ir diciendo que las combinaciones se hacen (para estos casos) con el operador | y la evaluación de las condiciones con &.

La declaración de una enumeración Flags se hace de la siguiente manera:

[Flags]
public enum NombreEnumeracion {
    Cadena0 = 0, //opcional
    Cadena1 = 1,
    Cadena2 = 2,
    Cadena3 = 4,
    Cadena4 = 8,
    //...
}

Los valores que toman las cadenas son potencias enteras de 2, de ahí el tratamiento de bits.
Nada mejor que un ejemplo para comprender como utlizarlo:

[Flags]
public enum TipoLimpieza {
   Ninguna = 0,
   Cliente = 1,
   Servicio = 2,
   Todo = Cliente | Servicio
}

esta enumeración la utilicé en una tarea que tuve en la cual debía limpiar el caché de datos en el cliente, en el servidor, o en ambos…
Acá va la implementación:

TipoLimpieza tipo = (TipoLimpieza)objetoTipoLimpieza;

if (tipo == TipoLimpieza.Cliente) {
    //1. limpieza SOLO en cliente
}
if ((tipo & TipoLimpieza.Cliente) == TipoLimpieza.Cliente) {
   //2. limpieza en cliente, ya sea Cliente sólo o Cliente y Servicio
}
if ((tipo & TipoLimpieza.Servicio) == TipoLimpieza.Servicio) {
   //3. limpieza en servicio, ya sea servicio sólo o Servicio y Cliente
}
//notar que por la enumeración 0 (Ninguno) no se hace nada

entonces, al utilizarlo con los distintos valores:

//cuando:
tipo = TipoLimpieza.Ninguna;
//no se realiza nunguna operación.

//cuando:
tipo = TipoLimpieza.Cliente;
//se ejecuta el código de las condiciones: 1 y 2.

//cuando:
tipo = TipoLimpieza.Servicio;
//se ejecuta el código de la condición: 3.

//cuando:
tipo = TipoLimpieza.Cliente | TipoLimpieza.Servicio;
//se ejecuta el código de la condición: 2 y 3.
Publicado en C#. Etiquetas: . Leave a Comment »

Expresiones Regulares (Regex)…

Es común trabajar con expresiones regulares en los casos en que necesitamos saber si una cadena específica de caracteres cumple un patrón específico (lo que sería un expresión) y realizar alguna acción en base a ello.
Si no tienes conocimientos sobre expresiones regulares puedes comenzar aquí.

Un ejemplo en el que utilizaríamos expresiones regulares sería si necesitamos validar que una cadena ingresada por el usuario es un mail válido (cumpliendo con el formato común). También puede utilizarse para reemplazar partes de un texto que cumplen expresiones regulares.

En .Net, contamos con la clase Regex, la cual nos brinda varios métodos para manejar expresiones regulares.

[SerializableAttribute] 
public class Regex : ISerializable

Les muestro dos ejemplos de la utilización de Regex:
1. Validar los mails ingresados:

private const String PATRON_MAIL = @"^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$";

private void ValidarMails() {
    String[] mails = new String[3];
    mails[0] = "mimail@mail.com";
    mails[1] = "mimailmail.com";
    mails[2] = "mimail@mailcom";

    Regex reg = new Regex(PATRON_MAIL, RegexOptions.Singleline);

    foreach (String mail in mails) {
        if (reg.IsMatch(mail)) {
            Console.WriteLine("Mail: {0} es válido", mail);
        }
        else {
            Console.WriteLine("Mail: {0} es inválido", mail);
        }
    }
}

si es una llamada simple podemos utilizar el método estático:

Regex.IsMatch(textoAValidar, patron);

Resultado:
Mail: mimail@mail.com es válido
Mail: mimailmail.com es inválido
Mail: mimail@mailcom es inválido

2. Reemplazar una cadena a través de una expresión regular:

private const String PATRON_MAYOR = “[^>]>[^>]”;

private void ReemplazarTexto() {
String textoACambiar = “numero1>numero2>numero3”;

Regex rexMayores = new Regex(PATRON_MAYOR, RegexOptions.Singleline);

String textoNuevo = rexMayores.Replace(textoACambiar,
delegate(Match m) {
return String.Format(“{0}<{1}", m.Value[0], m.Value[2]); } ); Console.WriteLine("Antes {0} ahora {1}", textoACambiar, textoNuevo); } [/sourcecode] Resultado
Antes numero1>numero2>numero3 ahora numero1<numero2<numero3

En el ejemplo hicimos uso de un método anónimo el cual recibe como párametro un objeto Match, este método es el encargado de devolver el texto por el cual se reemplazará la cadena que coincide con la expresión regular. El método anónimo será ejecutado dos veces, una vez por cada fragmento de texto que cumpla con la expresión regular.

Ejemplos y más información sobre expresiones regulares: http://www.regular-expressions.info/.
Más ejemplos en .Net: http://msdn.microsoft.com/es-es/library/kweb790z(VS.80).aspx.
Una herramienta muy útil para crear y probar expresiones regulares es Rad Software Regular Expression Designer: http://www.radsoftware.com.au/regexdesigner/

Publicado en C#. Etiquetas: . Leave a Comment »

Código fuente en WordPress!…

Para darle formato a un código fuente que subas a WordPress sólo tienes que encerrar el código fuente con los tags:


…Código fuente…

donde lenguajeCodigoFuente es alguno de los siguientes:

  • cpp
  • csharp
  • css
  • delphi
  • html
  • java
  • jscript
  • php
  • python
  • ruby
  • sql
  • vb
  • xml

Como resultado obtenemos:

Es por demás de estético..
Gracias WordPress por incluirlo!
Más que gracias SyntaxHighlighter por darnos la funcionalidad…

Para más información en WordPress vea el how to…

Para más información sobre SyntaxHighlighter y para aplicarlo sobre páginas propias u otros blogs, visitelo aquí.

Publicado en Wordpress. Etiquetas: . 2 Comments »

Como implementar correctamente IDisposable…

Primero lo primero… La interface IDisposable define un método “personalizado” para liberar los recursos administrados y no administrados.
IDisposable se usa principalmente para liberar los recursos no administrados, ya que el recolector de elementos no utilizados (GC: Garbage Collector) libera automáticamente la memoria asignada a un objeto administrado cuando ya no se utiliza, pero no se puede prever cuándo se producirá la recolección de elementos no utilizados. Además, el GC no reconoce recursos no administrados, como ser objetos de tipos File y Font.

A continuación, les muestro el código de ejemplo y aclaraciones sobre la implementación de una clase IDisposable:

public class ClaseDisposable : IDisposable {
    // Recursos manejados
    private Component componentes = new Component();
    private DataSet dataSetDisposable = new DataSet();

    // Indica si ya se llamo al método Dispose. (default = false)
    private Boolean disposed;

    /// <summary>
    /// Implementación de IDisposable. No se sobreescribe.
    /// </summary>
    public void Dispose() {
        this.Dispose(true);
        // GC.SupressFinalize quita de la cola de finalización al objeto.
        GC.SuppressFinalize(this);
    }

    /// <summary>
    /// Limpia los recursos manejados y no manejados.
    /// </summary>
    /// <param name="disposing">
    /// Si es true, el método es llamado directamente o indirectamente
    /// desde el código del usuario.
    /// Si es false, el método es llamado por el finalizador
    /// y sólo los recursos no manejados son finalizados.
    /// </param>
    protected virtual void Dispose(bool disposing) {
        // Preguntamos si Dispose ya fue llamado.
        if (!this.disposed) {
            if (disposing) {
                // Llamamos al Dispose de todos los RECURSOS MANEJADOS.
                this.componentes.Dispose();
                this.dataSetDisposable.Dispose();
            }

            // Acá finalizamos correctamente los RECURSOS NO MANEJADOS
            // ...

        }
        this.disposed = true;
    }

    /// <summary>
    /// Destructor de la instancia
    /// </summary>
    ~ClaseDisposable() {
        this.Dispose(false);
    }
}

Podemos agregar que el método Dispose(bool disposing) es virtual, por lo que podemos redefinirlo en clases que hereden de esta, por lo cual en dichas clases no necesitamos implementar nuevamente IDisposable. Un ejemplo de este comportamiento es un Formulario que hereda (obviamente) de Form, como vemos a continuación, en Designer tenemos el siguiente código:

/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing) {
     if (disposing && (components != null)) {
          components.Dispose();
     }
     base.Dispose(disposing);
}

También podemos ver como sería la llamada a Dispose. Hay dos tipos de llamadas, la directa y la indirecta:
Llamada Directa:

ClaseDisposable objetoDisposable = new ClaseDisposable();
// utilizamos el objetoDisposable
// ...
// y lo finalizamos:
objetoDisposable.Dispose();

Llamada Indirecta:

using (ClaseDisposable objetoDisposable = new ClaseDisposable()) {
    // utilizamos el objetoDisposable
    // ...
}
//se finaliza automáticamente al salir del using

Más información sobre using…

Espero que les sea útil.
(FxCop nos sugiere la implementación de IDisposable de esta manera cuando nuestra clase trabaja con recursos administrados y que implementan el método Dispose… Es bueno hacerle caso, implementando IDisposable como corresponde 😀 )

Publicado en C#, Tips. Etiquetas: . Leave a Comment »

Necesitas ayuda?…

Si necesitas ayuda sobre algún tema relacionado con la programación, si tenés preguntas o si simplemente te gustaría saber un tema en particular, el momento es este, realiza tu comentario en este post o en cualquier otro y veré de contestarlo.

Por mi parte pondré el mayor de los empeños, pero si es un tema que me supera, veremos de solucionarlo en equipo (conjuntamente con los lectores y/o blogs amigos)…

😀

Error: No se puede resolver el conflicto de intercalación entre “Modern_Spanish_CI_AS” y “Modern_Spanish_CI_AI” de la operación equal to…

Problema:

Al ejecutar un SP se produce el siguiente error: “No se puede resolver el conflicto de intercalación entre “Modern_Spanish_CI_AS” y “Modern_Spanish_CI_AI” de la operación equal to.”

Solución:

El SP contiene variables de nombre incorrecto o incompatible a la configuración. Revisar cuidadosamente el nombre de las variables.

En mi caso tenía una tabla declarada como sigue

CREATE TABLE #Creditos(EMPRESA UNIQUEIDENTIFIER, CODSUC varchar(50), CREDITO INT);

y la usaba en múltiples lugares. Al hacer

SELECT * FROM #Creditos

se producía el error aquí descripto. Renombré #Creditos por vCreditos y funcionó de maravillas.
Intuyo que esto debe ser a algún tipo de configuración de idioma que no he encontrado.

Publicado en Errores. Etiquetas: . Leave a Comment »

Operador as…

Les presento el operador as, es un operador de conversión bastante conocido, pero tiene características muy útiles que son interesantes de recalcar.

El operador as se utiliza para realizar conversiones entre tipos de referencia compatibles.

Veamos:

String cadena = objetoCadena as String;

sería (pero no lo es del todo) equivalente a:

String cadena = (String)algunObjeto;

Pero… ¿cuál es la verdadera diferencia?.
El operador as es similar a una operación de conversión de tipos; sin embargo, si la conversión no es posible, as devuelve null en lugar de producir una excepción.

Formalmente podemos decir que el operador realiza lo siguiente:

expresion is tipo ? (type)expresion : (type)null;

entonces lo utilizamos de la siguiente forma:

String cadena = objetoCadena as String;
if (cadena != null) {
    //objetoCadena ES un String.
}
else {
    //objetoCadena NO ES un String.
}

que es equivalente (y más performante) a:

if (objetoCadena is String) {
    //objetoCadena ES un string.
    String cadena = (String)objetoCadena;
}

NOTA: digo que as es más performante que el último ejemplo porque al realizar “objetoCadena is String” se realiza un casteo interno, siendo que después nosotros nuevamente lo realizamos dentro del if.
(FxCop notifica con un issue que realicemos este cambio de implementación)

Publicado en C#, Tips. Etiquetas: . 2 Comments »