Índice de la sección dedicada a .NET (en el Guille)

Aplicación para usar las clases generadas

Esta utilidad te muestra cómo usar las clases generadas automáticamente

Actualizado: 14/Jul/2004
Autor: Guillermo 'guille' Som

Volver al índice de Generar clases para acceder a una tabla

 
 

Para que puedas probar las clases que has generado con la utilidad de generar clases a partir de una tabla de una base de datos (que nombre más largo) la cual utiliza la librería que genera una clase a partir de una tabla de una base de datos (si me pagaran por cada palabra que escribo...), pongo a tu disposición una utilidad con la que puedes probar "cualquiera" de las clases generadas, con código tanto para Visual Basic como para C# (ya que en C# hay que usar las clases de una forma diferente... bueno, casi, en un momento te explico las "peculiaridades").

Como te decía... con esta utilidad podrás probar cualquiera de la clases que hayas generado con la utilidad de generar... (ya sabes), de esta forma podrás comprobar que es fácil de hacer incluso una aplicación "genérica" para acceder a los datos de una tabla.

Empecemos viéndola en acción con los datos de la tabla authors usando la clase generada.

 


Figura 1: La utilidad en tiempo de ejecución

 

Como puedes comprobar esta utilidad crea los textbox necesarios según el número de campos que tenga la tabla, ahora veremos el código necesario para crear esas cajas de textos.

El funcionamiento en sí de la aplicación es bastante simple.
Al iniciarse se carga la tabla a la que hace referencia la clase, aunque para no "sobrecargar" demasiado nuestro sufrido equipo, el máximo de registros que se muestra la primera vez serán 100, después podremos acceder al resto usando las cajas de texto que hay encima del botón Refrescar.
Aunque en realidad se obtienen todos los registros que haya en la tabla, la limitación la podemos hacer mediante la cadena SELECT, indicando lo que queremos obtener de la tabla.

Cuando pulsamos en Mostrar se llama al método compartido Tabla de la clase y se obtienen todos los datos desde la base de datos, por otro lado, cuando pulsamos en el botón Refrescar usamos los datos que ya tenemos en memoria, con lo cual la cosa irá más rápida.

Al pulsar en cualquier elemento del Listview éstos se muestran en las cajas de texto y se hace de la siguiente forma:

lviActual = ListView1.SelectedItems(0)
For i As Integer = 0 To lviActual.SubItems.Count - 1
    txtCampos(i).Text = lviActual.SubItems(i).Text
Next

txtCampos es un array con cada una de las cajas de texto que tiene el formulario (realmente las cajas de texto que están relacionadas con los datos de la tabla).

A continuación podemos modificar los datos y pulsar en el botón Actualizar para que dichos datos se actualicen, tanto en la base de datos (los datos se guardan de forma inmediata) como en el Listview.
También podemos eliminar esa fila, simplemente pulsando en el botón Borrar.
Y si lo que queremos es crear un nuevo registro, pues rellenamos los datos y pulsamos en el botón Nuevo.

 

Nota:
Las operaciones que realizan los métodos Actualizar, Crear y Borrar se hacen permanentes en la base de datos en el momento que son llamados, es decir, no se mantiene la información en la memoria, sino que se actualizan de inmediato.

 

Crear los controles relacionados con los campos (columnas) en tiempo de ejecución

Antes de entrar en detalles veamos el formulario en tiempo de diseño:

 


Figura 2: El formulario en tiempo de diseño

 

Como puedes observar tan solo hay una etiqueta y una caja de texto para usar con los campos de la tabla. El resto de controles se cargan en tiempo de ejecución, según el número de campos (columnas) que tenga la tabla.
Con Visual Basic clásico esta sería la forma de hacerlo, con la condición de que esos controles realmente fueran el elemento cero de un array de controles.
Pero en .NET no se pueden crear arrays de controles, al menos no de la forma que el IDE de VB6 lo hacía. Por suerte, por medio de código si que lo podemos hacer.

Veamos el código que yo he usado para hacerlo:
(En estos trozos de código estoy usando VB, pero en el código completo puedes ver cómo hacerlo también en C#)

Primero cargamos los datos de la tabla y llamamos al método que creará los controles: (este código estará en el evento Click del botón Mostrar)

dt = authors.Tabla(txtSelect.Text)
crearCampos(dt.Columns)

 

Private Sub crearCampos(ByVal cols As DataColumnCollection)
    Dim k As Integer
    Dim n As Integer = cols.Count
    '
    ' Quitar los controles anteriores de la colección del formulario
    If Not labelCampos Is Nothing Then
        For i As Integer = 1 To labelCampos.Length - 1
            Me.Controls.Remove(labelCampos(i))
        Next
    End If
    If Not txtCampos Is Nothing Then
        For i As Integer = 1 To txtCampos.Length - 1
            Me.Controls.Remove(txtCampos(i))
        Next
    End If
    '
    Me.AutoScroll = False
    '
    ReDim labelCampos(n - 1)
    ReDim txtCampos(n - 1)
    labelCampos(0) = LabelCampo_0
    txtCampo_0.Enabled = True
    txtCampos(0) = txtCampo_0
    k = txtCampos(0).TabIndex
    For i As Integer = 0 To n - 1
        Dim col As DataColumn = cols(i)
        If i > 0 Then
            labelCampos(i) = New Label
            txtCampos(i) = New TextBox
            k += 1
            labelCampos(i).TabIndex = k
            k += 1
            txtCampos(i).TabIndex = k
            '
            labelCampos(i).Name = "LabelCampo_" & i.ToString()
            txtCampos(i).Name = "txtCampo_" & i.ToString()
            labelCampos(i).Anchor = labelCampos(0).Anchor
            txtCampos(i).Anchor = txtCampos(0).Anchor
            labelCampos(i).Size = labelCampos(0).Size
            labelCampos(i).Location = labelCampos(i - 1).Location
            labelCampos(i).Top += 24
            txtCampos(i).Size = txtCampos(0).Size
            txtCampos(i).Location = txtCampos(i - 1).Location
            txtCampos(i).Top += 24
            labelCampos(i).Visible = True
            txtCampos(i).Visible = True
            Me.Controls.Add(labelCampos(i))
            Me.Controls.Add(txtCampos(i))
            txtCampos(i).Text = ""
        End If
        labelCampos(i).Text = col.ColumnName & ":"
    Next
    n = txtCampos(n - 1).Top + 24 + 36
    Me.MaximumSize = New Size(Screen.PrimaryScreen.WorkingArea.Width, n)
    Me.AutoScroll = True
End Sub

Debido a que el formulario tiene asignada la propiedad AutoScroll a True y las cajas de texto tienen asignado el valor Anchor para que se adapten al nuevo ancho, hay que desactivar esa propiedad con idea de que los controles mantengan el mismo aspecto, al final volvemos a activar la propiedad AutoScroll para que los controles se adapten al nuevo tamaño.

Finalmente asignamos el nuevo tamaño del formulario para que se puedan mostrar todos los controles que hemos añadido, pero como tiene activada la propiedad AutoScroll, si cambiamos el tamaño del formulario, se mostrarán las barras de desplazamiento para indicar que hay controles "ocultos", tal como se puede ver en la figura 1.

 

Nota:
Como te comentaba al principio, C# funciona de forma diferente que VB con los métodos estáticos de las clases. En el caso del método Mostrar usado para cargar los datos de la tabla en un objeto del tipo DataTable, en C# se debe usar de la forma mostrada anteriormente, es decir usar el nombre de la clase para poder acceder al método. En Visual Basic también, pero el VB permite que se utilicen de forma diferente.
En el código que he usado en la aplicación "real", lo que hago es crear una variable del mismo tipo que la clase y después uso esa variable para acceder a los distintos métodos, pero en C# esto no se puede hacer con lo métodos estáticos (compartidos), ya que en esos casos siempre hay que usar el nombre de la clase.
En el resto del código veremos cómo uso esa variable y también un método que me permite crear nuevos objetos, todo esto para no tener que hacer demasiados cambios en el código si decido usar una clase diferente (que apunte a otra tabla).

 

Usar los métodos de la clase (para actualizar, borrar y crear)

Ahora vamos a ver cómo usar los métodos que nos permiten crear nuevos registros, actualizarlos o borrarlos.

Para usar esta aplicación de la forma más genérica posible, he creado un método que me permite crear nuevas instancias de la clase que voy a usar. Ya que para realizar cualquiera de estas tres operaciones necesitamos crear nuevas instancias de la clase.
Además de este método también he definido una variable con la que acceder a la clase, no solo a los objetos creados en la memoria, sino también para acceder a los métodos compartidos, aunque, como he comentado en la nota anterior, en C# esto no es posible, así que si estás usando C# y quieres acceder a los métodos compartidos, tendrás que usar la clase en lugar de la variable, en VB se puede usar indistintamente la clase o la variable.

Veamos las declaraciones de la variable y el método para crear nuevos objetos:

'**************************************************************************
' Poner la clase a utilizar en la declaración de mClaseTabla
' y en la función nuevaClaseTabla
'**************************************************************************
Private mClaseTabla As authors
'
Private Function nuevaClaseTabla() As authors
    Return New authors
End Function
'**************************************************************************

La función nuevaClaseTabla lo que hace es crear una nueva instancia y la devuelve.

 

Ahora veamos el código usado para Actualizar los datos:

Private Sub btnActualizar_Click(sender As Object, e As EventArgs) Handles btnActualizar.Click
    ' actualizar los datos
    mClaseTabla = nuevaClaseTabla()
    '
    For i As Integer = 0 To txtCampos.Length - 1
        mClaseTabla(i) = txtCampos(i).Text
    Next
    Dim s As String = mClaseTabla.Actualizar()

    If s.StartsWith("ERROR") Then
        MessageBox.Show(s, "Error al actualizar")
    Else
        For i As Integer = 1 To txtCampos.Length - 1
            lviActual.SubItems(i).Text = txtCampos(i).Text
        Next
    End If
End Sub

Lo que hacemos es crear un nuevo objeto de la clase.
Le asignamos el contenido de las cajas de texto, la asignación:
mClaseTabla(i) = txtCampos(i).Text
Lo que hace es llamar a la propiedad predeterminada (Item en VB) y asignar el valor al campo correspondiente.

Después llamamos al método Actualizar, el cual devolverá una cadena que empezará por la palabra ERROR si es que hubo algún "fallo" al actualizar, el resto de la cadena contiene el error producido.

En caso de que no se produzca ningún error, actualizamos el contenido del Listview.

 

El código usado en los otros dos métodos es parecido, salvo porque se llaman a métodos diferentes:
Crear() cuando pulsamos en el botón Nuevo o Borrar() al pulsar en el botón del mismo nombre.

 

Y eso es todo lo que hay que hacer... como ves nada complicado, si bien esta aplicación tampoco es muy complicada, aunque el uso de estas clases, casi seguro que nos facilitarán el acceso a las tablas de las bases de datos.

 

Ya sólo me queda mostrarte el código completo de la utilidad, tanto para Visual Basic como para C# así como el link para que puedas bajarte el código fuente.

El código lo he puesto en otra página separada y con estos links puedes acceder:

 

Bueno, pues eso es todo... espero que te parezca interesante todo esto y que puedas sacarle alguna utilidad. Esa al menos ha sido mi intención.

Nos vemos.
Guillermo

Nota del 07/Mar/08:
El código fuente de esta utilidad, (y la DLL que genera el código), con algunas modificaciones y adaptado a Visual Basic 2005, lo puedes bajar desde Codeplex, para más información, lee esto que publiqué el 4 de Mayo de 2007.

 

la Luna del Guille o... el Guille que está en la Luna... tanto monta...