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í.

Anuncios
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 »

StringBuilder…

Ante la necesidad de manipular cadenas de caracteres dinámicamente nos encontramos con dos posibilidades:

  1. manejar cadenas con la clase String y realizar sobre él acciones como ser concatenación, reemplazo, inserción, etc.
  2. manejar cadenas con la clase StringBuilder.

Lo más común y más “fácil” es trabajar con String, mantener una instancia e ir realizando tratamientos sobre ella, como ser concatenar strings por medio del operador +,  lo cual nos lleva a crear código poco performante y hasta por momentos engorrosos. Dado que los Strings son de tamaño fijo, al concatenar dos cadenas con el operador + se crea una instancia aparte, lo que  lleva a disminuir el rendimiento debido al mal uso de memoria.

Por lo tanto para operar con cadenas de caracteres lo más formal (y también más óptimo) es utilizar la clase StringBuilder.

¿Qué podemos hacer con  StringBuilder?

La clase StringBuilder nos provee los siguientes métodos:

  • Append: Anexa al final de la instancia la representación en forma de cadena de un objeto especificado.
  • AppendFormat: Anexa a la instancia una cadena con formato, que contiene cero o más especificaciones de formato. Cada especificación de formato se reemplaza por la representación en forma de cadena de un argumento de objeto correspondiente.
  • AppendLine: Anexa el terminador de línea predeterminado, o una copia de una cadena especificada y el terminador de línea predeterminado, al final de esta instancia.
  • CopyTo: Copia los caracteres de un segmento especificado de esta instancia al segmento especificado de una matriz Char de destino.
  • EnsureCapacity: Garantiza que la capacidad de la instancia de StringBuilder corresponde como mínimo al valor especificado.
  • Remove: Elimina de la instancia el intervalo de caracteres especificado.
  • Replace: Reemplaza todas las apariciones de un carácter o cadena en la instancia por otro carácter o cadena especificados.
  • ToString: Sobrecargado. Reemplazado. Convierte el valor de un objeto StringBuilder en un objeto String.

Ejemplo:

usando String:

String mensaje = "Medios de pago excedidos de saldo: ";
foreach (DocSaldo.SaldoRow fila in doc.Saldo.Rows) {
    mensaje += Environment.NewLine + fila.MedioPago;
}

usando String Builder:

StringBuilder mensaje = new StringBuilder("Medios de pago excedidos de saldo:");
mensaje.Append(Environment.NewLine);

foreach (DocSaldo.SaldoRow fila in doc.Saldo.Rows) {
    mensaje.AppendLine(fila.MedioPago);
}
String mensajeString = mensaje.ToString();

Como se puede notar, la segunda opción es más formal y me atrevo a decir “más Orientada a Objetos”.

Una observación adicional es el constructor del StringBuilder, el cual en una de sus sobrecargas nos permite inicializarlo con una cadena de caracteres.

Cuando implementamos la primera opción FxCop nos indica con un issue que debemos cambiarlo por el uso de StringBuilder, que es la segunda opción.

Más información:

http://msdn.microsoft.com/es-es/library/system.text.stringbuilder(VS.80).aspx

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

Cambio de URL…

Como verán, cambie el nombre del blog, por uno un poco más creativo que mi nombre y apellido jejeje.

Gracias Pablo SM por inspirarme en este cambio de nombre!!!