Merry Christmas

via youtube.com

Posted via web from jordicarrasco's posterous

Obtener las clases derivadas de una clase base

Problemática

Tenemos un conjunto de clases que heredan todas de la misma clase base y al iniciar el programa necesitamos inicializar y configurar una instancia de cada una de las clases hijas. Hasta ahora cuando necesitábamos definir una clase hija teníamos que:
1. Crear la nueva clase.
2. Ir al método que inicializa las clases hijas.
3. Ir al método donde se configuran las clases hijas.

¡Un lío! .. y más si tenemos en cuenta que es algo que se hace esporádicamente.

Nuestro deseo era que cuando alguien necesite implementar la definición de una nueva clase hija simplemente deba hacer eso: definirla y punto, del resto de tareas (inicializar y configurar) que se preocupe el programa.

Solución

La solución pasa por usar Reflection. Realizamos una búsqueda en nuestro Assembly de todas las clases existentes que heredan de la clase base y las instanciamos, ¡Así de fácil!

Ejemplo

Primero creamos la clase base y las derivadas:

Public MustInherit Class ClaseBase

    Public MustOverride Sub Metodo()

End Class

Public Class ClaseQueHerada
    Inherits ClaseBase

    Public Sub New()
        Console.WriteLine("Constructor de la ClaseQueHerada")
    End Sub

    Public Overrides Sub Metodo()
        Console.WriteLine("ClaseQueHerada.Metodo")
    End Sub

End Class

Public Class OtraClaseQueHerada
    Inherits ClaseBase

    Public Sub New()
        Console.WriteLine("Constructor de la OtraClaseQueHerada")
    End Sub

    Public Overrides Sub Metodo()
        Console.WriteLine("OtraClaseQueHerada.Metodo")
    End Sub

End Class

En el código siguiente podemos ver como buscamos las clases derivadas, instanciamos y ejecutamos los métodos comunes y todo en tiempo de ejecución.

Module Main

    Sub Main()

        'Accedemos al Assembly que estamos ejecutando
        Dim CurrentAssembly As Assembly = System.Reflection.Assembly.GetExecutingAssembly()
        'Con LINQ obtenemos la lista de classes que heredan de ClaseBase, gracias al método IsSubClassOf
        Dim q = From t As Type In CurrentAssembly.GetTypes() _
                Where t.IsSubclassOf(GetType(ClaseBase))

        For Each o As Type In q
            'Para cada una de las clases hijas la instaciamos y ejecutamos el método
            Console.WriteLine(o.Name)
            Dim der As ClaseBase = CurrentAssembly.CreateInstance(o.FullName, True)
            der.Metodo()
        Next

        Console.Read()

    End Sub

Con este método de acceso a las clases hijas te puedes ahorrar mucho trabajo.

Hasta el infinito y más allá: Visual Studio online

¿Qué pasa cuando 5 tipos muy freaks se encierran para desarrollar?
Eso es lo que hicieron la gente de CodeRun y apareció esto:

Estos tipos han desarrollado un ¡Visual Studio online! Todo hecho en Javascript y yo que pensaba que lo había visto todo cuando los de Google hicieron Gmail. Si alguien tiene 5 minutos para jugar que le un vistazo al CodeRun Studio.

¿Y para que sirve esto?

Imagínate que estas en un lugar sin portátil y necesitas acceder a tu código fuente, realizar una corrección y compilar. Con esta herramienta “podríamos hacerlo” siempre y cuando no utilicemos sistemas de control de versiones, pruebas unitarias, etc.

La idea está verde aunque se ha realizado ya un trabajo impresionante pero nos da una idea de lo que podremos llevar a ver en la nube.

Toda la aplicación se ha desarrollado con el CodeRun web Toolkit sus propias librerías de controles que tienen a la venta y que no están nada mal.

¿Cómo saber el número de registros de una tabla?

Cuando trabajas con SQL Server a veces es necesario consultar cuantos registros tienes en una tabla concreta de la base de datos. Con el script que encontrareis acontinuación obtendreis fácilmente esta infomación.

SELECT
   [TableName] = so.name,
   [RowCount] = MAX(si.rows)
FROM
   sysobjects so,
   sysindexes si
WHERE
   so.xtype = 'U'
   AND
   si.id = OBJECT_ID(so.name)
GROUP BY
   so.name
ORDER BY
   2 DESC

Visto en How do I get a list of SQL Server tables and their row counts?

Si con lo anterior no tienes suficiones el maestro Pinal Dave nos enseña como obtener además el número de columnas y el tamaño en bytes de cada una de las tablas.
El script sería así:

CREATE TABLE #temp (
table_name sysname ,
row_count INT,
reserved_size VARCHAR(50),
data_size VARCHAR(50),
index_size VARCHAR(50),
unused_size VARCHAR(50))
SET NOCOUNT ON
INSERT #temp
EXEC sp_msforeachtable 'sp_spaceused ''?'''
SELECT a.table_name,
a.row_count,
COUNT(*) AS col_count,
a.data_size
FROM #temp a
INNER JOIN information_schema.columns b
ON a.table_name collate database_default
= b.table_name collate database_default
GROUP BY a.table_name, a.row_count, a.data_size
ORDER BY CAST(REPLACE(a.data_size, ' KB', '') AS integer) DESC
DROP TABLE #temp

Visto en SQL SERVER - Query to find number Rows, Columns, ByteSize for each table in the current database - Find Biggest Table in Database

Convertir tus objetos en XML directamente

En algunas ocasiones es necesario guardarse un objeto en su estado actual con todas sus propiedades por ejemplo para guardar en un fichero log, o para transferir por algún protocolo que sólo admite texto, etc. En casos como estos suele ser muy práctico utilizar las clases de serialización que vienen nativas en el Framework.net.

Imaginad que tenemos la típica clase Persona que representa un objeto de negocio de nuestra aplicación:

   1:  Public Class Persona

   2:   

   3:      Private _Nombre As String

   4:      Private _Apellidos As String

   5:   

   6:      Public Property Nombre() As String

   7:          Get

   8:              Return _Nombre

   9:          End Get

  10:          Set(ByVal value As String)

  11:              _Nombre = value

  12:          End Set

  13:      End Property

  14:   

  15:      Public Property Apellidos() As String

  16:          Get

  17:              Return _Apellidos

  18:          End Get

  19:          Set(ByVal value As String)

  20:              _Apellidos = value

  21:          End Set

  22:      End Property

  23:   

  24:      Sub New()

  25:          Me.Nombre = String.Empty

  26:          Me.Apellidos = String.Empty

  27:      End Sub

  28:   

  29:  End Class

Para pasar un objeto de esta clase a String necesitamos utilizar las clases System.Xml.Serialization.XmlSerializer y System.IO.StringWriter de la siguiente forma:

   1:  Dim PersonaSerializada As String

   2:  Dim Yo As New Persona()

   3:  Yo.Nombre = "Yo"

   4:  Yo.Apellidos = "Mismo"

   5:   

   6:  Using sw As New StringWriter()

   7:      Dim serialitzador As New XmlSerializer(GetType(Persona))

   8:      serialitzador.Serialize(sw, Yo)

   9:      PersonaSerializada = sw.ToString()

  10:  End Using

Y el resultado que tendríamos sería:

<?xml version="1.0" encoding="utf-16"?>
<Persona xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Nombre>Yo</Nombre>
<Apellidos>Mismo</Apellidos>
</Persona>

Este es un método práctico y rápido para guardar el estado de un objeto en un momento concreto y puede ser muy útil tanto para poder realizar trazas de un procedimiento concreto o para montar un sistema de gestión de excepciones avanzado .. imaginad que cada vez que se produce una excepción tratando un objeto de negocio nos guardamos la información de la excepción y además el objeto entero.

A tener en cuenta:

• El objeto System.Xml.Serialization.XmlSerializer también incluye el método Deserialize para cargar el objeto de negocio a partir de un String.
• Si cambiamos las referencias al objeto System.IO.StringWriter por un System.IO.StreamWriter podemos guardar el objeto serializado en un fichero XML directamente.
• Los procesos de serialización suelen tener un coste elevado para el sistema así que es conveniente utilizarlo en entornos donde no prime el rendimiento de la aplicación … ¿existe hoy día algún sitio donde no sea imprescindible el rendimiento? .. :-P

Asociar descripción a una Enum

Las Enum nos ofrecen la posibilidad de asociar un nombre descriptivo a un conjunto de valores relacionados entre si, estos valores son numéricos.

Public Enum EstadoCivil 
    Soltero 
    Casado 
End Enum

Muchas veces cuando tenemos una Enum tenemos la necesidad de obtener el nombre que le hemos dado a uno de los valores como si fuera un String (pe. “Soltero”) para mostrarlo en un mensaje por pantalla o registrarlo en algún fichero, etc.

Acceso directo al valor

Si queremos acceder directamente al literal que le hemos asociado al valor simplemente debemos utilizar el método ToString() del valor:

EstadoCivil.Soltero.ToString("G")

Esta línea de código nos devolvería el String “Soltero”.

Acceder a la descripción detalla del valor

Si lo que queremos es poder acceder a una información mucho más detallada, deberemos tirar de Reflection. Para empezar deberíamos ampliar la definición de la Enum.

Public Enum EstadoCivil
 <Description("Un soltero")> Soltero
 <Description("Un casado")> Casado
End Enum

Y la forma de acceder sería la siguiente:

Public Function ObtenerDescripcionEstadoCivil(ByVal estado As EstadoCivil) As String

    Dim InformacionEstado As FieldInfo = GetType(EstadoCivil).GetField(estado.ToString("G"))
    Dim Descripcion As DescriptionAttribute = InformacionEstado.GetCustomAttributes(GetType(DescriptionAttribute), False)(0)

    Return Descripcion.Description

End Function

La llamada a esta función nos daría acceso a la descripción que le hemos asignado.

Etiquetas de Technorati: Reflection,VB.NET,Enum

Inicialización rápida de objetos

Todos sabemos que las instancias de una clase son iniciadas a través de un constructor y que el constructor es un método de la clase que puede ser sobrecargado. Hasta ahí todo correcto, lo de toda la vida.

Constructores “on fly”

La versión actual de VB.NET nos permite iniciar las propiedades públicas de una clase en el momento de la instanciación, en la misma línea de código. Imaginaros la siguiente clase:

Public Class Persona

    Private _Nombre As String
    Private _Apellidos As String

    Public Property Nombre() As String
        Get
            Return _Nombre
        End Get
        Set(ByVal value As String)
            _Nombre = value
        End Set
    End Property

    Public Property Apellidos() As String
        Get
            Return _Apellidos
        End Get
        Set(ByVal value As String)
            _Apellidos = value
        End Set
    End Property

    Sub New()
        Me.Nombre = String.Empty
        Me.Apellidos = String.Empty
    End Sub

End Class

La manera natural de iniciar un objeto de esta clase sería:

Dim NuevaPersona As New Persona()
NuevaPersona.Nombre = "Bill"
NuevaPersona.Apellidos = "Gates

Si quisiéramos poder crear una persona directamente con su Nombre y Apellidos deberíamos sobrecargar el constructor por defecto para que aceptara estos dos nuevos parámetros.


Con la versión actual de VB.NET y sin tener que implementar el nuevo constructor podemos hacer:

Dim BillGates As New Persona() With {.Nombre = "Bill", .Apellidos = "Gates"}

¡Este código es equivalente al del ejemplo de antes pero en una sola línea de código! Y si quisiéramos podríamos ir instanciando diferentes objetos con diferentes propiedades configuradas inicialmente:

Dim Bill As New Persona() With {.Nombre = "Bill"}
Dim BillGates As New Persona() With {.Nombre = "Bill", .Apellidos = "Gates"}

Fácil, ¿no?

Detectar si la aplicación web está en modo Debug

Vía: Detecting ASP.NET Debug mode

No os pasa que cuando estais depurando una aplicación web teneís que introducir siempre los mismo parámetro, pasar los mismo procesos de inicialización, etc.

También es muy útil para generar algunos resultado intermedios que utilizas para ver el estado de la aplicación mientras debugas .. saltarte una pantalla de login, etc.

Si eres de los que no soporta hacer mil veces estas tareas aquí tiene la condición mágica:

If HttpContext.Current.IsDebuggingEnabled Then
	'Tareas a realizar
End If

Ejecución de funciones de modo asíncrono

¿Tienes en tu programa una función que tarda muchísimo en ejecutarse y no tienes que hacer nada con el resultado de esta? Por ejemplo en servicios de notificaciones a los que no esperas que te confirmen su recepción, escribir en un fichero de Log, insertar en un registro en una tabla, etc. En general acciones que no tienen que ver con la funcionalidad principal que estamos ejecutando en ese momento.
Si te has encontrado en esta situación .. ¡el esperar se va a acabar! Tenemos los Delegate.
Los delegados son básicamente un puntero a un función de tu programa, ¡Tranquilos! No vamos a ver nada de punteros .. no estamos en C. Lo que hace el .NET Framework es ejecutar tu función en otro subproceso de tu aplicación, sin tener que crear Thread.

Por ejemplo, imaginad que tenemos la siguiente función de nuestro programa:

Private Sub FuncionEjecutadaAsincrona(ByVal parametro1 As String)
'Código pesado del cual no esperamos su respuesta
End Sub

Para crear su delegado simplemente tendríamos que definir la así:

Private Delegate Sub FuncionEjecutadaAsincronaDelegate(ByVal parametro1 As String)

Efectivamente como podéis ver simplemente tenéis que utilizar la misma definición del procedimiento añadiendo la palabra Delegate.
Ahora sólo falta llamar a nuestra función que se hará así:

Dim deleg As FuncionEjecutadaAsincronaDelegate
      deleg = New FuncionEjecutadaAsincronaDelegate(AddressOf FuncionEjecutadaAsincrona)
      deleg.BeginInvoke("Parametro1", Nothing, Nothing)

¡Y ya está! Al realizar la llamada a BeginInvoke se lanza nuestra función. Los dos parámetros a Nothing permiten, si es una función, recibir la información de respuesta pero eso lo veremos otro día.

El patrón de diseño Singleton

El patrón de diseño Singleton, o de Instancia única, nos permite asegurar que de una determinada clase sólo hay un instancia en todo el sistema.

La idea es que nuestra clase Singleton no mostrará públicamente las operaciones necesarias para su instanciación (constructor) y por lo tanto será ella quien misma quien gestiones su instanciación.

Imaginaros la típica clase de acceso a la base de datos o a unos datos de configuración o a un sistema de escribir un fichero LOG. Realmente son tareas que realizamos en todos nuestros programas y seguramente lo resolvemos guardando información en variables globales o realizando el proceso de carga o configuración cada vez que lo necesitamos.
En todos estos casos es muy interesante tener la posibilidad de tener una clase común que nos proporcione acceso a sus recursos pero sin tener que estar instanciando la clase cada vez que la necesitamos.

La implementación de patrón Singleton en VB.NET sería así:

Public NotInheritable Class Singleton

    Private Shared _Instance As Singleton = Nothing
    Private Shared ReadOnly _Sync As New Object

    Private Sub New()
    End Sub

    Public Shared ReadOnly Property Instance() As Singleton
        Get
            If _Instance Is Nothing Then
                SyncLock _Sync
                    If _Instance Is Nothing Then
                        _Instance = New Singleton()
                    End If
                End SyncLock
            End If
            Return _Instance
        End Get
    End Property

End Class

Para utilizar la clase que hemos creado simplemente hay que definir una variable de ese objeto y llamar a la propiedad Instance.

Dim MiSingleton As Singleton = Singleton.Instance
'Ejemplo de llamada de un Metodo de Singleton
MiSingleton.HacerAlgo()

Aquí os dejo el fichero Singleton.vsi que os permitirá incluir en vuestro Visual Studio el code snippet del patrón Singleton.

Gestión global de excepciones

Aunque cada vez el software que desarrollamos es más robusto la verdad es que nadie se escapa de dejar algún gazapo que en cualquier momento se le presentará al usuario final en forma de un horrible mensaje de error.

Si queremos evitar estas situaciones podemos definir los eventos UnhandledException y ThreadException en nuestros programa y problema resuelto. La verdad es que no parece demasiado lógico que tengamos que definir dos eventos para capturar las excepciones que no controlamos pero el primero se encarga de manejar las que no tienen que ver con el interface gráfico y el segundo se encarga de las visuales.

La implementación sería de la siguiente manera:

1. Definición de los eventos:

   Private Sub Form1_Load(ByVal sender As System.Object, _
                          ByVal e As System.EventArgs) Handles MyBase.Load
   
       Dim currentDomain As AppDomain = AppDomain.CurrentDomain 
       AddHandler currentDomain.UnhandledException, AddressOf AppDomain_UnhandledException
       AddHandler Application.ThreadException, AddressOf Application_ThreadException
   
   End Sub

   
   


2. Declaración del evento que maneja la UnhandledException:
   

   
   Private Sub AppDomain_UnhandledException(ByVal sender As Object, ByVal e As UnhandledExceptionEventArgs)
   
   Dim st As New StackTrace()
   Dim pila As String = st.ToString() 'Obtenemos el estado actual de la pila
   
   Dim ex As Exception = DirectCast(e.ExceptionObject, Exception)
   
   'Acciones a realizar para registrar las excepciones
   MessageBox.Show("UnhandledException" & ex.Message)
   
   End Sub
   

   
   


3. Declaración del evento que maneja la ThreadException:
   

   
   Private Sub Application_ThreadException(ByVal sender As Object, ByVal e As Threading.ThreadExceptionEventArgs)
   
   Dim st As New StackTrace()
   Dim pila As String = st.ToString()
   
   'Acciones a realizar para registrar las excepciones
   MessageBox.Show("ThreadException" & e.Exception.Message & ". " & pila)
   
   End Sub
   

   
   

¡Y eso es todo! Ahora ya no hay excusa para no facilitarle el trabajo al usuario final mostrándole esos feos mensajes de error y además nos permitirá registrar toda la información existente en el sistema en el momento que se lanzó la excepción.