El Blog de RCastro

Ha nacido GLYPY The Hero

2011-12-02T11:35:00.000+01:00

Hoy he recibido la notificación de que mi primera aplicación para Windows Phone 7 ha pasado el proceso de certificación y está disponible desde hoy en el marketplace de Microsoft.

Todo empezó como una simple prueba con XNA y C# pero al cabo de algún tiempo se ha convertido en un juego completo, de principio a fin.

No creo que me haga rico con esto de los juegos pero me estoy divirtiendo mucho en el camino. :-)

GLYPY The Hero es un típico juego de plataformas en el que se “aplastan” bicharracos y se recogen cosas. Aquí os dejo una captura de pantalla para que os hagáis una idea.

Aquí dejo el enlace por si queréis probarlo.

Un ejemplo práctico y III

2009-01-12T13:50:00.001+01:00

En esta tercera y última entrega del ejemplo práctico pretendo:

Teorizar sobre los diferentes enfoques al problema de carga de entidades en un diseño orientado a objetos.
Profundizar en el diseño de la clase DataLoader y en sus mecanismos de expansión.

En el día a día de un desarrollador es habitual la utilización de tablas de Código-Descripción. Con ellas se ahorra espacio ya que no se duplica la información, se normalizan los datos, etc. Lo que todos ya sabemos. Los problemas con el manejo de estas entidades comienzan cuando en nuestro sistema existen entidades con muchos "códigos" de "tablas maestras", claves externas vamos.

¿Cómo obtenemos estos valores relativos a estas claves?. ¿Utilizamos sentencias INNER JOIN?. ¿Realmente y vamos a necesitar cargar todos estos valores en todos los escenarios?. Abordar estas preguntas, a mi modo de ver, es crucial a la hora de diseñar un sistema para que sea AGIL y TOLERANTE a los cambios. Esto último es importantísimo en proyectos grandes en los que, como todos sabemos, los cambios son constantes y no hay que romper lo que ya funciona.

Voy a intentar poner un ejemplo sencillo: supongamos que tenemos la típica entidad Empleado, que tiene, además de los campos habituales, un código de departamento, un código de categoría, un código de Responsable y una lista de Proyectos en los que participa. A la hora de cargar un objeto Empleado la implementación más habitual es la de lanzar una sentencia SQL con un INNER JOIN de las diferentes tablas. Es obvio, que si un caso de uso concreto dice que solo tengo que listar el Nombre y el Departamento, estaremos solicitando y transmitiendo más datos de los que realmente necesitamos.

Con este modelo "INNER JOIN" si posteriormente se añade otra clave externa, por ejemplo TipoDeHorario, habrá que modificar la sentencia SQL para que el método Carga() llene TODAS las propiedades. Este cambio en el modelo implicará una penalización en el rendimiento de otros métodos ya implementados que funcionaban correctamente.

Si cada cambio que se realice en el modelo afecta al rendimiento de lo ya existente nuestro sistema NO ES AGIL ni TOLERANTE a cambios. Con unos cuantos cambios como estos, a posteriori, y con este enfoque, el sistema dejará rápidamente de comportarse como venía haciéndolo y lo que es peor: de como el usuario ya está acostumbrado.

Por lo tanto y como ya he escrito en otra entrada:

“Siempre que se pueda, y aquí entran cuestiones de rendimiento, el primer enfoque que doy a la carga de entidades relacionada es la Lazy Load o Carga Perezosa con algún mecanismo de cacheo. De esta manera los objetos no pierden “su integridad” y siguen funcionando como se espera tras implementar diferentes modos de carga: en un escenario haciendo un INNER JOIN con la tabla Provincias, en otro escenario con la tabla Facturas donde no interesa en absoluto la información de las anteriores.”

No estoy en contra de la utilización del método INNER JOIN, al contrario, muchas veces es el que hay que utilizar. Lo que planteo es que, antes de nada, es necesario un análisis exhaustivo de donde se donde se va a utilizar y de como afectará esto a a posibles futuras modificaciones.

Otra decisión importante que tenemos que tomar a la hora de cargar un objeto, es "Cuando" se cargarán las entidades relacionadas y las descripciones de las propiedades de las que solo tenemos su clave externa. En nuestro ejemplo, simple el, solamente existe una: La lista de Proyectos. En una aplicación del mundo real podría haber, además, una lista de direcciones, una lista de teléfonos, etc. ¿Cómo abordamos este problema? ¿Cargamos todas las entidades en el método carga()?. De este modo estaríamos en disposición de obtener cualquier valor inmediatamente después de su invocación, pero de nuevo en la implementación del caso de uso Listar Nombre y Departamento estaríamos haciendo más cosas de las estrictamente necesarias.

Nota importante: Existen escenarios en que este enfoque es el correcto ya que SIEMPRE que se carga una entidad se van a utilizar/consultar sus entidades relacionadas. De no ser así es mas aconsejable utilizar mecanismos de Carga Perezosa (Lazy Load). De esta forma las cosas se cargan cuando realmente se necesitan.

A continuación intentaré mostrar como realizar la carga de objetos para evitar, de algún modo, los problemas expuestos anteriormente.

Carga de un valor desde una tabla maestra.

En ocasiones es necesario mostrar la descripción de una propiedad en lugar del código o clave externa. Por ejemplo, supongamos que ahora necesitamos especificar un Tipo para la entidad Envio que ya conocemos de otras entradas del blog. Los tipos pueden ser: Local = 0, Nacional = 1 e Internacional = 2. Podríamos implementarlo de la siguiente forma:

Private _idTipo As Integer 
Public Property IdTipo() As Integer 
  Get 
    Return _idTipo 
  End Get 
  Set(ByVal value As Integer) 
    _idTipo = value 
  End Set 
End Property 

Private _TipoDeEnvio As String = "" 
Public ReadOnly Property TipoDeEnvio() As String 
  Get 
    Return _TipoDeEnvio 
  End Get 
End Property

Con un enfoque tradicional del problema primero realizaríamos un INNER JOIN en la sentencia SQL, cambiaríamos el cargador del objeto y lo tendríamos. Lo MALO de este enfoque es que penalizamos el código ya existente que no necesita el tipo de envio. Por lo tanto es necesario hacernos las siguientes preguntas: ¿Es en todos los escenarios estrictamente necesaria la carga del Tipo de envio? ¿Lo será en futuros escenarios o casos de uso?. Lo más normal es dar un NO como respuesta estas dos preguntas.

Tendremos, por tanto, que mejorar el mecanismo de carga de este tipo de propiedades. Una primera aproximación puede ser la de cachear el valor. Lo vemos con el siguiente código:

Public ReadOnly Property TipoDeEnvio() As String 
  Get 
    If _TipoDeEnvio.Length = 0 Then 
      _TipoDeEnvio = New TipoDeEnvio().Carga(_idTipo).Descripcion 
    End If 
    Return _TipoDeEnvio 
  End Get 
End Property

Si observamos con detenimiento esta nueva implementación nos daremos cuenta de que no interfiere con la anterior y de que en el caso de seguir cargando el objeto con INNER JOIN la creación y carga de un objeto TipoDeEnvio no será necesaria. Es muy importante, repito, que las modificaciones no rompan ni incidan en el rendimiento de lo que ya funciona.

Esta patrón puede ser interesante para la implementación de algunos casos de uso sencillos. Por ejemplo, si queremos abrir un solo envio y conocer su tipo. Necesitaremos, entonces, 2 accesos a la capa de Datos.

En el caso de que queramos, por el contrario, listar todos los envios de un mes cualquiera y mostrar su tipo, el patrón anterior no será el más adecuado, realizará una consulta a la base de datos por cada envio. No es del todo malo, ya que en una etapa inicial del desarrollo puede interesar más mostrar la futura funcionalidad, que el RENDIMIENTO.

Una versión mejorada puede hacer uso de mecanismos de cacheo globales o incrementales.

Public ReadOnly Property TipoDeEnvio() As String 
  Get 
    If _TipoDeEnvio.Length = 0 Then 
      If Helper.CacheDeTipos Is Nothing Then 
        _TipoDeEnvio = New TipoDeEnvio().Carga(_idTipo).Descripcion 
      Else 
        _TipoDeEnvio = Helper.CacheDeTipos.Item(_idTipo).Descripcion 
      End If 
    End If 
    Return _TipoDeEnvio 
  End Get 
End Property

Se puede apreciar como esta última implementación “permitirá” el correcto funcionamiento del objeto independientemente del contexto en el que se utilice y de como se haya inicializado.

Carga de Entidades relacionadas

En ocasiones me he encontrado con código heredado en el que los objetos del tipo Cliente se cargaban en el constructor junto con una colección de TODAS las facturas del mismo, para finalmente mostrar por pantalla sencillamente la Localidad y la Provincia. Inadmisible.

Hemos de preguntarnos, como hicimos anteriormente, si es estrictamente necesario cargar todas, algunas o ninguna de las entidades relacionadas. Existirán casos en los que no haya más remedio que cargar todas las entidades y otros en los que habrá que dotar al objeto de mecanismos que le permitan ser usado de una forma Flexible.

Como norma general en el diseño de los objetos se establece que los métodos de carga recuperarán solamente los valores comunes a todos los casos de uso, es decir, los de la Tabla de la Base de Datos correspondiente a la entidad. Los demás valores o entidades relacionadas deberían ser cargadas bajo petición.

Un patrón de implementación de la propiedad Documentos es la siguiente:

Private _Documentos As Anexos = Nothing 
Public ReadOnly Property Documentos() As Anexos 
  Get 
    If _Documentos Is Nothing Then 
      _Documentos = New Anexos().Carga(Me.IdEnvio) 
    End If 
    Return _Documentos 
  End Get 
End Property

podremos utilizar el objeto de la siguiente forma:

. 
. 
With New Envio().Carga(350) 
  Debug.WriteLine(.this.IdEnvio) 
  For Each a As Anexo In .this.Documentos 
    Debug.WriteLine(a.FileName) 
  Next 
End With 
. 
.

De esta forma no existirá penalización en el rendimiento cuando solamente queramos cambiar, por ejemplo la fecha de un envio ya que los Documentos SOLO son cargados cuando se solicitan.

Si requisitos posteriores indican, por ejemplo, la necesidad de incluir una lista de Destinatarios del envio, bastará con realizar la implementación de la propiedad Destinatarios de la misma forma que antes:

Private _Destinatarios As Destinatarios 
Public ReadOnly Property Destinatarios() As Destinatarios 
  Get 
    If _Destinatarios Is Nothing Then 
      _Destinatarios = New Destinatarios().Carga(Me.IdEnvio) 
    End If 
    Return _Destinatarios 
  End Get 
End Property

La ejecución de la nueva funcionalidad no interfiere en absoluto con la funcionalidad anterior consistente en listar los nombres de los documentos anexos.

With New Envio().Carga(350) 
  Debug.WriteLine(.this.IdEnvio)        
  For Each a As Destinatario In .this.Destinatario 
    Debug.WriteLine(a.Nombre) 
  Next 
End With

Lo que perseguimos con patrones como estos es que los objetos se comporten como se espera que lo hagan y sobre todo, mantener está coherencia y efectividad aun cuando los requisitos cambien (Que cambiarán).

Al principio y cuando estamos acostumbrados a la carga INNER JOIN todo lo anterior nos parece que es complicar las cosas, porque, si me puedo traer toda la información de una sola vez, ¿Para qué montar tanto lio?. La respuesta es: Porque no sabemos cuales serán los requisitos en el en futuro, porque no queremos "Que el diseño inicial nos hipoteque el sistema", porque queremos desarrollos ágiles y porque queremos a toda costa evitar sentencias SLQ de más de 30 líneas que difícilmente entenderemos pasados cinco minutos.

Pensemos en que los grandes sistemas existentes, incluso los vivos, están compuestos por la agregación de pequeñas partes: bloques, ladrillos, células ... Lo complejo aquí es el sistema no sus componentes. Diseñemos, púes, componentes pequeños, sencillos, pensados para su expansión futura y, sobre todo, fácilmente comprensibles tanto en su funcionamiento individual como cuando interactúan con otros para formar el TODO.

El DataLoader y sus mecanismos de expansión.

Como hemos visto anteriormente los objetos de un sistema deben ser cargados de forma efectiva y coherente en sus todos y cada uno de los escenarios en donde son utilizados. Para ello debemos disponer de unos mecanismos de carga lo suficientemente flexibles para realizar con éxito esta tarea.

En el Modelo que propongo esta responsabilidad se le ha asignado a los propios objetos. No obstante se podría, por ejemplo, crear una clase “BindingManager” que realizara la tarea de gestionar los “cargadores” de los objetos.

Los objeto de la capa de negocio, heredando y sobrescribiendo, implementan el siguiente interfaz:

Public Interface ILoader
  Function GetObjectLoader() As ObjectLoader
  Property ConnectionProvider() As Dal.ConnectionProviderDelegate
  Property transactionProvider() As Dal.TransactionProviderDelegate
End Interface

Como ya he dicho anteriormente los objetos inicialmente son cargados con sus valores mas “usados” y a la vez los mas “fácilmente” accesibles. Por lo tanto para este escenario el objeto proporciona a través de la interfaz ILoader su “cargador genérico”. Este cargador, normalmente, traspasa los valores de la base de datos (DataReader) a las variables privadas de las propiedades del objeto. El siguiente código muestra el cargador generico de la clase Envio:

Public Class Envio : Inherits ObjetoBase
  .
  .
  Private Shared Sub InitDataBinder()
    If _DataBinder Is Nothing Then
      _DataBinder = New Dal.ObjectLoader()
      With _DataBinder 
        .Add(New Dal.BindItem("id", "Id", 0, GetType(Integer)))
        .Add(New Dal.BindItem("idEnvio", "IdEnvio", 1, GetType(String)))
        .Add(New Dal.BindItem("observaciones", "Observaciones", 2, GetType(String)))
        .Add(New Dal.BindItem("numeroDeRegistro", "NumeroDeRegistro", 3, GetType(String)))
        .Add(New Dal.BindItem("fechaDeRegistro", "FechaDeRegistro", 4, GetType(Date)))
        .Add(New Dal.BindItem("fecha", "Fecha", 5, GetType(Date)))          
        .Add(New Dal.BindItem("usuario", "Usuario", 6, GetType(String)))          
      End with
    End If
  End Sub

  Shared _DataBinder As Dal.ObjectLoader = Nothing
  Public Overrides Function GetBinder() As Dal.ObjectLoader
    InitDataBinder()
    Return _DataBinder
  End Function
  .
  .
End Class

Este cargador está diseñado para trabajar con un DataReader con 6 campos que son los que actualmente devuelve el siguiente método de la capa de Datos:

Public Function GetItem(ByVal id As Integer) As IDataReader
  Using cmd As IDbCommand = CreateCommand()   
    cmd.CommandText = String.Format("Select * from [Envio] where Id={0}", id)
    Return DataServer.ExecuteReader(cmd)
  End Using
End Function

El responsable de la carga es el método LoadObject de la clase DataLoader que devuelve el objeto cargado con los valores de un DataReader:

Public Class Envio : Inherits ObjetoBase
  .
  .
  Public Function Carga(ByVal id As Integer) As Envio
    Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)
      Dal.Loader.LoadObject(Me, D__.GetItem(id))
    End Using
    Return Me
  End Function
  .
  .

Hasta aquí hemos visto cual es la forma, genérica, en la que los objetos son cargados. Creo que es el momento de aclarar que en la actual implementación de los métodos de carga se generan dinámicamente funciones de carga de acuerdo a la información especificada en los ObjectLoader de los objetos. Esta generación dinámica de código intermedio se realiza una sola vez por tipo de cargador y almacenada como un delegado en el mismo ObjectLoader. El mecanismo de generación supone que existe una variable privada por cada bindItem cuyo nombre va precedido de “_”. Esta variable recibirá el valor del campo del DataReader cuyo índice se indica en el BindItem. Veamos una ejemplo de lo que digo:

en el cargador del objeto

.Add(New Dal.BindItem("id", "Id", 0, GetType(Integer)))

en la propiedad

.
.
Private _id As Integer
Public Property Id() As Integer
.
.

Nota: El segundo parámetro del constructor de BindItem actualmente no se usa. Es el nombre del campo en la tabla de la base de datos. Por rendimiento el acceso es por el indice de columna, el tercer parámetro.

A partir de ahora veremos como el Modelo nos permite especificar que valores cargar.

Supongamos que en un determinado caso de uso necesitamos conocer el Id, el Id del envio y el usuario que lo realizó. A la vista del código que ya tenemos utilizamos el método genérico de carga para implementar dicho caso de uso. Bueno, funciona, y en un primer estadío del desarrollo nos sirve para mostrar la funcionalidad del sistema al cliente pero sin entrar en cuestiones de rendimiento. El cliente, sin que sirva de precedente, nos indica que “Que si, que le gusta la funcionalidad” pero que estima que “el tiempo de respuesta debe ser bastante menor”. En este momento, o una vez que detectamos un punto en el que el rendimiento es importante, pasaríamos a la optimización del código de carga para este caso particular.

La primera optimización que podemos hacer es la creación en la capa de datos de un método que nos devuelva un DataReader únicamente con los columnas necesarias:

Public Function GetItemsExt() As IDataReader
  Using cmd As IDbCommand = CreateCommand()
    cmd.CommandText = "Select Id,IdEnvio,Usuario from [Envio]"
    Return DataServer.ExecuteReader(cmd)
  End Using
End Funtion

A continuación deberemos crear un método que pueda ser usado para implementar el exigente Caso de Uso. Este método debe especificar cuales son las propiedades que se van a cargar. Hasta ahora hemos visto que el cargador de objetos necesita un objeto y un DataReader con los valores de las propiedades para realizar su trabajo. Lo que no vemos tan fácilmente es que necesita también un cargador del objeto ya que este es solicitado al objeto si no se proporciona. De todas formas, y este es un típico mecanismo de expansión del diseño, existen versiones sobrecargadas de los métodos de carga: LoadObject y LoadObjects que aceptan un Cargador Personalizado:

Public Shared Sub LoadObject(Of T As {Class, New, ILoader})(ByVal Target As T, ByVal dr As IDataReader, ByVal Loader_ As ObjectLoader) 
Public Shared Sub LoadObject(Of T As {Class, New, ILoader})(ByVal Target As T, ByVal dr As IDataReader)

Public Shared Function LoadObjects(Of T As {Class, New, ILoader})(ByVal Target As Generic.List(Of T), ByVal dr As IDataReader) As Generic.List(Of T) 
Public Shared Function LoadObjects(Of T As {Class, New, ILoader})(ByVal Target As Generic.List(Of T), ByVal dr As IDataReader, ByVal Loader_ As ObjectLoader) As Generic.List(Of T)

En el siguiente ejemplo el cargador se crearía en cada llamada, no obstante vemos claramente que este es un punto en el que se podrían aplicar mecanismos de cacheo de cargadores específicos. No lo hago aquí por simplicidad.

Public Function CargaExt() As Envios
  Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)
    Dim customLoader As New Dal.ObjectLoader
    With customLoader
      .Add(New Dal.BindItem("id", "Id", 0, GetType(Integer)))
      .Add(New Dal.BindItem("idEnvio", "IdEnvio", 1, GetType(String)))
      .Add(New Dal.BindItem("usuario", "Usuario", 2, GetType(String)))
    End With
    Return Dal.Loader.LoadObjects(Of Envio)(Me, D__.GetItemsExt(), customLoader)
  End Using
End Function

Bueno pues esto es todo por hoy. Hemos visto la forma generica de cargar los objetos y como, en casos específicos, es necesaria una carga especifica y optimizada de valores para obtener unos rendimientos altos.

Espero que todo esto sirva, al menos, para daros algunas ideas.

Saludos y hasta la próxima.

Un ejemplo práctico II Bis.

2008-12-18T12:12:00.001+01:00

Todo modelo que se precie debe implementar mecanismos que permitan tanto su expansión como su trazabilidad. Es muy conveniente poder saber, por ejemplo, por qué esta fallando nuestra aplicación al intentar realizar una operación en la base de datos en un entorno de producción. Para conseguir este objetivo es requisito indispensable que cualquier operación de acceso a base de datos se realice desde un punto común. De esta forma, por tanto, podremos trazar dichas operaciones e informar de los posibles errores que estas puedan producir.

En el modelo esto es responsabilidad de la clase Dal.DataServer. A continuación el fragmento de código que lo realiza:

.
.
Public Shared Function ExecuteReader(ByVal cmd As IDbCommand) As IDataReader
  Return ExecuteCommand(Of IDataReader)(cmd, AddressOf _ExecuteReader)
End Function
Public Shared Function ExecuteNonQuery(ByVal cmd As IDbCommand) As Integer
  Return ExecuteCommand(Of Integer)(cmd, AddressOf _ExecuteNonQuery)
End Function
Public Shared Function ExecuteScalar(Of T)(ByVal cmd As IDbCommand) As T
  Return ExecuteCommand(Of T)(cmd, AddressOf _ExecuteScalar)
End Function
' Para centralizar los mensajes de error de la Capa de Acceso a Datos
' de forma que se puedan: Escribir la sentencia SQL, escribir en un log, tratar el texto de error, etc
Private Shared Function ExecuteCommand(Of T)(ByVal cmd As IDbCommand, ByVal handler As CommandHandler(Of T)) As T
  Try
    If _Trazas.Enabled And DisableLog = False Then
      Trace.WriteLine(IIf(cmd.Transaction IsNot Nothing, "Dal --> Transaction.", "DAL.") & "ExecuteCommand : " & cmd.CommandText)
    End If
    DisableLog = False
    Return handler(cmd)
  Catch e As Exception
    ' Trace the exception into the same log.
    Trace.WriteLine("--- Exception : " & e.Message)
    ' Aqui se podría inntentar controlar los mensajes de error de clave duplicada, etc...
    Throw New Exception("Data Access Layer Exception ", e)
  End Try
End Function
Private Shared Function _ExecuteReader(ByVal Cmd As IDbCommand) As IDataReader
  Return Cmd.ExecuteReader()
End Function
Private Shared Function _ExecuteNonQuery(ByVal Cmd As IDbCommand) As Integer
  Dim Res As Integer = Cmd.ExecuteNonQuery()
  If _Trazas.Enabled Then
    Trace.WriteLine(IIf(Cmd.Transaction IsNot Nothing, "Dal --> Transaction ", "DAL ") & Res & " Filas")
  End If
  Return Res
End Function
Private Shared Function _ExecuteScalar(Of T)(ByVal Cmd As IDbCommand) As T
  Return Cmd.ExecuteScalar
End Function
.
.
.

Es una traducción-adaptación a vb, allá por febrero del 2006, de un articulo lo publicado en www.codeproject.com titulado: “Templating via Generics and delegates” de Oren Ellenbogen.

Configuración del Debug.

Vamos a modificar el formulario del proyecto de pruebas añadiéndole algunos botones de comando, cambiaremos el control de texto por un RichTextBox y adecentamos un poco el formulario.

Además vamos a necesitar una clase que nos permita visualizar las trazas que nuestro modelo va dejando. Esta clase va a heredar de TraceListener y enviará todo mensaje que escribamos en el objeto Trace al control RichTextBox dándole un aspecto más vistoso. Una buena presentación siempre es de agradecer.

Este es el código de nuestro, bueno mío, TraceLister:

Friend Class MyListener : Inherits TraceListener
  Private _theRichTextBox As RichTextBox
  Private _theSetValueDelegate As SetValueDelegate

  Public Sub New(ByVal control As RichTextBox)
    MyBase.new()
    _theRichTextBox = control
    _theRichTextBox.Multiline = True
    _theSetValueDelegate = New SetValueDelegate(AddressOf SetValueProc)
  End Sub

  Public Overloads Overrides Sub Write(ByVal message As String)
    _theRichTextBox.BeginInvoke(_theSetValueDelegate, New Object() {message})
  End Sub

  Public Overloads Overrides Sub WriteLine(ByVal message As String)
    _theRichTextBox.BeginInvoke(_theSetValueDelegate, New Object() {message & Environment.NewLine})
  End Sub

  Private Delegate Sub SetValueDelegate(ByVal value As String)
  Private Sub SetValueProc(ByVal value As String)
    _theRichTextBox.SelectionColor = Color.Blue
    If value.IndexOf("Objetos/Segundo") > -1 Then _theRichTextBox.SelectionColor = Color.Gray
    If System.Text.RegularExpressions.Regex.Match(value, _
                    "(Commit)|(Rollback)|(BeginTransaction)|(Transaction.)").Success Then _theRichTextBox.SelectionColor = Color.Green    
    _theRichTextBox.AppendText(New String(" "c, 2 * Trace.IndentLevel) & value)
    _theRichTextBox.ScrollToCaret()
  End Sub

End Class

El siguiente paso es inicializar el mecanismo de notificación de carga de objetos que nos ofrece el Dal y agregar nuestro listener a la lista para que reciba los mensajes de depuración

Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
  .
  ' Resto del código omitido intencionadamente
  .       
  Dal.Loader.OnBeginLoad = New Dal.BeginLoadDelegate(AddressOf OnBeginLoad)
  Dal.Loader.OnEndLoad = New Dal.EndLoadDelegate(AddressOf OnEndLoad)
  Dal.DXTimer.Init()
    
  With Trace.Listeners
    .Add(New MyListener(Me.TextBox1))
  End With

End Sub

Private Shared Sub OnBeginLoad()
  DAL.DXTimer.GetElapsedMilliseconds()
End Sub

Private Shared Sub OnEndLoad(ByVal Properties As Integer, ByVal Objects As Integer)
  Dim time As Double = DAL.DXTimer.GetElapsedMilliseconds
  Trace.WriteLine( _
    String.Format("{0}s para {1} objetos con {2} campos.{3} Objetos/Segundo", _
                    New String() {(time / 1000.0).ToString("0.###0"), _
                                   Objects, _
                                   Properties, _
                                   (Objects / (time / 1000.0)).ToString("0.###0") _
                                   }))
End Sub

A partir de este momento tendremos completa información sobre las sentencias SQL ejecutadas así como del tiempo empleado en crear y cargar los objetos con los valores obtenidos.

Carga de objetos

Una vez que hemos realizado los cambios anteriores la pulsación del botón Cargar, como ya hacía antes, llenará lista con los ids de los envíos recuperados. Pero esta vez tenemos más cosas. Tenemos INFORMACIÓN y la información es poder.

Vemos como se van creando conexiones, como se van cerrando, que sentencias se ejecutan y cual es el tiempo que el sistema tarda en crear y cargar los objetos de la capa de Negocio.

Aquí, y seguro que alguno ya se ha dado cuenta, los datos nos muestran diferentes valores en lo referente al tiempo de carga de objetos: 0,2881 s y 0,004s. Estos valores corresponden a dos ejecuciones consecutivas y, aunque no reflejan fielmente la velocidad de carga ya que sólo son dos los registros de la tabal, si nos indican que la primera vez tarda más.

Esta tardanza es debida a la generación del delegado de carga de ese tipo de objeto. Esta generación solo se produce una vez en la “vida” del proceso que hospeda nuestros objetos. Las siguientes llamadas ejecutan código intermedio generado dinámicamente con la información de del DataBinder del objeto. Las pruebas están hechas con VS2008 en un Pentium II, no os digo más. Si es el que tengo en casa, ¡¡¡que pasa!!!!.

Entraré a fondo en este tema otro día. En www.codeproject.com estaba la inspiración “A General Fast Method Invoker” por Luyan.

Las transacciones en el Modelo

Para probar el funcionamiento de las transacciones hemos añadido un botón con el título Insertar y establecido un manejador para el mimo. Este procedimiento simplemente insertará dos registro en la base de datos. En una primera ejecución vamos a olvidar un campo requerido por la tabla para observar que es lo que ocurre.

Este es el código del procedimiento:

Private Sub btnInsertar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnInsertar.Click    
    Dim TH As New Negocio.TransactionHelper(Dal.DataServer.GetNewConection())
    Try
      TH.BeginTransaction()
      ' Insertar el primer elemento (sintaxis 1)
      With New Negocio.Envio()
        .ConnectionProvider = TH.ConnectionProvider
        .TransactionProvider = TH.TransactionProvider
        .Id = 0 ' Segun nuestro diseño esto provocará una inserción.
        .IdEnvio = "Envio_02"
        .NumeroDeRegistro = "REG002"
        .FechaDeRegistro = "17/12/2008"
        .Observaciones = "Con método 2"
        .Usuario = "Test"
        .Save()
      End With
      ' Insertar el segundo elemento (Sintaxis 2)
      With Negocio.Factory.Crear(Of Negocio.Envio)(TH)
        .Id = 0
        .IdEnvio = "Envio_03"
        '.NumeroDeRegistro = "REG003"
        .FechaDeRegistro = "17/12/2008"
        .Observaciones = "Con la sintaxis 2 ahorramos lineas"
        .Usuario = "Test"
        .Save()
      End With
      TH.Commit()
      Trace.WriteLine("Inserción realizada")
    Catch ex As Exception
      TH.RollBack()
      Trace.WriteLine(ex.Message)
      MsgBox(ex.Message)
    Finally
      TH.Dispose()
    End Try
End Sub

En la imagen se puede ver cual ha sido el resultado de esta ejecución accidentada.

Gracias a nuestro mecanismo centralizado de consultas y trazas podemos fácilmente ver como el error que se ha producido en la segunda inserción es debido a la omisión de un valor requerido. Además observamos como: se abre y cierra correctamente la conexión; las operaciones se ejecutaban dentro de una transacción y que esta ha sido cancelada.

La siguiente imagen muestra una ejecución correcta una vez quitado el comentario del NumeroDeRegistro.

El código superior nos muestra las dos formas de especificar que conexión y que transacción usan los objetos. En la primera se establecen explícitamente, en la segunda se hace a través de un artilugio software (una clase vamos) que nos crea el objeto y establece estos valores obteniéndolos de TranscationHelper, pero, y esto es lo importante, con una sola línea de código. “Menos líneas menos errores”

Trabajar con conexiones

La forma en que el modelo hace uso de las conexiones es muy ¿simpe?: Si el objeto de la capa de datos tiene una conexión asignada la usa, si no y si tiene un ConnectionProvider lo invocará almacenando el resultado. En el caso de que las dos anteriores condiciones no se cumplan buscará primero una conexión compartida que usar. Si no la encuentra creará una nueva conexión y la almacenará por si el objeto la necesitara posteriormente. Es muy importante llamas al metodo Dispose de los objetos del DAL y que de no hacerlo las conexiones siguen abiertas. por lo tanto es “obligatorio” utilizar el patrón Using que implicitamente llamará a Dispose por nosotros:

Public Function Carga() As Negocio.Envios
  Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)
    Return Dal.Loader.LoadObjects(Of Envio)(Me, D__.GetItems())
  End Using
End Function

En el formulario de pruebas hemos agregado un nuevo botón y un manejador para realizar, ahora, unas pruebas de modificación de objetos.

  Private Sub btnModificar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnModificar.Click
    Dim TH As New Negocio.TransactionHelper(Dal.DataServer.GetNewConection())
    Try
      With Negocio.Factory.Crear(Of Negocio.Envios)(TH).Carga()
        For Each env In .this.Where(Function(envio) envio.Usuario = "Test")
          env.Usuario = "OldTest"
          env.Save()
        Next
      End With
    Catch ex As Exception
      Trace.WriteLine(ex.Message)
      MsgBox(ex.Message)
    Finally
      TH.Dispose()
    End Try
  End Sub

Este es su aspecto después de ejecutar el código superior

Aquí podemos ver como creamos un objeto TransactionHelper para pasárselo al “Creador de objetos” Factory e inmediatamente llamar al método Carga() del objeto devuelto. Con este método, y aprovechando la sentecia With, nos ahorramos la posible variable local, creamos y cargamos en la misma línea. Después vemos la utilidad de la propiedad This de “nuestros” objetos al permitirnos referenciar la colección dentro de un With y utilizando LINQ obtener solo los envios hechos por “Test”.

Cambiamos el valor de alguna propiedad y grabamos. ESTO SON OBJETOS. Creo que este tipo de flexibilidad es la que hay que ir buscando a la hora de diseñar los objeto ya que, con la actual capacidad de proceso de las maquinas con las que nos encontramos hoy en día, el recuperar 30 objetos con una simple sentencia “Select * from tabla” filtrarlos con LINQ y actualizar finalmente 4 es preferible a aplicaciones con decenas de “Optimizadas” y “es un solo sitio usadas” operaciones de actualizacion y/o borrado. Por otro lado el utilizar estructuras simples y poco acopladas unas con otras reduce sustancialmente los tiempos de desarrollo. Posteriormente siempre es posible “Optimizar” el procedimiento que hemos detectado problemático.

En resumén si lo que quiero es realizar “una sola” operación de carga no es necesario especificar la conexión a utilizar bastaría lo siguiente:

With New Negocio.Envios().Carga()
  For Each env In .this.Where(Function(envio) envio.Usuario = "Test")
    Trace.WriteLine(env.Id)
  Next
End With

Si lo que queremos es realizar varias operaciones, por ejemplo: cargar un grupo de clientes y sus facturas sería conveniente aprovechar la misma conexión con el fin de evitar una constante creación de conexiones. Utilizaríamos el siguiente patrón:

Dim TH As New Negocio.TransactionHelper(Dal.DataServer.GetNewConection())
With Negocio.Factory.Crear(Of Negocio.Envios)(TH).Carga()
  For Each env In .this.Where(Function(envio) envio.Usuario = "Test")
    With Negocio.Factory.Crear(Of Negocio.Anexo)(TH).Carga(env.Id)
        .
        .  
    End With
    With Negocio.Factory.Crear(Of Negocio.Historico)(TH).Carga(env.Id)
        .
        .
    End With
  Next
End with

Saludos a todos.

Un ejemplo práctico II.

2008-12-18T10:13:00.001+01:00

En esta segunda entrega del ejemplo práctico pretendo mostrar:

Las posibilidades de obtener las trazas de toda consulta realizada en la capa DAL.
Las diferentes formas de inicialización, carga y utilización de los objetos.
La implementación de transacciones en el modelo.
Utilización de las conexiones.

Como es interesante conocer en todo momento los tiempos de carga de los objetos, el modelo dispone de un mecanismo de notificación de comienzo y fin de carga (OnBeginLoad y OnEndLoad). Pero esto lo veremos más adelante. Ahora solo agregar el código para un Timer mas preciso.

No recuerdo muy bien dónde encontré el código en C# pero creo que fue en www.kalme.de.

Este el código de Dal.Core.DXTimer.vb, archivo que hay que añadir al proyecto DAL aunque, ahora tras algún tiempo, estoy empezando a cuestionarme si no debiera estar en otra Capa. No obstante el cambio de localización de esta clase no compromete en nada el modelo.

Imports System
Imports System.Runtime.InteropServices

Namespace Dal
  Public Class DXTimer

#Region " imported functions "
    <System.Security.SuppressUnmanagedCodeSecurity()> _
    Private Declare Function QueryPerformanceFrequency Lib "kernel32" (ByRef PerformanceFrequency As Long) As Boolean
    <System.Security.SuppressUnmanagedCodeSecurity()> _
    Private Declare Function QueryPerformanceCounter _
    Lib "kernel32" (ByRef PerformanceCount As Long) As Boolean
#End Region

    ' The last number of ticks.
    Private Shared lLastTime As Long = 0
    ' The current number of ticks.
    Private Shared lCurrentTime As Long = 0
    ' The number of ticks per second for this system.
    ' This will be a constant value.
    Private Shared lTicksPerSecond As Long = 0
    ' Indicates if the Timer is initialized
    Private Shared bInitialized As Boolean = False
    ' The elapsed seconds since the last GetElapsedSeconds() call.
    Private Shared dElapsedSeconds As Double = 0.0
    ' The elapsed milliseconds since the last   GetElapsedMilliseconds() call.
    Private Shared dElapsedMilliseconds As Double = 0.0

    ' Property to query the ticks per second  for this system (Timer has to be initialized).
    Public Shared ReadOnly Property TicksPerSecond() As Long
      Get
        Return lTicksPerSecond
      End Get
    End Property

    ' The initialization of the timer. Tries to query
    ' performance frequency and determines if performance
    ' counters are supported by this system.
    Public Shared Sub Init()
      ' Try to read frequency. 
      ' If this fails, performance counters are not supported.
      If QueryPerformanceFrequency(lTicksPerSecond) = False Then
        Throw New Exception("Performance Counter not supported on this system!")
      End If
      ' Initialization successful
      bInitialized = True
    End Sub

    ' Starts the Timer. This set the initial time value.
    ' Timer has to be initialized for this.
    Public Shared Sub Start()
      ' Check if initialized
      If bInitialized = False Then
        Throw New Exception("Timer no initializado!")
      End If

      ' Initialize time value
      QueryPerformanceCounter(lLastTime)

    End Sub


    ' Gets the elapsed milliseconds since the last
    ' call to this function. Timer has to be initialized
    ' for this.
    ' Returns The number of milliseconds.
    Public Shared Function GetElapsedMilliseconds() As Double

      ' Check if initialized
      If bInitialized = False Then
        Throw New Exception("Timer no initializado!")
      End If

      ' Get current number of ticks
      QueryPerformanceCounter(lCurrentTime)

      ' Calculate number of milliseconds since last call
      dElapsedMilliseconds = (Convert.ToDouble(lCurrentTime - lLastTime) / Convert.ToDouble(lTicksPerSecond)) * 1000.0

      ' Store current number of ticks for next call
      lLastTime = lCurrentTime

      ' Return milliseconds
      Return dElapsedMilliseconds
    End Function


    ' Gets the elapsed seconds since the last call
    ' to this function. Timer has to be initialized for this.

    ' Returns The number of seconds.
    Public Shared Function GetElapsedSeconds() As Double
      ' Check if initialized
      If bInitialized = False Then
        Throw New Exception("Timer no initializedo!")
      End If
      ' Get current number of ticks
      QueryPerformanceCounter(lCurrentTime)

      ' Calculate elapsed seconds
      dElapsedSeconds = Convert.ToDouble(lCurrentTime - lLastTime) / Convert.ToDouble(lTicksPerSecond)

      ' Store current number of ticks for next call
      lLastTime = lCurrentTime

      ' Return number of seconds
      Return dElapsedSeconds
    End Function

    Public Shared Rnd As New Random(DateTime.Now.Millisecond)
  End Class
End Namespace

Un ejemplo práctico

2008-12-17T10:04:00.001+01:00

Con esta entrada pretendo dar una visión generar del modelo y mostrar algunos ejemplos de su utilización.

Quiero hacer hincapié en que lo que se pretende es acortar el tiempo de desarrollo, homogeneizar el código fuente y ALGO MUY IMPORTANTE: reducirlo . Ya lo dijo el sabio “menos líneas menos errores”.

Lo primero que tenemos que hacer es configurar una solución con el aspecto de la imagen de la derecha.

Todos los ficheros están como antiguas entradas. La tabla que vamos a utilizar tiene el siguiente definición:

CREATE TABLE [dbo].[T_Envio](
    [Id] [int] IDENTITY(1,1) NOT NULL,
    [IdEnvio] [nvarchar](250) COLLATE Modern_Spanish_CI_AS NOT NULL,
    [Observaciones] [nvarchar](200) COLLATE Modern_Spanish_CI_AS NULL,
    [NumeroDeRegistro] [nvarchar](250) COLLATE Modern_Spanish_CI_AS NOT NULL,
    [FechaDeRegistro] [datetime] NOT NULL,
    [Fecha] [datetime] NOT NULL CONSTRAINT [DF_T_Envio_Fecha]  DEFAULT (getdate()),
    [Usuario] [nvarchar](250) COLLATE Modern_Spanish_CI_AS NOT NULL,
 CONSTRAINT [PK_T_Envio] PRIMARY KEY CLUSTERED 
(
    [Id] ASC
)WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]

A continuación deberemos crear un nuevo proyecto para la capa que nos queda, la capa de presentación. En este proyecto es en el que veremos las distintas formas de utilizar los objetos.

De dónde se obtienen los datos.

Una de las primeras cosas que, cuando empecé en esto, me sorprendía, es que en todos los ejemplos de acceso a datos que encontraba por ahí, las conexiones con la base de datos se establecían al ladito de donde se cargaban los objetos de la capa de negocio. Esto, a mi modo de ver, no encaja en un enfoque orientado a objetos donde estos TIENEN que tener la posibilidad de no conocer cual es origen de los datos, pero también TIENEN que tener la posibilidad de especificarlo.

¿Como se resuelve esta aparente paradoja? Pues dotándoles de dos propiedades que son delegados que retornaran, si están establecidos, la conexión y la transacción asignados a ese objeto. En el caso que no establezcamos dichos valores será la capa de acceso a datos la que tenga que decidir que conexión utilizar. Esta decisión se basa en si el proyecto es WEB o WindowsForm (supongo que la conexión está abierta durante la ejecución de la aplicación).

Para simplificar las cosas aquí van dos ejemplos:

Aplicación ASP.NET

  Sub Application_Start(ByVal sender As Object, ByVal e As EventArgs)
    'Dal.DataServer.SetWebConnection(System.Configuration.ConfigurationManager.AppSettings("ConnectionString"))
    Dal.DataServer.SetWebConnection("server=.;database=TEST;uid=user;pwd=xxx")
  End Sub

Aplicación WindowsForm:

Dal.DataServer.Open("server=.;database=TEST;uid=user;pwd=xxx")

La diferencia entre los dos “Modelos” es que en la primera se especifica la cadena de conexión y en la otra se abre realmente y queda a disposición de la aplicación.

Veamos cual es el camino que sigue una petición de carga:

1. Se solicita la carga de un objeto:

 Dim __Envios As Negocio.Envios = New Negocio.Envios().Carga()

2. La capa de negocio pasa la petición a la de Datos y le informa de lo que sabe (sus “provider”)

    Public Function Carga(ByVal id As Integer) As Envio
      Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)
        Dal.Loader.LoadObject(Me, D__.GetItem(id))
      End Using
      Return Me ' El que los métodos devuelvan la instancia permite muuuuchas cosas.
    End Function

En este enlace se puede ver algún ejemplo de lo que se puede conseguir con la implementación de funciones que devuelven la instancia en lugar de la implementación de simples métodos. El que lo dice no es un cualquiera.

3. El DAL realiza una serie de comprobaciones para determinar los parámetros( conexión y transacción) que debe utilizar:

Protected Function CreateCommand() As System.Data.IDbCommand
  Dim cmd As IDbCommand = ConexionEnUso.CreateCommand()
  cmd.Connection = ConexionEnUso
  cmd.Transaction = TransaccionEnUso
  Return cmd
End Function
Private _ConexionActual As IDbConnection = Nothing
Protected ReadOnly Property ConexionEnUso() As IDbConnection
  Get
    ' Primero se intenta usar la conexion asignada al objeto
    If _ConexionActual IsNot Nothing Then Return _ConexionActual
    ' Luego se intenta usar el proveedor de conexion
    If Me.ConnectionProvider IsNot Nothing Then
      _ConexionActual = ConnectionProvider.Invoke()
      Return _ConexionActual
    End If
    ' Si la conexion compartida no existe se crea una nueva (normalmente para uso con WebForm)
    If DataServer.Connection Is Nothing Then
      _ConexionActual = DataServer.GetNewConection()
      Return _ConexionActual
    End If
    Return DataServer.Connection() ' Se devuelve la connexion compartida (Esta ser� la usada normalmente por WindowsForm)
  End Get
End Property

Public Function GetItem(ByVal id As Integer) As IDataReader
  Using cmd As IDbCommand = CreateCommand()   
    cmd.CommandText = String.Format("Select * from [TELMA_Envio] where Id={0}", id)
    Return DataServer.ExecuteReader(cmd)
  End Using
End Function

Otro día entraré a fondo en la clase DataServer y sus métodos y como nos permite controlar, trazar TODAS las consultas que hacemos a la base de datos. También debería volver a buscar las páginas de las que aprendí todo lo que estoy poniendo aquí y enlazarlas. Prometo hacerlo.

Cómo deben comportarse los objetos

Los objetos deben comportarse bieen y ser bueeeeeeeeenos. Además, y algo muy importante, TODOS deben comportarse de forma parecida a fin de que el conocimiento por parte de un componente del equipo del código de un objeto u objetos, le haga sentirse a gusto con el código desarrollado por los otros componentes.

Yo propongo que:

Los elementos (no colecciones) deben poder grabarse, borrarse y cargarse.
La grabación: Inserciones y actualizaciones se facilita si adoptamos Id únicos por registro. Yo siempre que puedo uso auto numéricos.
Con autonumericos el establecimiento de objeto.Id=0 implica una inserción en la base de datos al llamar a objeto.Save(). Posteriores llamadas as Save() provocan la actualización.
Los constructores de objetos NUNCA cargan el objeto. Utilizo New Negocio.Envio().Carga(25).
Los Elementos No cargan colecciones, eso lo dejo para las coleccionesDeObjetos
Las Colecciones de objetos SON LAS RESPONSABLES de cargar grupos de objetos. Para ello deberán tener metodos con nombres significativos como: CargaPorId(codigo), CargaPendientes(), etc. Por favor evitar esto: CarIElePend(), No hay quien se entere luego.
Siempre que se pueda, y aquí entran cuestiones de rendimiento, el primer enfoque que doy a la carga de entidades relacionada es la Lazy Load o Carga Perezosa con algun mecanismo de caheo. De esta manera los objetos no pierden “su integridad” y siguen funcionando como se espera tras implementar diferentes modos de carga: en un escenario haciendo un inner join con Provincias y en otro escenario con Facturas donde no interesa en absoluto la información de las anteriores. Esto también es tema de grandes discusiones y de otro posible post.

El ejemplo

Bueno todo esto empezó con que iba a poner un ejemplo. Al final me he liado.

Una vez que tenemos una ventana de prueba en un proyecto de prueba en el que hemos referenciado Dal.dll y Negocio.dll

escribimos es siguiente código en el formulario:

Public Class Form1
  Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
    ' Si quisieramos una sola conexión por aplicación descomentariar la linea siguiente
    'Dal.DataServer.Open("server=.;database=TRACTORES;uid=xxx;pwd=xxx")
    ' Para simular un entorno WEB donde las conexiones se deben crear y cerrar mu rapido :-)
    Dal.DataServer.SetWebConnection("server=.;database=TRACTORES;uid=xx;pwd=xx")
  End Sub
  Private Sub btnEjecutar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnEjecutar.Click
    Me.ListBox1.DataSource = Nothing
    With New Negocio.Envios().Carga()
      Me.ListBox1.DisplayMember = "IdEnvio"
      Me.ListBox1.DataSource = .this
    End With
  End Sub
End Class

Nuestra ventana se ve así

Bueno pues esto es todo por hoy.
No he pensado nunca en hacer esto, y mira lo he hecho he escrito un articulo en un blog.
CONTINUARÁ
Saludos.

Explicación del Proyecto Base

2008-12-16T17:33:00.001+01:00

Todos estos archivos forman parte del “Proyecto base”. Exceptuando los que hacen referencia a Envíos que es una entidad de ejemplo para que se pueda ver como interactúan las dos “Capas”.

La idea es generar el código de estas dos capas: la de Negocio y la de Acceso a Datos que se repite en todas las entidades. Para esto he creado una herramienta de uso interno. Le he mandado el código tanto del generador como del proyecto base a El blog de Quique. No se si lo pondrá en geeks no obstante existen multitud de generadores que se podrían utilizar.

Es necesario decir que muchas de las cosas que este modelo tiene(buenas se entiende) no se me han ocurrido a mi solo. Lo que he hecho es solo coger algo de aquí y algo de allí y unirlo. Muchas de las ideas y de la información están en CodeProject.

Negocio.EnviosCollection.vb

2008-12-16T14:02:00.001+01:00

' Fichero generado con PolCodeGen
'        __          __               _     ___             _                   ___  
'       /__\  __ _  / _|  __ _   ___ | |   / __\ __ _  ___ | |_  _ __  ___     / _ \ ___   _ __ ___    ___  ____
'      / \// / _` || |_  / _` | / _ \| |  / /   / _` |/ __|| __|| '__|/ _ \   / /_\// _ \ | '_ ` _ \  / _ \|_  /
'     / _  \| (_| ||  _|| (_| ||  __/| | / /___| (_| |\__ \| |_ | |  | (_) | / /_\\| (_) || | | | | ||  __/ / / 
'     \/ \_/ \__,_||_|   \__,_| \___||_| \____/ \__,_||___/ \__||_|   \___/  \____/ \___/ |_| |_| |_| \___|/___|                                                                   
'

Namespace Negocio
  ''' <summary>
  ''' Envios es una slase de contiene elementos del tipo Envio
  ''' </summary>
  <Xml.Serialization.XmlRoot("Envios")> _ 
  Public Class Envios : Inherits ColeccionBase(Of Envio)
    Public Const ClassName As String = "Coleccion de Envios"
    
    ''' <summary>
    ''' Referencia a la instancia.
    ''' </summary>
    '''<example>
    ''' <c>
    ''' With New Envios()
    '''   DoSomething(.this())
    '''   .DoPrint()
    ''' End With
    ''' </c>
    ''' </example>
    Public Overloads Function this() As Envios
      Return Me
    End Function
    
    ''' <summary>
    ''' Constructor de instancias de proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    Public Shared Function Values(ByVal fieldName As String, ByVal th As TransactionHelper) As String()    
      Using D__ As New DAL.Envios()
        D__.ConnectionProvider = th.ConnectionProvider
        D__.TransactionProvider = th.TransactionProvider      
        With D__.GetDistinctItem(fieldName)
          Dim Cadenas__ As New Generic.List(Of String)
          Do Until .Read() = False
            If Not TypeOf (.GetValue(0)) Is System.DBNull Then Cadenas__.Add(.GetValue(0))
          Loop
          .Close()
          Return Cadenas__.ToArray()
        End With        
      End Using      
    End Function


#Region " Recuperación desde la Base de Datos "
    ''' <summary>
    ''' Carga todos los elementos del tipo Envio desde la base de datos en la colección
    ''' </summary>
    Public Function Carga() As Envios
      Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)
        Return Dal.Loader.LoadObjects(Of Envio)(Me, D__.GetItems())
      End Using
    End Function
    'Public Function CargaByXXX(ByVal IdXXX As Integer) As Envios
    '  Using D__ As New DAL.Envios(ConnectionProvider, TransactionProvider)
    '    Return DAL.Loader.LoadObjects(Of Envio)(Me, D__.GetItemsByXXX(IdXXX))
    '  End Using      
    'End Function    
#End Region
  

  End Class
End Namespace

Negocio.Envio.vb

2008-12-16T14:01:00.001+01:00

' Fichero autogenerado con PolCodeGen
'        __          __               _     ___             _                   ___  
'       /__\  __ _  / _|  __ _   ___ | |   / __\ __ _  ___ | |_  _ __  ___     / _ \ ___   _ __ ___    ___  ____
'      / \// / _` || |_  / _` | / _ \| |  / /   / _` |/ __|| __|| '__|/ _ \   / /_\// _ \ | '_ ` _ \  / _ \|_  /
'     / _  \| (_| ||  _|| (_| ||  __/| | / /___| (_| |\__ \| |_ | |  | (_) | / /_\\| (_) || | | | | ||  __/ / / 
'     \/ \_/ \__,_||_|   \__,_| \___||_| \____/ \__,_||___/ \__||_|   \___/  \____/ \___/ |_| |_| |_| \___|/___|                                                                   

Namespace Negocio
  ''' <summary>
  ''' Clase de Envio
  ''' </summary>
  <Serializable()> _
  Public Class Envio : Inherits ObjetoBase
    Public Const ClassName As String = "Envio"
    
#Region " Recuperación desde la Base de Datos "
    ''' <summary>
    ''' Carga el objeto con los valores del registro de la base de datos con el id especificado.
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function Carga(ByVal id As Integer) As Envio
      Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)
        Dal.Loader.LoadObject(Me, D__.GetItem(id))
      End Using
      Return Me
    End Function
#End Region 

#Region " Grabar y Borrar "
    ''' <summary>
    ''' Constructor de instancias de proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function Save() As Envio
      Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)        
        If _id = 0 Then
          _id = D__.Insert(IdEnvio, Observaciones, NumeroDeRegistro, FechaDeRegistro, Usuario)
        Else
          D__.Update(Id, IdEnvio, Observaciones, NumeroDeRegistro, FechaDeRegistro, Usuario)
        End If
        Return Me
      End Using
    End Function
    
    ''' <summary>
    ''' Constructor de instancias de proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    Public Overrides Function DeleteString() As String
      Return "Confirma la eliminación del Envio: {0}"
    End Function
    
    ''' <summary>
    ''' Constructor de instancias de proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    Public Sub Delete()
      Using D__ As New Dal.Envios(ConnectionProvider, TransactionProvider)
        D__.Delete(_id)        
      End Using  
    End Sub
#End Region   
  


#Region " Propiedades enlazadas a Datos "

    Private _id As Integer
    ''' <summary>
    ''' Obtiene o establece el Id del Envio
    ''' </summary>
    ''' <value>
    ''' La propiedad Id obtiene o establece el valor de la variable privada _id.
    ''' </value>
    Public Overrides Property Id() As Integer
      Get
        Return _id
      End Get
      Set(ByVal value As Integer)      
        _id = value
      End Set
    End Property

    Private _idEnvio As String
    ''' <summary>
    ''' Obtiene o establece el IdEnvio del Envio
    ''' </summary>
    ''' <value>
    ''' La propiedad IdEnvio obtiene o establece el valor de la variable privada _idEnvio.
    ''' </value>
    Public Property IdEnvio() As String
      Get
        Return _idEnvio
      End Get
      Set(ByVal value As String)      
        _idEnvio = value
      End Set
    End Property

    Private _observaciones As String
    ''' <summary>
    ''' Obtiene o establece el Observaciones del Envio
    ''' </summary>
    ''' <value>
    ''' La propiedad Observaciones obtiene o establece el valor de la variable privada _observaciones.
    ''' </value>
    Public Property Observaciones() As String
      Get
        Return _observaciones
      End Get
      Set(ByVal value As String)      
        _observaciones = value
      End Set
    End Property

    Private _numeroDeRegistro As String
    ''' <summary>
    ''' Obtiene o establece el NumeroDeRegistro del Envio
    ''' </summary>
    ''' <value>
    ''' La propiedad NumeroDeRegistro obtiene o establece el valor de la variable privada _numeroDeRegistro.
    ''' </value>
    Public Property NumeroDeRegistro() As String
      Get
        Return _numeroDeRegistro
      End Get
      Set(ByVal value As String)      
        _numeroDeRegistro = value
      End Set
    End Property

    Private _fechaDeRegistro As String
    ''' <summary>
    ''' Obtiene o establece el FechaDeRegistro del Envio
    ''' </summary>
    ''' <value>
    ''' La propiedad FechaDeRegistro obtiene o establece el valor de la variable privada _fechaDeRegistro.
    ''' </value>
    Public Property FechaDeRegistro() As String
      Get
        Return _fechaDeRegistro
      End Get
      Set(ByVal value As String)      
        Try
      _fechaDeRegistro = DateTime.Parse(value).ToString("dd/MM/yyyy")
    Catch e As Exception
      _fechaDeRegistro = ""
    End Try
      End Set
    End Property

    Private _fecha As String
    ''' <summary>
    ''' Obtiene o establece el Fecha del Envio
    ''' </summary>
    ''' <value>
    ''' La propiedad Fecha obtiene o establece el valor de la variable privada _fecha.
    ''' </value>
    Public Property Fecha() As String
      Get
        Return _fecha
      End Get
      Set(ByVal value As String)      
        Try
      _fecha = DateTime.Parse(value).ToString("dd/MM/yyyy")
    Catch e As Exception
      _fecha = ""
    End Try
      End Set
    End Property

    Private _usuario As String
    ''' <summary>
    ''' Obtiene o establece el Usuario del Envio
    ''' </summary>
    ''' <value>
    ''' La propiedad Usuario obtiene o establece el valor de la variable privada _usuario.
    ''' </value>
    Public Property Usuario() As String
      Get
        Return _usuario
      End Get
      Set(ByVal value As String)      
        _usuario = value
      End Set
    End Property

#End Region    

    ''' <summary>
    ''' Devuelve una cadena que representa al objeto
    ''' </summary>
    Public Overrides Function ToString() as String
      Return id.ToString() & " " & idEnvio.ToString() & " " & observaciones.ToString() & " " & numeroDeRegistro.ToString() & " " & fechaDeRegistro.ToString() & " " & fecha.ToString() & " " & usuario.ToString()
    End Function
    
    ''' <summary>
    ''' Devuelve una cadena que representa al objeto
    ''' </summary>
    ''' <param name="customFormat"> Indica se se realizará el formato personalizado </param>
    Public Overrides Function ToString(ByVal customFormat As Boolean) As String      
      Return Me.ToString()
    End Function
    
    ''' <summary>
    ''' Constructor de instancias de proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    '''<example>
    ''' <c>
    ''' With New Envio()
    '''   DoSomething(.this())
    '''   .DoPrint()
    ''' End With
    ''' </c>
    ''' </example>
    Public Shadows Function this() As Envio
      Return Me
    End Function

#Region " Cargador del objeto "
    ''' <summary>
    ''' Constructor de instancias de proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    Private Shared Sub InitDataBinder()
      If _DataBinder Is Nothing Then
        With New Dal.ObjectLoader()
          _DataBinder = .this
          .Add(New Dal.BindItem("id", "Id", 0,GetType(Integer)))
          .Add(New Dal.BindItem("idEnvio", "IdEnvio", 1,GetType(String)))
          .Add(New Dal.BindItem("observaciones", "Observaciones", 2,GetType(String)))
          .Add(New Dal.BindItem("numeroDeRegistro", "NumeroDeRegistro", 3,GetType(String)))
          .Add(New Dal.BindItem("fechaDeRegistro", "FechaDeRegistro", 4,GetType(Date)))
          .Add(New Dal.BindItem("fecha", "Fecha", 5,GetType(Date)))
          .Add(New Dal.BindItem("usuario", "Usuario", 6,GetType(String)))       
        End with
      End If
    End Sub

    Shared _DataBinder As Dal.ObjectLoader = Nothing
    
    ''' <summary>
    ''' Constructor de instancias de proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Overrides Function GetBinder() As Dal.ObjectLoader
      InitDataBinder()
      Return _DataBinder
    End Function
#End Region
  
  End Class
End Namespace

Negocio.Core.TransactionHelper.vb

2008-12-16T13:59:00.003+01:00

Namespace Negocio

  Public Class TransactionHelper : Implements IDisposable

    Public Sub New(ByVal connection As IDbConnection)
      _Connection = connection
    End Sub

    Public Sub BeginTransaction()
      _Transaction = Dal.DataServer.CreateTransaction(_Connection)
    End Sub

    Public Sub Commit()
      Dal.DataServer.Commit(_Transaction)
    End Sub
    Public Sub RollBack()
      Dal.DataServer.Rollback(_Transaction)
    End Sub

    Private _Connection As IDbConnection
    Public Function Connection() As IDbConnection
      Return _Connection
    End Function

    Private _Transaction As IDbTransaction
    Public Function Transaction() As IDbTransaction
      Return _Transaction
    End Function

    Public ReadOnly Property ConnectionProvider() As Dal.ConnectionProviderDelegate
      Get
        Return AddressOf Connection
      End Get
    End Property

    Public ReadOnly Property TransactionProvider() As Dal.TransactionProviderDelegate
      Get
        Return AddressOf Transaction
      End Get
    End Property

#Region " IDisposable "
    Private _disposedValue As Boolean = False
    Protected Overridable Sub Dispose(ByVal disposing As Boolean)
      If Not Me._disposedValue Then
        If disposing Then

        End If
        Connection.Close()
        Connection.Dispose()
      End If
      Me._disposedValue = True
    End Sub
    Public Sub Dispose() Implements IDisposable.Dispose
      Dispose(True)
      GC.SuppressFinalize(Me)
    End Sub
#End Region


  End Class

End Namespace

Negocio.Core.ObjetoBase.vb

2008-12-16T13:59:00.001+01:00

Namespace Negocio

  <Serializable()> _
  Public MustInherit Class ObjetoBase : Implements IExportable : Implements Dal.ILoader
    Public MustOverride Property Id() As Integer
    Public MustOverride Overloads Function ToString(ByVal CustomFormat As Boolean) As String

    Public Sub New()
    End Sub

    Public Overridable Function DeleteString() As String
      Return "Confirma la eliminacion del elemento: {0}"
    End Function


#Region " Interface ILoader "
    <NonSerialized()> _
    Private _ConnectionProvider As Dal.ConnectionProviderDelegate = Nothing
    <Xml.Serialization.XmlIgnore()> _
    Public Property ConnectionProvider() As Dal.ConnectionProviderDelegate Implements Dal.ILoader.ConnectionProvider
      Get
        Return _ConnectionProvider
      End Get
      Set(ByVal value As Dal.ConnectionProviderDelegate)
        _ConnectionProvider = value
      End Set
    End Property

    <NonSerialized()> _
    Private _TransactionProvider As Dal.TransactionProviderDelegate = Nothing
    <Xml.Serialization.XmlIgnore()> _
    Public Property TransactionProvider() As Dal.TransactionProviderDelegate Implements Dal.ILoader.transactionProvider
      Get
        Return _TransactionProvider
      End Get
      Set(ByVal value As Dal.TransactionProviderDelegate)
        _TransactionProvider = value
      End Set
    End Property

    Public Overridable Function GetBinder() As Dal.ObjectLoader Implements Dal.ILoader.GetObjectLoader
      Return Nothing
    End Function
#End Region

    Public Overridable Function ToXml() As String Implements IExportable.FormatoXml
      With New Xml.Serialization.XmlSerializer(Me.GetType)
        Dim _SWriter As New IO.StringWriter()
        .Serialize(_SWriter, Me)
        Dim xml As String = _SWriter.ToString()
        With New System.Xml.XmlDocument()
          .LoadXml(xml)
          Return .DocumentElement.InnerXml
        End With
      End With
    End Function

    Public Overridable Function ToCSV(ByVal separador As String) As String Implements IExportable.FormatoCsv
      With New Xml.Serialization.XmlSerializer(Me.GetType)
        Dim _SWriter As New IO.StringWriter()
        .Serialize(_SWriter, Me)
        With New System.Xml.XmlDocument()
          .LoadXml(_SWriter.ToString())
          Dim s As New System.Text.StringBuilder
          For i As Integer = 0 To .ChildNodes(1).ChildNodes.Count - 1
            s.Append(.ChildNodes(1).ChildNodes(i).InnerText.Replace(separador, ".") & separador)
          Next
          s.Remove(s.Length - 1, 1)
          Return s.ToString
        End With
      End With
    End Function

    Public Overridable Function HeaderCSV(ByVal separador As String) As String Implements IExportable.HeaderCsv
      With New Xml.Serialization.XmlSerializer(Me.GetType)
        Dim _SWriter As New IO.StringWriter()
        .Serialize(_SWriter, Me)
        With New System.Xml.XmlDocument()
          .LoadXml(_SWriter.ToString())
          Dim s As New System.Text.StringBuilder
          For i As Integer = 0 To .ChildNodes(1).ChildNodes.Count - 1
            s.Append(.ChildNodes(1).ChildNodes(i).Name & separador)
          Next
          s.Remove(s.Length - 1, 1)
          Return s.ToString
        End With
      End With
    End Function

    Public Function this() As ObjetoBase
      Return Me
    End Function

    <NonSerialized()> _
    Private _Tag As Object = Nothing
    <Xml.Serialization.XmlIgnore()> _
    Public Property Tag() As Object
      Get
        Return _Tag
      End Get
      Set(ByVal Value As Object)
        _Tag = Value
      End Set
    End Property

    Public Shared Function ToBase64XmlString(Of T)(ByVal input As T) As String
      If input Is Nothing Then Return Nothing
      Dim writer As New IO.MemoryStream()
      Dim formatter As Xml.Serialization.XmlSerializer = New Xml.Serialization.XmlSerializer(input.GetType)
      formatter.Serialize(writer, input)
      Return Convert.ToBase64String(writer.ToArray)
    End Function

    Public Shared Function FromBase64XmlString(Of T)(ByVal input As String) As T
      If input Is Nothing Or input.Length = 0 Then Return Nothing
      Dim formatter As Xml.Serialization.XmlSerializer = New Xml.Serialization.XmlSerializer(GetType(T))
      Return formatter.Deserialize(New IO.MemoryStream(Convert.FromBase64String(input)))
    End Function


#Region " Compresion "


    Public Shared Function ToBase64XmlStringCompress(Of T)(ByVal input As T) As String
      If input Is Nothing Then Return Nothing
      Dim writer As New IO.MemoryStream()
      Dim formatter As Xml.Serialization.XmlSerializer = New Xml.Serialization.XmlSerializer(input.GetType)
      'Dim formatter As Runtime.Serialization.Formatters.Binary.BinaryFormatter = New Runtime.Serialization.Formatters.Binary.BinaryFormatter()
      formatter.Serialize(writer, input)
      writer.Position = 0
      Return Convert.ToBase64String(Compress(writer))
    End Function

    Public Shared Function FromBase64XmlStringCompress(Of T)(ByVal input As String) As T
      If input Is Nothing Or input.Length = 0 Then Return Nothing
      Dim formatter As Xml.Serialization.XmlSerializer = New Xml.Serialization.XmlSerializer(GetType(T))
      'Dim formatter As Runtime.Serialization.Formatters.Binary.BinaryFormatter = New Runtime.Serialization.Formatters.Binary.BinaryFormatter()
      Return formatter.Deserialize(New IO.MemoryStream(Decompress(New IO.MemoryStream(Convert.FromBase64String(input)))))
    End Function

    Private Shared Function Compress(ByVal stream As IO.Stream) As Byte()
      Using resultStream As IO.MemoryStream = New IO.MemoryStream()
        Using writeStream As IO.Compression.GZipStream = New IO.Compression.GZipStream(resultStream, IO.Compression.CompressionMode.Compress, True)
          CopyBuffered(stream, writeStream)
        End Using
        Return resultStream.ToArray()
      End Using
    End Function

    Private Shared ReadOnly bufferSize As Integer = 10000
    Private Shared Sub CopyBuffered(ByVal readStream As IO.Stream, ByVal writeStream As IO.Stream)
      Dim bytes(bufferSize) As Byte
      Dim byteCount As Integer = readStream.Read(bytes, 0, bytes.Length)
      While byteCount <> 0
        writeStream.Write(bytes, 0, byteCount)
        byteCount = readStream.Read(bytes, 0, bytes.Length)
      End While
    End Sub

    Private Shared Function Decompress(ByVal stream As IO.Stream) As Byte()
      Using decompressedStream As IO.Stream = New IO.Compression.GZipStream(stream, IO.Compression.CompressionMode.Decompress, False)
        Using resultStream As IO.MemoryStream = New IO.MemoryStream()
          CopyBuffered(decompressedStream, resultStream)
          Return resultStream.ToArray()
        End Using
      End Using
    End Function
#End Region


  End Class

End Namespace

Negocio.Core.IExportable.vb

2008-12-16T13:57:00.001+01:00

Namespace Negocio

  Public Interface IExportable
    Function FormatoXml() As String
    Function FormatoCsv(ByVal separador As String) As String
    Function HeaderCsv(ByVal separador As String) As String
  End Interface

End Namespace

Negocio.Core.Factory.vb

2008-12-16T13:56:00.001+01:00

Namespace Negocio

  Public Class Factory

    Public Shared Function Crear(Of T As {New, Dal.ILoader})(ByVal th As TransactionHelper) As T
      Dim __O As T = New T
      __O.ConnectionProvider = th.ConnectionProvider
      __O.transactionProvider = th.TransactionProvider
      Return __O
    End Function

    Public Shared Function Crear(Of T As {New, Dal.ILoader})(ByVal cp As Dal.ConnectionProviderDelegate, ByVal tp As Dal.TransactionProviderDelegate) As T
      Dim __O As T = New T
      __O.ConnectionProvider = cp
      __O.transactionProvider = tp
      Return __O
    End Function

    Public Shared Function Crear(Of T As {New, Dal.ILoader})(ByVal cp As Dal.ConnectionProviderDelegate) As T
      Dim __O As T = New T
      __O.ConnectionProvider = cp
      Return __O
    End Function

    Public Shared Function Crear(Of T As {New, Dal.ILoader})(ByVal servidor As String, ByVal baseDeDatos As String, ByVal usuario As String, ByVal password As String) As T
      Return Crear(Of T)(New TransactionHelper(Dal.DataServer.GetNewConection(servidor, baseDeDatos, usuario, password)).ConnectionProvider)
    End Function

    Public Function this() As Factory
      Return Me
    End Function

  End Class

End Namespace

Negocio.Core.CollectionBase.vb

2008-12-16T13:55:00.001+01:00

Namespace Negocio

  <Serializable()> _
  Public MustInherit Class ColeccionBase(Of T As ObjetoBase) : Inherits Generic.List(Of T) : Implements Dal.ILoader

    Public Overloads Sub Remove(ByVal id As String)
      MyBase.Remove(Item(id))
    End Sub

    Default Public Overloads ReadOnly Property Item(ByVal id As String) As T
      Get
        Return Me.Find(Function(o As ObjetoBase) o.Id = id)
      End Get
    End Property

#Region " Interface ILoader "
    Private _ConnectionProvider As Dal.ConnectionProviderDelegate = Nothing
    <Xml.Serialization.XmlIgnore()> _
    Public Property ConnectionProvider() As Dal.ConnectionProviderDelegate Implements Dal.ILoader.ConnectionProvider
      Get
        Return _ConnectionProvider
      End Get
      Set(ByVal value As Dal.ConnectionProviderDelegate)
        _ConnectionProvider = value
      End Set
    End Property

    Private _TransactionProvider As Dal.TransactionProviderDelegate = Nothing
    <Xml.Serialization.XmlIgnore()> _
    Public Property TransactionProvider() As Dal.TransactionProviderDelegate Implements Dal.ILoader.transactionProvider
      Get
        Return _TransactionProvider
      End Get
      Set(ByVal value As Dal.TransactionProviderDelegate)
        _TransactionProvider = value
      End Set
    End Property

    Public Overridable Function GetBinder() As Dal.ObjectLoader Implements Dal.ILoader.GetObjectLoader
      Return Nothing
    End Function
#End Region

    <NonSerialized()> _
    Private _Tag As Object = Nothing
    <Xml.Serialization.XmlIgnore()> _
    Public Property Tag() As Object
      Get
        Return _Tag
      End Get
      Set(ByVal Value As Object)
        _Tag = Value
      End Set
    End Property

  End Class

End Namespace

Dal.Core.Helper.vb

2008-12-16T13:54:00.001+01:00

Namespace Dal
  Public NotInheritable Class Helpers

    Private Sub New()
    End Sub


    ' Formatear cadenas para sentencias SQL
    Public Shared Function ParseCadena(ByVal value As String) As String
      If value Is Nothing OrElse value.Length = 0 Then Return "NULL"
      Return String.Format("'{0}'", value.Replace("'", "''"))
    End Function

    ' Formatear cadenas para sentencias SQL
    Public Shared Function ParseNulableInteger(ByVal value As String) As String
      Dim i As Integer
      If Integer.TryParse(value, i) = False Then Return "NULL"
      If i = 0 Then Return "NULL"
      Return i
    End Function

    ' Formatear N�meros para sentencias SQL
    Public Shared Function FormateaNumero(ByVal value As String) As String
      If value Is Nothing OrElse value.Length = 0 Then Return "NULL"
      Return Replace(value, ",", ".")
    End Function

    ' Formatear Fechas para sentencias SQL
    Public Shared Function ParseFecha(ByVal value As String) As String
      If value Is Nothing OrElse value.Length = 0 Then Return "NULL"
      Try
        Return Date.Parse(value).ToString("\'yyyyMMdd HH:mm:ss\'")
      Catch e As Exception
        Return "NULL"
      End Try
    End Function

  End Class

  Public Module HexHelper
    <System.Runtime.CompilerServices.Extension()> _
    Public Function ToHexString(ByVal value As Byte()) As String
      Dim hex As System.Text.StringBuilder = New System.Text.StringBuilder(value.Length * 2)
      For Each b As Byte In value
        hex.AppendFormat("{0:x2}", b)
      Next
      Return hex.ToString()
    End Function  
  End Module


End Namespace

Dal.Envios.vb

2008-12-16T13:53:00.001+01:00

' Fichero autogenerado con PolCodeGen
'        __          __               _     ___             _                   ___  
'       /__\  __ _  / _|  __ _   ___ | |   / __\ __ _  ___ | |_  _ __  ___     / _ \ ___   _ __ ___    ___  ____
'      / \// / _` || |_  / _` | / _ \| |  / /   / _` |/ __|| __|| '__|/ _ \   / /_\// _ \ | '_ ` _ \  / _ \|_  /
'     / _  \| (_| ||  _|| (_| ||  __/| | / /___| (_| |\__ \| |_ | |  | (_) | / /_\\| (_) || | | | | ||  __/ / / 
'     \/ \_/ \__,_||_|   \__,_| \___||_| \____/ \__,_||___/ \__||_|   \___/  \____/ \___/ |_| |_| |_| \___|/___|                                                                   
'

Imports Dal.Helpers

Namespace Dal
  ''' <summary>
  ''' Clase de acceso a datos de Envios
  ''' </summary>
  Public Class Envios : Inherits ObjetoBase  
  
#Region " Constructores "
    ''' <summary>
    ''' Contructor por defecto de instancias de Envios 
    ''' </summary>
    Public Sub New()
      MyBase.New()
    End Sub
    
    ''' <summary>
    ''' Constructor de instancias de Envios proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Sub New(ByVal conexion As IDbConnection)
      MyBase.New(conexion)
    End Sub
    
    ''' <summary>
    ''' constructor de instancias de Envios proporcionando
    ''' un proveedor de conexión y un proveedor de transacción
    ''' </summary>
    ''' <param name="cP"> Proveedor de conexión que utilizará el objeto para obtener la conexión. </param>    
    ''' <param name="tP"> Proveedor de transacción que utilizará el objeto para obtener la transacción. </param>    
    Public Sub New(ByVal cp As ConnectionProviderDelegate, ByVal tp As TransactionProviderDelegate)
      MyBase.New(cp, tp)
    End Sub
#End Region

#Region " Recuperación de datos "
    ''' <summary>
    ''' Constructor de instancias de Envios proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function GetItems() As IDataReader
      Using cmd As IDbCommand = CreateCommand()
        cmd.CommandText = "Select * from [T_Envio]"
        Return DataServer.ExecuteReader(cmd)
      End Using
    End Function
    
    ''' <summary>
    ''' Constructor de instancias de Envios proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Private Function __GetItems(ByVal filtro As String) As IDataReader
      If filtro = "" Then Return GetItems()
      Using cmd As IDbCommand = CreateCommand()
        cmd.CommandText = String.Format("Select * from [T_Envio] where 1=1 and {0}", filtro)
        Return DataServer.ExecuteReader(cmd)
      End Using
    End Function
    
    ''' <summary>
    ''' Constructor de instancias de Envios proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function GetItem(ByVal id As Integer) As IDataReader
      Using cmd As IDbCommand = CreateCommand()   
        cmd.CommandText = String.Format("Select * from [T_Envio] where Id={0}", id)
        Return DataServer.ExecuteReader(cmd)
      End Using
    End Function
    
    ''' <summary>
    ''' Constructor de instancias de Envios proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function GetDistinctItem(ByVal fieldName As String) As IDataReader
      Using cmd As IDbCommand = CreateCommand()        
        If fieldName = "" Then fieldName = "Id"
        cmd.CommandText = String.Format("Select Distinct {0} from [T_Envio] order by {0} asc", fieldName)
        Return DataServer.ExecuteReader(cmd)
      End Using
    End Function
#End Region

    ''' <summary>
    ''' Constructor de instancias de Envios proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function Delete(ByVal id As Integer) As Integer
      Using cmd As IDbCommand = CreateCommand()
        cmd.CommandText = String.Format("Delete from [T_Envio] where ID={0}", id)
        Return DataServer.ExecuteNonQuery(cmd)
      End Using
    End Function        
    
#Region " Inserción "
    ''' <summary>
    ''' Constructor de instancias de  proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function Insert(ByVal idEnvio As String, _
                           ByVal observaciones As String, _
                           ByVal numeroDeRegistro As String, _
                           ByVal fechaDeRegistro As String, _
                           ByVal usuario As String) As Integer
      Using CM As IDbCommand = CreateCommand()

        With New System.Text.StringBuilder()
          .Append("Insert into [T_Envio] ")
          .Append("(IdEnvio,Observaciones,NumeroDeRegistro,FechaDeRegistro,Usuario)")
          .AppendFormat(" values({0},{1},{2},{3},{4});SELECT @@IDENTITY;", _
              New String() {ParseCadena(idEnvio), _
                            ParseCadena(observaciones), _
                            ParseCadena(numeroDeRegistro), _
                            ParseFecha(fechaDeRegistro), _
                            ParseCadena(usuario)})
          CM.CommandText = .ToString
        End With
        Return DataServer.ExecuteScalar(Of Integer)(CM)
      End Using
    End Function
#End Region

#Region " Modificación "
    ''' <summary>
    ''' Constructor de instancias de  proporcionando en <param ref="conexion" /> la conexión
    ''' </summary>
    ''' <param name="conexion"> Conexión que utilizará el objeto. </param>
    Public Function Update(ByVal id As Integer, _
                            ByVal idEnvio As String, _
                            ByVal observaciones As String, _
                            ByVal numeroDeRegistro As String, _
                            ByVal fechaDeRegistro As String, _
                            ByVal usuario As String) As Integer
      Using CM As IDbCommand = CreateCommand()
        With New System.Text.StringBuilder()
          .Append("Update [T_Envio] SET ")
          .AppendFormat("IdEnvio={1},Observaciones={2},NumeroDeRegistro={3},FechaDeRegistro={4},Usuario={5}" & _
                        " Where Id={0};", _
              New String() {id, _
                            ParseCadena(idEnvio), _
                            ParseCadena(observaciones), _
                            ParseCadena(numeroDeRegistro), _
                            ParseFecha(fechaDeRegistro), _
                            ParseCadena(usuario)})
          CM.CommandText = .ToString
        End With
        Return DataServer.ExecuteNonQuery(CM)
      End Using
    End Function
#End Region

   
  End Class
End Namespace

Dal.Core.ObjetoBase.vb

2008-12-16T13:48:00.001+01:00

Namespace Dal
  Public MustInherit Class ObjetoBase : Implements IDisposable
    Public ConnectionProvider As Dal.ConnectionProviderDelegate = Nothing
    Public TransactionProvider As Dal.TransactionProviderDelegate = Nothing

#Region " Constructores "
    Public Sub New()
    End Sub
    Public Sub New(ByVal conexion_ As IDbConnection)
      _ConexionActual = conexion_
    End Sub

    Public Sub New(ByVal connectionProvider As ConnectionProviderDelegate, ByVal transactionProvider As TransactionProviderDelegate)
      Me.ConnectionProvider = connectionProvider
      Me.TransactionProvider = transactionProvider
    End Sub
#End Region


    ' Destructor
    Protected Overrides Sub Finalize()
      Dispose(False)
    End Sub

    Public Sub Dispose() Implements System.IDisposable.Dispose
      Dispose(True)
      GC.SuppressFinalize(True)
    End Sub

    Protected Overridable Sub Dispose(ByVal disposing As Boolean)
      If ConnectionProvider IsNot Nothing Then Return
      If disposing = False Then _ConexionActual = Nothing : Return
      If _ConexionActual Is Nothing Then Return
      If ConnectionProvider Is Nothing Then
        _ConexionActual.Close()
        _ConexionActual.Dispose()
        _ConexionActual = Nothing
      End If
    End Sub


    Private _ConexionActual As IDbConnection = Nothing
    Protected ReadOnly Property ConexionEnUso() As IDbConnection
      Get
        ' Primero se intenta usar la conexion asignada al objeto
        If _ConexionActual IsNot Nothing Then Return _ConexionActual
        ' Luego se intenta usar el proveedor de conexion
        If Me.ConnectionProvider IsNot Nothing Then
          _ConexionActual = ConnectionProvider.Invoke()
          Return _ConexionActual
        End If
        ' Si la conexion compartida no existe se crea una nueva (normalmente para uso con WebForm)
        If DataServer.Connection Is Nothing Then
          _ConexionActual = DataServer.GetNewConection()
          Return _ConexionActual
        End If
        Return DataServer.Connection() ' Se devuelve la connexion compartida (Esta ser� la usada normalmente por WindowsForm)
      End Get
    End Property

    Private _Transaction As IDbTransaction = Nothing
    Protected ReadOnly Property TransaccionEnUso() As IDbTransaction
      Get
        ' Primero se intenta usar la _Transaction asignada al objeto
        If _Transaction IsNot Nothing Then Return _Transaction
        ' si hay un delegado lo llamamos
        If TransactionProvider IsNot Nothing Then
          _Transaction = TransactionProvider.Invoke()
          Return _Transaction
        End If
        ' Se devuelve la transaccion compartida
        Return DataServer.Transaction
      End Get
    End Property

    Protected Function CreateCommand() As System.Data.IDbCommand
      Dim cmd As IDbCommand = ConexionEnUso.CreateCommand()
      cmd.Connection = ConexionEnUso
      cmd.Transaction = TransaccionEnUso
      Return cmd
    End Function

  End Class

End Namespace

Dal.Core.DataServer.vb

2008-12-16T13:47:00.001+01:00

Namespace Dal

  Public Class DataServer
    Private Shared CADENA_DE_CONEXION As String = "server=serve;database=;uid=;pwd=;"
    ' variable conexion
    Shared _connection As Data.IDbConnection
    Shared _Trazas As BooleanSwitch = New BooleanSwitch("ConsultasDAL", "", "1")
    Public Shared DisableLog As Boolean = False

    ' Constructor privado
    Private Sub New()
      ' Evitar la creacion de objetos de esta clase
    End Sub

#Region " Propiedades "
    Public Shared ReadOnly Property ConnectionString() As String
      Get
        Return _connection.ConnectionString()
      End Get
    End Property

    Public Shared ReadOnly Property Connection() As Data.IDbConnection
      Get
        Return _connection
      End Get
    End Property
#End Region

#Region " Metodos "

    ' Abre la conexion con la base de datos
    Public Shared Sub Open(ByVal ConnectionString As String)
      Close()
      _connection = New SqlClient.SqlConnection(ConnectionString)
      _connection.Open()
    End Sub

    ' Cierra la conexion con la base de datos
    Public Shared Sub Close()
      If _connection IsNot Nothing Then
        _connection.Close()
        _connection.Dispose()
      End If
    End Sub

    Public Shared Sub SetWebConnection(ByVal value As String)
      CADENA_DE_CONEXION = value
    End Sub

    Public Shared Function OpenInternal2(ByVal servidor As String, ByVal baseDeDatos As String, ByVal usuario As String, ByVal password As String) As IDbConnection
      Dim tempConnection As Data.IDbConnection
      tempConnection = New SqlClient.SqlConnection(String.Format( _
                          "server={0};database={1};uid={2};pwd={3};Application Name=AppName.WindowsForms;", New String() { _
                          Helpers.ParseCadena(servidor), _
                          Helpers.ParseCadena(baseDeDatos), _
                          Helpers.ParseCadena(usuario), _
                          Helpers.ParseCadena(password)}))
      tempConnection.Open()

      With DirectCast(tempConnection, SqlClient.SqlConnection)
        Trace.WriteLineIf(_Trazas.Enabled, String.Format("DAL.CreateConnection  : {0} {1}", .GetHashCode, DateTime.Now.ToString("HH:mm:ss tt")))
        AddHandler .Disposed, AddressOf OnDisposeConnection
        AddHandler .StateChange, AddressOf OnStateChange
      End With
      Return tempConnection
    End Function


    Public Shared Function GetNewConection(ByVal servidor As String, ByVal baseDeDatos As String, ByVal usuario As String, ByVal password As String) As IDbConnection
      Return OpenInternal2(servidor, baseDeDatos, usuario, password)
    End Function

    Public Shared Function GetNewConection() As IDbConnection
      Dim c As SqlClient.SqlConnection = New SqlClient.SqlConnection(CADENA_DE_CONEXION)
      c.Open()
      AddHandler c.Disposed, AddressOf OnDisposeConnection
      Trace.WriteLineIf(_Trazas.Enabled, String.Format("DAL.CreateConnection  : {0} {1}", c.GetHashCode, DateTime.Now.ToString("HH:mm:ss tt")))
      Return c
    End Function

    Private Shared Sub OnDisposeConnection(ByVal sender As Object, ByVal e As EventArgs)
      Trace.WriteLineIf(_Trazas.Enabled, String.Format("DAL.DisposeConnection : {0} {1}", sender.GetHashCode, DateTime.Now.ToString("HH:mm:ss tt")))
    End Sub
    Private Shared Sub OnStateChange(ByVal sender As Object, ByVal e As StateChangeEventArgs)
      Trace.WriteLineIf(_Trazas.Enabled, String.Format("DAL.StateChage : {0} {1}", sender.GetHashCode, e.CurrentState))
    End Sub

#End Region

#Region " Transacciones "
    Shared _transaction As Data.IDbTransaction

    Public Shared ReadOnly Property InTransaction() As Boolean
      Get
        Return Transaction IsNot Nothing
      End Get
    End Property

    Public Shared ReadOnly Property Transaction() As Data.IDbTransaction
      Get
        Return _transaction
      End Get
    End Property

    Public Shared Function CreateOrUseTransaction() As Data.IDbTransaction
      If _transaction Is Nothing Then _transaction = CreateTransaction(_connection)
      Return _transaction
    End Function
    Public Shared Function CreateTransaction(ByVal c As IDbConnection) As Data.IDbTransaction
      Trace.WriteLineIf(_Trazas.Enabled, "Dal --> BeginTransaction")
      Return c.BeginTransaction
    End Function

    Public Shared Sub Rollback(ByVal t As IDbTransaction)
      If t Is Nothing Then
        Trace.WriteLineIf(_Trazas.Enabled, "Dal --> Rollback : No existe Transacción en curso")
      Else
        t.Rollback()
        t.Dispose()
        t = Nothing
        Trace.WriteLineIf(_Trazas.Enabled, "Dal --> Rollback")
      End If
    End Sub
    Public Shared Sub Rollback()
      Rollback(_transaction)
    End Sub

    Public Shared Sub Commit(ByVal t As IDbTransaction)
      If t Is Nothing Then
        Trace.WriteLineIf(_Trazas.Enabled, "Dal --> Commit: No existe Transacción en curso")
      Else
        t.Commit()
        t.Dispose()
        t = Nothing
        Trace.WriteLineIf(_Trazas.Enabled, "Dal --> Commit")
      End If
    End Sub

    Public Shared Sub Commit()
      Commit(_transaction)
    End Sub

    Public Shared Sub DisposeTransaction(ByVal t As IDbTransaction)
      If t IsNot Nothing Then
        t.Dispose()
        t = Nothing
      End If
    End Sub

    Public Shared Sub DisposeTransaction()
      DisposeTransaction(_transaction)
    End Sub

#End Region

    Public Shared Function ExecuteReader(ByVal cmd As IDbCommand) As IDataReader
      Return ExecuteCommand(Of IDataReader)(cmd, AddressOf _ExecuteReader)
    End Function
    Public Shared Function ExecuteNonQuery(ByVal cmd As IDbCommand) As Integer
      Return ExecuteCommand(Of Integer)(cmd, AddressOf _ExecuteNonQuery)
    End Function
    Public Shared Function ExecuteScalar(Of T)(ByVal cmd As IDbCommand) As T
      Return ExecuteCommand(Of T)(cmd, AddressOf _ExecuteScalar)
    End Function

    ' Para centralizar los mensajes de error de la Capa de Acceso a Datos
    ' de forma que se puedan: Escribir la sentencia SQL, escribir en un log, tratar el texto de error, etc
    Private Shared Function ExecuteCommand(Of T)(ByVal cmd As IDbCommand, ByVal handler As CommandHandler(Of T)) As T
      Try
        If _Trazas.Enabled And DisableLog = False Then
          Trace.WriteLine(IIf(cmd.Transaction IsNot Nothing, "Dal --> Transaction.", "DAL.") & "ExecuteCommand : " & cmd.CommandText)
        End If
        DisableLog = False
        Return handler(cmd)
      Catch e As Exception
        ' Trace the exception into the same log.
        Trace.WriteLine("--- Exception : " & e.Message)
        ' Aqui se podría inntentar controlar los mensajes de error de clave duplicada, etc...
        Throw New Exception("Data Access Layer Exception ", e)
      End Try
    End Function
    Private Shared Function _ExecuteReader(ByVal Cmd As IDbCommand) As IDataReader
      Return Cmd.ExecuteReader()
    End Function
    Private Shared Function _ExecuteNonQuery(ByVal Cmd As IDbCommand) As Integer
      Dim Res As Integer = Cmd.ExecuteNonQuery()
      If _Trazas.Enabled Then
        Trace.WriteLine(IIf(Cmd.Transaction IsNot Nothing, "Dal --> Transaction ", "DAL ") & Res & " Filas")
      End If
      Return Res
    End Function
    Private Shared Function _ExecuteScalar(Of T)(ByVal Cmd As IDbCommand) As T
      Return Cmd.ExecuteScalar
    End Function

  End Class
End Namespace

Dal.Core.DataLoader.vb

2008-12-16T12:58:00.000+01:00

Imports System.Reflection

Namespace Dal

  Public Delegate Sub BeginLoadDelegate()
  Public Delegate Sub EndLoadDelegate(ByVal fields As Integer, ByVal objects As Integer)
  Public Delegate Function CommandHandler(Of T)(ByVal cmd As IDbCommand) As T
  Public Delegate Function ConnectionProviderDelegate() As IDbConnection
  Public Delegate Function TransactionProviderDelegate() As Data.IDbTransaction


  Public Class Loader
    ' Delegados para informar del comienzo y fin de la carga de los objetos
    Public Shared OnBeginLoad As BeginLoadDelegate = Nothing
    Public Shared OnEndLoad As EndLoadDelegate = Nothing

    Private Delegate Function FillObjectsDelegate(Of T)(ByVal dr As IDataReader, ByVal c As Dal.ConnectionProviderDelegate, ByVal t As Dal.TransactionProviderDelegate) As T
    Private Delegate Function FillObjectDelegate(Of T)(ByVal target As T, ByVal dr As IDataReader) As T

    Private Sub New()
      ' Constructor privado para evitar que se creen instancias de esta clase. 
    End Sub

#Region " Cargar un objeto "
    Public Shared Sub LoadObject(Of T As {Class, New, ILoader})(ByVal Target As T, ByVal dr As IDataReader, ByVal Loader_ As ObjectLoader)
      Try
        If OnBeginLoad IsNot Nothing Then OnBeginLoad()
        If dr.Read() Then PopulateObject(Target, dr, Loader_)
        If OnEndLoad IsNot Nothing Then OnEndLoad(Loader_.Campos.Count, 1)
      Catch
      Finally
        If dr.IsClosed = False Then dr.Close()
      End Try
    End Sub

    Public Shared Sub LoadObject(Of T As {Class, New, ILoader})(ByVal Target As T, ByVal dr As IDataReader)
      Try
        If OnBeginLoad IsNot Nothing Then OnBeginLoad()
        If dr.Read() Then PopulateObject(Target, dr)
        If OnEndLoad IsNot Nothing Then OnEndLoad(Target.GetObjectLoader.Campos.Count, 1)
      Catch
      Finally
        If dr.IsClosed = False Then dr.Close()
      End Try
    End Sub
#End Region

#Region " Creacion y carga de colecciones de objetos "
    Public Shared Function LoadObjects(Of T As {Class, New, ILoader})(ByVal Target As Generic.List(Of T), ByVal dr As IDataReader) As Generic.List(Of T)
      Return LoadObjects(Target, dr, New T().GetObjectLoader)
    End Function

    Public Shared s As Boolean = False
    Public Shared Function LoadObjects(Of T As {Class, New, ILoader})(ByVal Target As Generic.List(Of T), ByVal dr As IDataReader, ByVal Loader_ As ObjectLoader) As Generic.List(Of T)
      Try

        Dim iLoader As ILoader = DirectCast(Target, ILoader) '.GetObjectLoader

        ' Notificamos el inicio de la carga
        If OnBeginLoad IsNot Nothing Then OnBeginLoad()
        ' Se cachea el delegado creado dinamicamente
        If Loader_.FillObjectsDelegate Is Nothing Then Loader_.FillObjectsDelegate = MakeFillObjectsDelegate(Of T)(Loader_)
        Dim D As FillObjectsDelegate(Of T) = Loader_.FillObjectsDelegate
        Do Until dr.Read() = False
          Target.Add(D(dr, iLoader.ConnectionProvider, iLoader.transactionProvider))
        Loop
      Catch
      Finally
        If dr.IsClosed = False Then dr.Close()
      End Try
      ' Notificamos el fin de la carga
      If OnEndLoad IsNot Nothing Then OnEndLoad(Loader_.Campos.Count, Target.Count)
      Return Target
    End Function
#End Region


    Private Shared Function PopulateObject(Of T As {Class, New, ILoader})(ByVal Target As T, ByVal dr As IDataReader) As T
      Return PopulateObject(Target, dr, Target.GetObjectLoader)
    End Function

    Private Shared Function PopulateObject(Of T As {Class, New})(ByVal Target As T, ByVal dr As IDataReader, ByVal Cargador As ObjectLoader) As T
      Try
        If Cargador.FillObjectDelegate Is Nothing Then Cargador.FillObjectDelegate = MakeFillObjectDelegate(Of T)(Cargador)
        DirectCast(Cargador.FillObjectDelegate, FillObjectDelegate(Of T))(Target, dr)
      Catch ex As Exception
      Finally
        If dr.IsClosed = False Then dr.Close()
      End Try
      Return Target
    End Function


    Private Shared Function MakeFillObjectsDelegate(Of T)(ByVal loader As ObjectLoader) As FillObjectsDelegate(Of T)
      Dim Metodo As New Emit.DynamicMethod("", GetType(T), New Type() {GetType(IDataRecord), GetType(ConnectionProviderDelegate), GetType(TransactionProviderDelegate)}, GetType(T), True)

      With Metodo.GetILGenerator()
        ' Declarar Objeto de salida, Crearlo y Almacenarlo
        .DeclareLocal(GetType(T))
        .Emit(Emit.OpCodes.Newobj, GetType(T).GetConstructor(Type.EmptyTypes))
        .Emit(Emit.OpCodes.Stloc_0)

        For Each F As BindItem In loader.Campos
          Dim OmitirNullos As Emit.Label = .DefineLabel()
          ' Comprobar si el valor del campo es DbNull
          .Emit(Emit.OpCodes.Ldarg_0)               ' DataRecord
          .Emit(Emit.OpCodes.Ldc_I4, F.fieldInfo.Index)  ' Indice
          ' Llamada a la funcion 
          .Emit(Emit.OpCodes.Callvirt, GetType(IDataRecord).GetMethod("IsDBNull"))
          ' Saltar a la etiqueta si hay null
          .Emit(Emit.OpCodes.Brtrue, OmitirNullos)

          ' Recuperar el valor del campo
          .Emit(Emit.OpCodes.Ldloc_0)               ' Objeto Negocio
          .Emit(Emit.OpCodes.Ldarg_0)               ' DataRecord
          .Emit(Emit.OpCodes.Ldc_I4, F.fieldInfo.Index)  ' Indice
          .Emit(Emit.OpCodes.Callvirt, GetType(IDataRecord).GetMethod("get_Item", New Type() {GetType(Integer)}))
          Select Case True
            Case F.fieldInfo.DbType Is GetType(Integer)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Int32))
            Case F.fieldInfo.DbType Is GetType(Double)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Double))
            Case F.fieldInfo.DbType Is GetType(Decimal)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Decimal))
            Case F.fieldInfo.DbType Is GetType(Boolean)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Boolean))
            Case F.fieldInfo.DbType Is GetType(Date)
              .Emit(Emit.OpCodes.Callvirt, GetType(Object).GetMethod("ToString", Type.EmptyTypes))
          End Select

          .Emit(Emit.OpCodes.Stfld, GetType(T).GetField("_" + F.PropertyName, BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.IgnoreCase))
          '.Emit(Emit.OpCodes.Callvirt, GetType(T).GetProperty(F.PropertyName).GetSetMethod)
          .MarkLabel(OmitirNullos)

        Next
        .Emit(Emit.OpCodes.Ldloc_0)
        .Emit(Emit.OpCodes.Ldarg_1)
        .Emit(Emit.OpCodes.Callvirt, GetType(T).GetProperty("ConnectionProvider", BindingFlags.Public Or BindingFlags.Instance Or BindingFlags.IgnoreCase).GetSetMethod)
        '.Emit(Emit.OpCodes.Stfld, GetType(T).GetField("_ConnectionProvider", BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.IgnoreCase))

        .Emit(Emit.OpCodes.Ldloc_0)
        .Emit(Emit.OpCodes.Ldarg_2)
        .Emit(Emit.OpCodes.Callvirt, GetType(T).GetProperty("TransactionProvider", BindingFlags.Public Or BindingFlags.Instance Or BindingFlags.IgnoreCase).GetSetMethod)
        '.Emit(Emit.OpCodes.Stfld, GetType(T).GetField("_TransactionProvider", BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.IgnoreCase))

        ' Cargar el objeto y devolverlo
        .Emit(Emit.OpCodes.Ldloc_0)
        .Emit(Emit.OpCodes.Ret)
      End With
      Return Metodo.CreateDelegate(GetType(FillObjectsDelegate(Of T)))
    End Function

    Private Shared Function MakeFillObjectDelegate(Of T)(ByVal loader As ObjectLoader) As FillObjectDelegate(Of T)
      Dim Metodo As New Emit.DynamicMethod("", GetType(T), New Type() {GetType(T), GetType(IDataRecord)}, GetType(T), True)

      With Metodo.GetILGenerator()
        For Each F As BindItem In loader.Campos
          Dim OmitirNullos As Emit.Label = .DefineLabel()
          ' Comprobar si el valor del campo es DbNull
          .Emit(Emit.OpCodes.Ldarg_1)                    ' DataRecord
          .Emit(Emit.OpCodes.Ldc_I4, F.fieldInfo.Index)  ' Indice
          ' Llamada a la funcion 
          .Emit(Emit.OpCodes.Callvirt, GetType(IDataRecord).GetMethod("IsDBNull"))
          ' Saltar a la etiqueta si hay null
          .Emit(Emit.OpCodes.Brtrue, OmitirNullos)

          ' Recuperar el valor del campo
          .Emit(Emit.OpCodes.Ldarg_0)                    ' Objeto Negocio
          .Emit(Emit.OpCodes.Ldarg_1)                    ' DataRecord
          .Emit(Emit.OpCodes.Ldc_I4, F.fieldInfo.Index)  ' Indice
          .Emit(Emit.OpCodes.Callvirt, GetType(IDataRecord).GetMethod("get_Item", New Type() {GetType(Integer)}))
          Select Case True
            Case F.fieldInfo.DbType Is GetType(Integer)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Int32))
            Case F.fieldInfo.DbType Is GetType(Double)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Double))
            Case F.fieldInfo.DbType Is GetType(Decimal)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Decimal))
            Case F.fieldInfo.DbType Is GetType(Boolean)
              .Emit(Emit.OpCodes.Unbox_Any, GetType(Boolean))
            Case F.fieldInfo.DbType Is GetType(Date)
              .Emit(Emit.OpCodes.Callvirt, GetType(Object).GetMethod("ToString", Type.EmptyTypes))
          End Select

          .Emit(Emit.OpCodes.Stfld, GetType(T).GetField("_" + F.PropertyName, BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.IgnoreCase))
          '.Emit(Emit.OpCodes.Callvirt, GetType(T).GetProperty(F.PropertyName).GetSetMethod)
          .MarkLabel(OmitirNullos)

        Next
        ' Cargar el objeto y devolverlo
        .Emit(Emit.OpCodes.Ldarg_0)
        .Emit(Emit.OpCodes.Ret)
      End With
      Return Metodo.CreateDelegate(GetType(FillObjectDelegate(Of T)))
    End Function

  End Class

  Public Interface ILoader
    Function GetObjectLoader() As ObjectLoader
    Property ConnectionProvider() As Dal.ConnectionProviderDelegate
    Property transactionProvider() As Dal.TransactionProviderDelegate
  End Interface

  Public Class ObjectLoader
    Public FillObjectDelegate As [Delegate]
    Public FillObjectsDelegate As [Delegate]


    Public C As Dal.ConnectionProviderDelegate = Nothing
    Public T As Dal.TransactionProviderDelegate = Nothing

    Private _Items As Generic.List(Of BindItem)

    Public Sub New()
      _Items = New Generic.List(Of BindItem)
    End Sub
    Public Sub Add(ByVal value As BindItem)
      _Items.Add(value)
    End Sub

    Default Public ReadOnly Property Item(ByVal Index As Integer) As BindItem
      Get
        Return _Items(Index)
      End Get
    End Property

    Public Function Campos() As Generic.List(Of BindItem)
      Return _Items
    End Function

    Public Function this() As ObjectLoader
      Return Me
    End Function

  End Class

  Public Class BindItem
    Public PropertyName As String
    Public fieldInfo As DbFieldInfo
    Public Sub New(ByVal propertyName As String, ByVal fieldName As String, ByVal fieldIndex As Integer, ByVal fieldDbType As Type)
      Me.PropertyName = propertyName
      With fieldInfo
        .Name = fieldName
        .Index = fieldIndex
        .DbType = fieldDbType
      End With
    End Sub
  End Class

  Public Structure DbFieldInfo
    Public Name As String
    Public Index As Integer
    Public DbType As Type
  End Structure

End Namespace