Eventos en VB.Net y C#

Una de las cosas que más me ha llamado la atención en el cambio de VB a C# ha sido la diferencia de cómo tratan ambos lenguajes el tema de los eventos. Me imagino que estaba demasiado acostumbrado a crear eventos en VB y, sencillamente, no contemplaba ya otras opciones. De hecho, antes del .Net, en VB 6.0, ya creábamos los eventos en aquellas “maravillosas clases”:

VB. 6.0

Ejemplo de clase de VB 6.0 con un evento definido:

' --------------------------------------------------------------------------
' PruebasContador
' Clase de pruebas de eventos
'
' alskare, Jul/09
' --------------------------------------------------------------------------
Option Explicit


' Declaración del evento público de pruebas
Public Event MiEvento(ByVal NumeroActual As Integer)


Private contador As Integer


' Rutina que realiza una cuenta y dispara el evento
Public Sub Inicio()
    contador = 0
    Dim i As Integer
    For i = 1 To 1000
        If i Mod 10 = 0 Then
            RaiseEvent MiEvento(i)
        End If
    Next i
End Sub

 

Con algo tan simple como esto (la verdad es ahora lo veo simple, pero reconozco que me costó lo suyo entenderlo en su día), era frecuente añadir la rutina que capturaba el evento en algún que otro formulario, más o menos como el ejemplo que incluyo a continuación:

' --------------------------------------------------------------------------
' Form: EjecutaPruebas
' Formulario de ejecución de las pruebas
'
' alskare, Jul/09
' --------------------------------------------------------------------------
Option Explicit


' Declaración de la clase
Private WithEvents c As PruebasContador



Private Sub Form_Load()
    ' Instancia de la clase
    Set c = New PruebasContador
    ' Ejecución del módulo de la clase que inicia el contador y dispara el
    ' evento
    c.Inicio
End Sub


' Captura del evento. En el ejemplo sólo muestra el resultado en la ventana
' de inmediato.
Private Sub c_MiEvento(ByVal NumeroActual As Integer)
    Debug.Print NumeroActual
End Sub

 

Bueno, el caso es que, acostumbrado a esto, no noté una gran diferencia en VB.Net y enseguida me acostumbré a hacer uso de las facilidades que me suministraba el .Net Framework como el usar clases como parámetros en los eventos.

VB.NET

Así, una hipotética adaptación de VB6 a VB.Net del ejemplo del contador anterior podía haber sido algo como lo siguiente:

 

' -----------------------------------------------------------------------------
' Pruebas de eventos
' 
' alskare, Jul/09
' -----------------------------------------------------------------------------
Option Explicit On
Option Strict On


Namespace jnSoftware.Pruebas.Eventos

    ''' <summary>
    ''' ContadorEvents. Clase que se usará como parámetro en el disparador.
    ''' La clase contiene la propiedad Contador que incluirá el valor a "traspasar" entre
    ''' la clase disparadora y la clase receptora
    ''' </summary>
    Public Class ContadorEvents
        Inherits EventArgs

        Private _contador As Integer
        Public Property Contador() As Integer
            Get
                Return _contador
            End Get
            Set(ByVal value As Integer)
                _contador = value
            End Set
        End Property
    End Class


    ''' <summary>
    ''' PruebasContador. Al igual que en el ejemplo de VB6, sólo contiene un método que 
    ''' dispara el evento
    ''' </summary>
    Public Class PruebasContador

        ' Declaración del evento público de pruebas
        Public Event MiEvento(ByVal sender As Object, ByVal e As ContadorEvents)

        Private _contador As Integer = 0
        Private _campoContadorEvents As ContadorEvents = New ContadorEvents()

        Public Sub Inicio()
            For i As Integer = 1 To 1000
                If i Mod 10 = 0 Then
                    _campoContadorEvents.Contador = i
                    RaiseEvent MiEvento(Me, _campoContadorEvents)
                End If
            Next
        End Sub
    End Class


    ''' <summary>
    ''' Clase que ejecuta las pruebas. 
    ''' </summary>
    ''' <remarks></remarks>
    Public Class PruebasEventosVB

        Private Shared WithEvents c As New PruebasContador


        Public Shared Sub Main()
            c.Inicio()
            Console.ReadKey()
        End Sub


        ' Cada vez que se dispara el evento en la clase PruebasContador, se ejecuta este método pudiendo leer el 
        ' valor del contador gracias al parámetro del contador e.Contador
        Private Shared Sub MuestraProgreso(ByVal sender As Object, ByVal e As ContadorEvents) Handles c.MiEvento
            Console.WriteLine("Número {0}", e.Contador)
        End Sub

    End Class

End Namespace

 

He intentado seguir la misma nomenclatura que la usada en el ejemplo de VB6 para poder realizar las comparaciones. Es de destacar el método MuestraProgreso, que queda “vinculado” al disparador gracias a la cláusula Handles que se incluye después de la firma estándar. La cláusula Handles es de lo que me llamó más la atención puesto que podía vincularse un mismo método a los eventos de varios objetos, siempre que incluyesen la misma firma (ideal para capturar eventos de controles de formularios).

La vinculación del evento al método podríamos haberla creado de modo dinámico sin incluir la cláusula Handles. Esto me ha sido muy práctico cuando se trata de crear controles dinámicamente o cuando he tenido algún que otro problema de rendimiento al dispararse demasiadas veces algún evento. Así, una modificación que podríamos realizar en la clase PruebasEventos para que se vincule el evento de un modo dinámico sería algo así como:

 

Public Class PruebasEventosVB

    Private Shared WithEvents c As New PruebasContador


    Public Shared Sub Main()

        ' Vinculación del evento al módulo MuestraProgreso
        AddHandler c.MiEvento, AddressOf MuestraProgreso

        c.Inicio()

        ' Casi del mismo modo se podría desvincular
        RemoveHandler c.MiEvento, AddressOf MuestraProgreso

        Console.ReadKey()
    End Sub


    Private Shared Sub MuestraProgreso(ByVal sender As Object, ByVal e As ContadorEvents)
        Console.WriteLine("Número {0}", e.Contador)
    End Sub

End Class

 

Como podemos apreciar, entre VB 6 y VB.Net no existen grandes diferencias. Tan sólo es cuestión de ir habituándose a las nuevas características que nos ofreció .Net. No obstante, el día que me empeciné en empezar a crear las aplicaciones en C#, la cosa no ha sido tan fácil.

C#

Para empezar, resulta que no existe la cláusula Handles de VB ni, que yo sepa, nada que se le parezca, así que habrá que hacer uso de una vinculación dinámica al igual que se ha creado en el último listado. De hecho, en este último listado, al hacer uso de AddHandler, sin saberlo ya hemos estado empleando algo nuevo para aquellos que nos hemos movido siempre en VB: los delegados. Aunque cueste un poco el entendimiento de este concepto, yo he creído entender que un delegado es una función anónima que, sencillamente, tiene la dirección de memoria de la función.  Pues eso, que ya en VB hemos usado los delegados pero, como dice el maestro Guille, VB es muy protector con nosotros y nos protege de ciertas cosas que no necesitamos saber, o que no es obligatorio que sepamos.

El caso es que para poder crear una vinculación dinámica necesitamos que sea una función la que se encargue de “recepcionar” los datos que queremos traspasar al disparar el evento, así que, además del evento, deberemos crear un delegado para que pueda crear tal vinculación (jo, qué rollo, ¿no?). Mejor lo vemos con un ejemplo:

 

using System;


namespace jnSoftware.Pruebas.Eventos
{


    /// <summary>
    /// ContadorEvents. Clase que se usará como parámetro en el disparador
    /// </summary>
    public class ContadorEvents: EventArgs 
    {
        public int Contador { get; set; }
    }



    public class PruebasContador
    {

        // Definición del delegado
        public delegate void MiEventoDelegate(object sender, ContadorEvents e);

        // Definición del evento
        public event MiEventoDelegate MiEvento;


        private int contador = 0;
        private ContadorEvents campoContador = new ContadorEvents();

        public void Inicio()
        {
            for (int i = 0; i <= 1000; i++)
            {
                if (i % 10 == 0)
                {
                    campoContador.Contador = i;
                    if (MiEvento != null)
                        MiEvento(this, campoContador);
                }
            }
        }
    }




    /// <summary>
    /// Clase que ejecuta las pruebas
    /// </summary>
    public class PruebasEventosC
    {

        private static PruebasContador c = new PruebasContador();

        static void Main()
        {
            // Vinculación entre el evento y la función MuestraProgreso. Nos fijamos que 
            // se hace uso del delegado definido en la clase PruebasContador
            c.MiEvento += new PruebasContador.MiEventoDelegate(MuestraProgreso);
            
            c.Inicio();

            // Al igual que se ha hecho con anterioridad, se desvincula el evento
            c.MiEvento -= new PruebasContador.MiEventoDelegate(MuestraProgreso);
        
            Console.ReadKey();
        }

     
        static void MuestraProgreso(object sender, ContadorEvents e) 
        {
            Console.WriteLine("Número {0}", e.Contador);
        }
    }

}

 

Como se puede apreciar, las máximas diferencias podemos encontrarlas en la clase PruebasContador, sobre todo porque, frente a VB, define el Delegado antes mencionado y, antes de lanzar el evento, realiza una comprobación para ver si existen suscripciones a MiEvento.

Bueno, ahí queda. Por supuesto, creando esta entrada no he intentado escribir nada nuevo del tema, puesto que existe, ya en internet miles de artículos que destripan mucho mejor que yo todo lo referente a los eventos, pero sí creo haber puesto mi granito de arena para todos aquellos que, como me ha pasado a mí, se han encontrado con la aparición de los delegados a la hora de pasar a programar en C#.

mailto y Codificación Unicode

Ya que tengo alguna que otra primavera a cuestas y que suelo ganarme la vida, entre otras cosas, impartiendo clases, reconozco que tengo alguna que otra manía. Una de estas manías está estrechamente ligada con la ortografía (u hortografía, como vi no hace mucho en el escrito de un alumno).

Hace poco, en la creación de una página web, el cliente solicitó uno de aquellos enlaces que, al hacer un clic sobre él, se abriera el cliente de correo. Para la mayor parte de clientes, sólo existe el Outlook y, sinceramente, creo que es mejor porque hace muy poquito, el jefe de una empresa en la que trabajo me comentó que quería usar el OpenOffice y, claro, iba a instalar el “gestor de correos del OpenOffice, es decir, el Ubuntu” –casi me da algo- Lástima que no sé callar, puesto que se hubiera merecido instalar este “cliente de correo” sobre el Windows XP, más que nada, por la supremacía que intentaba transmitir al hablarme del tema…

Bueno, siempre suelo irme por las ramas, así que retomo el tema inicial. El caso es que quería añadir, en una página HTML un enlace para que se abriese el Outlook del visitante al site, así que, como una vez hice un cursillo de HTML, me pongo a teclear:

<a 
  href="mailto:usuario@dominio.com
      ?subject=Solicitud de información 
      &body=Les agradecería se sirvan remitirme información adicional acerca de: 
      ">
      Texto del enlace
</a>

A partir de aquí, haces las pruebas y todo va bien, puesto que yo también suelo usar IE y Outlook. El problema empieza a sospecharse cuando recibes correos con caracteres extraños y empiezas a probar con algún explorador diferente, como Firefox. El resultado viene a ser el siguiente:

 

¡Cáspita! Los acentos no acaban de verse como yo esperaba.

La verdad es que no sé si existe alguna solución sencilla para arreglar esto, pero entre que una vez estudié algo de codificación en la asignatura “Estructura de computadores” y que soy retorcido por naturaleza, hecho mano del VisualStudio y me pongo a intentar encontrar una solución.

Tras estar un rato buscando en las clases de .Net Framework, veo que existe una clase dedicada a la conversión entre codificaciones de caracteres, la clase System.Text.Encoding, así que no resulta difícil crear una función que convierta una serie de caracteres escritos en ASCII a Unicode:

''' <summary>
''' Devuelve la cadena pasada como parámetro en formato Unicode
''' </summary>
''' <param name="texto">Cadena de caracteres en formato ASCII extendido para 
''' traspasar a Unicode</param>
Public Function CodificaUnicode(ByVal texto As String) As String

    ' Codificación de la cadena de devolución
    Dim Codificacion As System.Text.Encoding = System.Text.Encoding.Unicode

    ' Se crea una matriz de CHAR con los carácteres de la cadena que se quiere codificar
    Dim Caracteres() As Char = texto.ToCharArray

    ' Conversión de la cadena en una matriz de Bytes
    Dim BytesCodificados() As Byte = Codificacion.GetBytes(Caracteres)

    ' Se crea un StringBuilder para poder traspasar los bytes ya codificados
    Dim sb As New System.Text.StringBuilder

    ' Bucle que añade los bytes codificados. Se puede aprovechar para poder comprobar 
    ' caracteres especiales
    For c As Integer = 0 To BytesCodificados.Length - 1
        Dim ByteActual As String = String.Format("%{0:X2}", BytesCodificados(c))

        ' Se comprueba que no se trate del carácter "especial" del separador
        If Not ByteActual.Equals("%00") Then
            sb.Append(ByteActual)
        End If
    Next

    Return sb.ToString
End Function

Por cierto, una vez aplicada la función, el enlace queda un poco más “sucio”, pero mucho más compatible:

<a 
  href="mailto:%75%73%75%61%72%69%6F%40%64%6F%6D%69%6E%69%6F%2E%63%6F%6D
      ?subject=%53%6F%6C%69%63%69%74%75%64%20%64%65%20%69%6E%66%6F%72%6D%61%63%69%F3%6E
      &body=%4C%65%73%20%61%67%72%61%64%65%63%65%72%ED%61%20%73%65%20%73%69%72%76%61%6E%20%72%65%6D%69%74%69%72%6D%65%20%69%6E%66%6F%72%6D%61%63%69%F3%6E%20%61%64%69%63%69%6F%6E%61%6C%20%61%63%65%72%63%61%20%64%65%3A
      ">
      Texto del enlace
</a>

Redimensionar una imagen

Cuando se trata de subir fotografías a una página Web, casi siempre nos encontramos que, la cámara más barata hace unas fotos de miedo. De miedo por calidad y por el tamaño.

Una solución es redimensionar la imagen, de tal manera que ocupe lo mínimo posible y tenga una calidad aceptable para mostrarse por Internet. Un tamaño que se está convirtiendo en estándar para fotos de productos en Internet es 640×480.

En el código que acompaña al post,  incluyo un ejemplo de cómo cambiar el tamaño y la resolución de una imagen

VB.NET

''' <summary>Cambia la resolución de una imagen a 640x480</summary>
''' <param name="FicheroOrigen">Fichero con la foto original</param>
''' <param name="FicheroDestino">Fichero en el que se guardará la foto redimensionada</param>
Public Shared Sub Redimensiona(ByVal FicheroOrigen As String, ByVal FicheroDestino As String)
    Dim FotoOriginal As New Bitmap(FicheroOrigen)
    Dim FotoRetocada As New Bitmap(FotoOriginal, 640, 480)
    FotoRetocada.SetResolution(72, 72)

    FotoRetocada.Save(FicheroDestino, Imaging.ImageFormat.Jpeg)

    FotoOriginal = Nothing
    FotoRetocada = Nothing
End Sub

C#

/// <summary>Cambia la resolución de una imagen a 640x480</summary>
/// <param name="FicheroOrigen">Fichero con la foto original</param>
/// <param name="FicheroDestino">Fichero en el que se guardará la foto redimensionada</param>
public static void  Redimesiona(string FicheroOrigen, string FicheroDestino)
{
    Bitmap FotoOriginal = new Bitmap(FicheroOrigen);
    Bitmap FotoDestino = new Bitmap(FotoOriginal, new Size(640, 480));

    FotoDestino.SetResolution(72, 72);

    FotoDestino.Save(FicheroDestino, System.Drawing.Imaging.ImageFormat.Jpeg);

    FotoOriginal = null;
    FotoDestino = null;
}