El corazón de la clase son dos métodos privados que son los que rellenan el ListControl (ya sea un ListBox o un ComboBox). Ambos reciben como parámetros el control que se va a rellenar, el nombre de la tabla origen, los dos campos con los que vamos a rellenar el control (indentificados por su índice en la colección de columnas de la tabla, o su posición, para entendernos), una sentencia WHERE para ajustar la consulta y una sentencia de ordenación, ambas sin las palabras reservadas WHERE y ORDER BY. El método para OleDB es el siguiente:

Private Function RellenarComboOleDB( _
        ByVal MiControl As System.Windows.Forms.ListControl, _
        ByVal Tabla As String, ByVal ClavePrincipal As Integer, _
        ByVal CampoDescriptor As Integer, _
        ByVal SentenciaWhere As String, _
        ByVal SentenciaOrderBy As String) As Boolean
    Dim drDatos As OleDb.OleDbDataReader
    Dim Comando As New OleDb.OleDbCommand("SELECT * FROM " & Tabla, _
                                    Me._cnOleDb)
    Dim tbTabla As New DataTable
    Dim deVuelta As Boolean
    Try
        If SentenciaWhere.Length > 0 Then
            Comando.CommandText = "SELECT * FROM " & Tabla _
                    & " WHERE " & SentenciaWhere
        End If
        If SentenciaOrderBy.Length > 0 Then
            Comando.CommandText = Comando.CommandText & _
                    " ORDER BY " & SentenciaOrderBy
        End If
        drDatos = Comando.ExecuteReader()
        tbTabla.Load(drDatos, LoadOption.OverwriteChanges)
        MiControl.DataSource = tbTabla
        MiControl.DisplayMember = _
            tbTabla.Columns.Item(CampoDescriptor).Caption
        MiControl.ValueMember = _
            tbTabla.Columns.Item(ClavePrincipal).Caption
        drDatos.Close()
        deVuelta = True
    Catch NoConexion As InvalidOperationException
        'Error del Comado.ExecuteReader
        deVuelta = False
        Throw NoConexion
    Catch NoConexion As Exception
        deVuelta = False
        Throw NoConexion
    Finally
        Comando = Nothing
        tbTabla = Nothing
    End Try
    Return deVuelta
End Function

Para SQL es similar, pues sólo cambian el nombre (RellenarComboSQL), el tipo de objeto DataReader, el Command y la conexión utilizada, es decir, en vez de:

Dim drDatos As OleDb.OleDbDataReader
Dim Comando As New OleDb.OleDbCommand("SELECT * FROM " & Tabla, _
        Me._cnOleDb)

Tendríamos:

Dim drDatos As SqlClient.SqlDataReader
Dim Comando As New SqlClient.SqlCommand("SELECT * FROM " & Tabla, _
        Me._cnSQL)

Como métodos públicos tenemos dos variantes, donde jugamos con la sobrecarga de operadores. El primero, que se muestra a continuación, es el principal. En él asumimos que la conexión ya está abierta, bien porque hemos llamado previamente al método Conectar, bien porque le hemos pasado un objeto conexión a través de la propiedad ConexionOleDB o ConexionSQL. Como puede verse, los parámetros que recibe son los mismos que reciben los métodos privados vistos antes, con la salvedad de que, salvo el control y el nombre de la tabla, los demás son opcionales. En lo que a mí respecta, la situación más habitual para la que estoy usando esta clase es para rellenar combos con tablas que no tienen más de 10-15 registros y tres campos: por orden, IdTabla, Nombre y Descripción, siendo los dos primeros los campos a mostrar en el combo. De ahí los valores por defecto de los parámetros opcionales.

Lo que hace el método es identificar con qué base de datos estamos tratando y llamar al método privado correspondiente, pasándole por parámetro lo que a él le ha llegado.

''' <summary>
''' Rellena un ListControl con un campo descriptor 
''' y la clave principal de una tabla
''' para usarlo como clave externa en otra tabla.
''' </summary>
''' <param name="MiControl">ListControl (Combo, ListBox)
''' que se va a rellenar</param>
''' <param name="Tabla">Nombre de la tabla a rellenar</param>
''' <param name="ClavePrincipal">Número del campo Clave Principal
''' en la tabla (por defecto, 0)</param>
''' <param name="CampoDescriptor">Número del campo descriptor
''' usado como DisplayMember del Combo (por defecto, el 1)</param>
''' <param name="SentenciaWhere">Sentencia WHERE de la selección
''' SQL (sin el WHERE). Puede incluir más opciones, como ORDER BY.
''' No se realiza ninguna comprobación sobre la sentencia</param>
''' <param name="OrdenarPor">Sentencia ORDER BY, si la hay.</param>
''' <returns>True operación completada, False si se ha producido
''' un error</returns>
''' <remarks>Hay que haber pasado previamente la cadena de
''' conexión a la propiedad CadConexion y abrir la conexión
''' con el método Conectar antes de llamar a este método
''' y llamar a Desconectar al finalizar.</remarks>
Public Function RellenarCombo(ByVal MiControl As _
        System.Windows.Forms.ListControl, _
        ByVal Tabla As String, _
        Optional ByVal ClavePrincipal As Integer = 0, _
        Optional ByVal CampoDescriptor As Integer = 1, _
        Optional ByVal SentenciaWhere As String = "", _
        Optional ByVal OrdenarPor As String = "") As Boolean
    Dim deVuelta As Boolean
    'Según el tipo de base de datos al que estemos conectados, 
    'llama a una u otra función que rellenarán el combo.
    Try
        Select Case _BDD
            Case QueBase.Access
                deVuelta = Me.RellenarComboOleDB(MiControl, _
                    Tabla, ClavePrincipal, CampoDescriptor, _
                    SentenciaWhere, OrdenarPor)
            Case QueBase.SQL
                deVuelta = Me.RellenarComboSQL(MiControl, _
                    Tabla, ClavePrincipal, CampoDescriptor, _
                    SentenciaWhere, OrdenarPor)
            Case Else
                deVuelta = False
                Throw New ApplicationException( _
                    "Tipo de base de datos desconocido o no establecido")
        End Select
    Catch NoConexion As Exception
        Throw NoConexion
        deVuelta = False
    End Try
    Return deVuelta
End Function

La otra variante de RellenarCombo no necesita tener una conexión abierta, sino que se preocupa él mismo de abrirla y cerrarla. Para ello, tiene un parámetro adicional que es la cadena de conexión. Así, si sólo vamos a llenar un ListControl, podemos usar este método y condensarlo todo en una única llamada, mientras que usaremos el anterior si vamos a aprovechar la conexión abierta para más cosas (llenar varios combos y listboxes, llenar algún dataset…).

Public Function RellenarCombo(ByVal MiControl As _
        System.Windows.Forms.ListControl, _
        ByVal Tabla As String, _
        ByVal CadenaConexion As String, _
        Optional ByVal ClavePrincipal As Integer = 0, _
        Optional ByVal CampoDescriptor As Integer = 1, _
        Optional ByVal SentenciaWhere As String = "", _
        Optional ByVal OrdenarPor As String = "") As Boolean
    Dim DeVuelta As Boolean
    Try
        Me.CadConexion = CadenaConexion
        DeVuelta = Me.Conectar
        If DeVuelta Then
            DeVuelta = Me.RellenarCombo(MiControl, _
                Tabla, ClavePrincipal, CampoDescriptor, _
                SentenciaWhere, OrdenarPor)
        End If
    Catch NoConexion As Exception
        DeVuelta = False
        Throw NoConexion
    Finally
        Me.Desconectar()
    End Try
    Return DeVuelta
End Function

Y eso es todo. No es ninguna maravilla, pero me es útil. Si a alguien le sirve, pues mejor.

*Ejem* Bueno, no es todo. RellenarCombo presenta 4 sobrecargas (variantes) y aquí sólo he puesto dos de ellas. Las otras dos son iguales, pero cambiando el ListControl por un DataGridViewComboBoxColumn, o sea, la variante del ComboBox para DataGridView. Cambiando ese pequeño detalle, son exactamente iguales y, por supuesto, llevan sus métodos privados correspondientes (RellenarComboDataGridOleDB y RellenarComboDataGridSQL, de momento). Y, ahora, sí, eso es to… to… todo, amigos.

Continuando con el aprendizaje, esta clase no sólo fue mi primera clase y supuso mi primer constructor, sino que también fue la primera vez que me pegué con las propiedades. Prácticamente se puede decir que LlenarComboBox me desvirgó en VB2005. La clase terminó con tres propiedades públicas: la cadena de conexión, el objeto conexión OleDB y el objeto conexión SQL. Inicialemente estos dos últimos eran uno solo (sólo OleDB) y de sólo lectura, pero luego empecé a cogerle cariño a los bloque Using y modifiqué el código. Y no hay mucho más que decir, las propiedades son éstas:

''' <summary>
''' Cadena de conexión que va a usarse luego para conectarse
''' a la base de datos
''' </summary>
Public WriteOnly Property CadConexion() As String
    Set(ByVal value As String)
        Me._Conexion = value
        'Identificamos el tipo de conexión.
        Me._BDD = QueBase.NoSel
        For i As Integer = 0 To Me._TipoConexion.Length - 1
            If Me._Conexion.IndexOf(Me._TipoConexion(i).Presenta) _
                                     <> -1 Then
                Me._BDD = Me._TipoConexion(i).Tipo
                Exit For
            End If
        Next
    End Set
End Property

''' <summary>
''' Establece o devuelve el objeto OLEDBConnection
'''  que usa LlenarCombobox
''' </summary>
Public Property ConexionOLEDB() As OleDb.OleDbConnection
    Get
        Return Me._cnOleDb
    End Get
    Set(ByVal value As OleDb.OleDbConnection)
        If value IsNot Nothing Then
            Me._cnOleDb = value
            Me.CadConexion = value.ConnectionString
        End If
    End Set
End Property

''' <summary>
''' Establece o devuelve el objeto SQLConnection
''' que usa LlenarCombobox
''' </summary>
Public Property ConexionSQL() As SqlClient.SqlConnection
    Get
        Return Me._cnSQL
    End Get
    Set(ByVal value As SqlClient.SqlConnection)
        If value IsNot Nothing Then
            Me._cnSQL = value
            Me.CadConexion = value.ConnectionString
        End If
    End Set
End Property

Sigo con la duda de si añadir en el Set una comprobación del tipo

If Me._cnOleDb Is Nothing Then
    Me._cnOleDb = New OleDb.OleDbConnection
End If

que es lo que me pide el cuerpo, pero sin esas tres líneas también funciona, aunque no sé el porqué. En fin, todavía no soy más que un aficionadillo.

Los métodos de conexión están divididos en dos grupos: los métodos públicos y los métodos privados. El método público Conectar identifica el tipo de conexión que estamos manejando y llama al método privado correspondiente. Vale, para las pocas líneas de código que son podría haber usado un único método, pero así me resulta más cómodo. Todos los métodos son funciones y devuelven un valor booleano con el resultado de la operación. Esto también es una manía personal, y bastante estúpida porque luego rara vez uso el valor de vuelta. De todas formas, ha habido veces (dos) que me ha venido bien. Por otra parte, en caso de error el método devuelve una excepción al método de llamada. En esta clase todos los errores se mandan de vuelta, para que se gestione desde el programa principal. No me complico mucho la vida, no.

''' <summary>
''' Conecta a la base de datos indicada
''' por la cadena de conexión pasada previamente
''' </summary>
''' <returns>True si la conexión se realiza,
''' false si se produce un error</returns>
''' <remarks>Hay que haber pasado la cadena de conexión previamente
''' a la propiedad CadConexion, de lo contrario devuelve false.
''' Si se produce una excepción, la devuelve para su gestión</remarks>
Public Function Conectar() As Boolean
    Dim Result As Boolean
    Try
        Select Case _BDD
            Case QueBase.NoSel
                'Mensaje de error
            Case QueBase.Access
                Result = Me.ConectarOleDB
            Case QueBase.SQL
                Result = Me.ConectarSQL
            Case Else
                Result = False
        End Select
    Catch NoConexion As Exception
        Throw NoConexion
    End Try
    Return Result
End Function

Private Function ConectarOleDB() As Boolean
    Dim Result As Boolean
    If Me._cnOleDb Is Nothing Then
        Me._cnOleDb = New OleDb.OleDbConnection
    End If
    With Me
        Try
            ._cnOleDb.ConnectionString = ._Conexion
            ._cnOleDb.Open()
            Result = True
        Catch ex As OleDb.OleDbException
            ._cnOleDb.Close()
            Result = False
            Throw ex
        End Try
    End With
    Return Result
End Function

Private Function ConectarSQL() As Boolean
    Dim Result As Boolean
    If Me._cnSQL Is Nothing Then
        Me._cnSQL = New SqlClient.SqlConnection
    End If
    With Me
        Try
            ._cnSQL.ConnectionString = ._Conexion
            ._cnSQL.Open()
            Result = True
        Catch ex As SqlClient.SqlException
            ._cnSQL.Close()
            Result = False
            Throw ex
        End Try
    End With
    Return Result
End Function

Public Sub Desconectar()
    Select Case _BDD
        Case QueBase.Access
            Me._cnOleDb.Close()
            Me._cnOleDb = Nothing
        Case QueBase.SQL
            Me._cnSQL.Close()
            Me._cnSQL = Nothing
    End Select
End Sub

Como se puede ver, en el método público Conectar falta gestionar el caso de que se intente conectar sin haber definido primeramente el tipo de base de datos, o sea, cuando falta la cadena de conexión. Olvidadizo que es uno. Pero, vamos, que ahí se generará una nueva excepción (tipo aún por decidir) con un mensaje que informe de lo inútil que es el progrador que se olvidó de poner los pilares antes de levantar los tabiques y a otra cosa.

Y eso es todo por hoy. Como se puede ver, un poquito de código sencillito y es que mis neuronas no dan para mucho más. La próxima entrega, los métodos privados y públicos para llenar un ListControl (o sea, tanto un ListBox como un ComboBox). He de reconocer que con ellos puse en práctica por primera vez lo de la “sobrecarga de operadores” y, confieso, me emocioné un poco. Hasta entonces, nos vemos en el Gentleman Loser

Pero, primero, lo prometido es deuda: ejercicio de egocentrismo concentrado y autopropaganda. O sea, my first class: LlenarComboBox. La idea, pequeño recordatorio, era rellenar unos combos o listboxes con la clave primaria y un campo descriptor de su tabla correspondiente y luego enlazar el combo (o listbox) al dataset tipado con el que vamos a trabajar mediante un bindingsource. De este modo, en el método de carga de datos del formulario tendría algo como esto:

• Abrir conexión con la BDD.
• Llenar los combos.
• Llenar el dataset tipado con su tableadapter correspondiente, aprovechando la conexión abierta antes.
• Cerrar la conexión.
• Ligar el dataset con el bindingsoure y el selectedvalue del combo con el campo correspondiente.

Vale, no es ninguna maravilla de idea y habrá a quien le produzca sarpullidos la idea de usar un dataset tipado, pero es de las primeras cosas que hice en VB2005, cuando intentaba comprender cómo funciona su acceso a datos, que cuando vienes de VB6 y ADO es un infienno y lo que deseas es tirar el dataset a la basura y usar un recordset.

Viendo lo que quería que hicera la clase, lo que necesitaba era un método Conectar que me abriera la conexión, un método Desconectar que la cerrara, una propiedad para pasarle la cadena de conexión y un método que llenara el combo pasándole como parámetros el combo y el nombre de la tabla que contenía los datos. Simple y sencillo.

Luego me emocioné y ya no fue tan simple y sencillo, pero bueno… Por ejemplo, originalmente la única conexión que hacía era a una base de datos Access, pero la primavera pasada me hizo falta en el trabajo que se conectara a una base de datos SQL Server, así que modifiqué toda la clase para permitir conexiones tanto a través de OleDB como de SQL y, a la vez, dejar abierta la posibilidad de nuevas conexiones. Para distinguir las conexiones no me compliqué mucho la vida: he definido una estructura que tiene dos campos, el identificador de la base de datos (uso una enumeración porque soy muy perro) y una string con un texto identificativo de la cadena de conexión del tipo de conexión dado. En el constructor de la clase relleno un array de esta estructura con los casos posibles. La idea es bastante tonta: cuando le pase la cadena de conexión a la clase, miro. Si presente “Jet.OLEDB” es que voy a conectarme a una base de datos ACCESS, y así.

El resto de las variables privadas, como puede verse, son los objetos conexión necesarios, una string que contendrá la cadena de conexión y una variable del tipo enumeración antes definida que indicará el tipo de base de datos que corresponde a la cadena de conexión almacenada. En resumen, el código siguiente:

Imports System.Data
Imports System.Windows.Forms
Imports System.Xml

Public Class LlenarComboBox

#Region " Declaraciones "

    'Declaración de enumeraciones y estructuras previas
    Private Enum QueBase As Integer
        NoSel = -1
        Access
        SQL
    End Enum
    Private Structure TipoBDD
        Public Tipo As QueBase
        Public Presenta As String 'texto reconocible de la cadena 
        'de conexión que nos permita identificar el tipo de BDD
    End Structure
    'Declaración de variables
    Private _cnOleDb As OleDb.OleDbConnection
    Private _cnSQL As SqlClient.SqlConnection
    Private _Conexion As String 'La cadena de conexión
    Private _BDD As QueBase = QueBase.NoSel
    Private _TipoConexion() As TipoBDD
#End Region
'Relleno del array Tipo de Conexion al
'inicializar una instancia de la clase
    Public Sub New()
        ReDim _TipoConexion(2)
        _TipoConexion(0).Tipo = QueBase.Access
        _TipoConexion(0).Presenta = "Jet.OLEDB"
        _TipoConexion(1).Tipo = QueBase.SQL
        _TipoConexion(1).Presenta = "Initial Catalog" 'Server puro
        _TipoConexion(2).Tipo = QueBase.SQL
        _TipoConexion(2).Presenta = "AttachDbFilename" 'Archivo bdd
    End Sub

Y por hoy me temo que lo dejo, que es tarde. Mañana, las propiedades públicas y los métodos de conexión y desconexión. Hasta entonces, nos vemos en el Gentleman Loser.

Una posibilidad sería usar una combinación de DataSet y BindingSource, estableciendo como DataSource del ListControl el BindingSource y seleccionando los campos a mostrar como DisplayMember y ValueMember. Este método lo he usado bastante, la verdad, pero como herramienta de navagación entre registros en la tabla principal que se muestra en el formulario. Me explico:

En rojo aparece señalado un ListBox usado como herramienta de navegación por registros. Lo que busco realmente es el señalado en azul, que presenta una lista de estudios que han producido esas series. El combo muestra el campo Nombre de la tabla Estudio pero también almacena la clave principal, IdEstudio, que es clave externa en la tabla de Series. Lo mismo es aplicable para el combo Valoración (justo encima) y otros. Otro ejemplo quizás más práctico sería un combo con el listado de comerciales en la pantalla de generar nuevo pedido de una aplicación de gestión. Es importante saber qué comercial ha hecho el pedido (sobre todo si van a comisión) y, si son pocos, nos ahorramos el tener que diseñar un formulario de búsqueda o que el comercial tenga que aprenderse su código.

Pero me estoy desviando. Quiero mostrar una tabla (la clave primaria y un campo descriptor) en un ListControl. No voy a trabajar con esa tabla directamente (altas, bajas, modificaciones), así que no necesito tener un dataset zumbando por ahí, así que voy a usar un datareader. La "cosa" quedaría más o menos así:

Dim drDatos As OleDb.OleDbDataReader
Dim cnOleDb As New OleDb.OleDbConnection(MiConexion)
Dim Comando As New OleDb.OleDbCommand("SELECT * FROM " & Tabla, cnOleDb)
Dim tbTabla As New DataTable
cnOleDb.Open()
drDatos = Comando.ExecuteReader()
tbTabla.Load(drDatos, LoadOption.OverwriteChanges)
MiControl.DataSource = tbTabla
MiControl.DisplayMember = tbTabla.Columns.Item(1).Caption
MiControl.ValueMember = tbTabla.Columns.Item(0).Caption
drDatos.Close()
cnOleDb.Close()

Donde Tabla es el nombre de la tabla en cuestión, MiConexion es la cadena de conexión empleada y se asume que el campo 0 de la tabla es la clave primaria (ValueMember) y el campo 1 es el campo descriptor que vamos a mostrar y MiControl es el ListControl (da igual que sea un ListBox o un ComboBox) que vamos a rellenar. El código del ejemplo es un poco "de andar por casa". Lo suyo sería que el objeto conexión estuviera en un bloque Using y falta la gestión de errores, pero sirve como base.

Como este procedimiento, es decir, llenar un ComboBox o ListBox con datos de una tabla a partir de un DataReader, lo utilizo bastante, me sirvió para hacerme mi primera clase en Visual Basic 2005 (y comprender cómo funcionan), así como para probar el tema de las sobrecargas. Es mi idea comentar esa primera clase en próximas entradas, por puro y sencillo egocentrismo (tampoco es que me vaya a leer nadie, claro).

Nos vemos en el Forlon.

En todo caso, el asunto era simple: no podía entrar como Supervisor y el Supervisor es el único usuario que puede hacer ciertas tareas de mantenimiento, como, por ejemplo, no sé, ¿quitar una contraseña olvidada? Para solucionar este pequeño contratiempo necesitaba pensar rápido y conocer a fondo las herramientas internas del programa (que las tiene muy buenas). En la parte primera, el contratiempo se produjo poco antes del fin de la jornada matutina, así que tuve dos horitas para pensar tranquilamente la solución. Realmente, tampoco es que el problema fuera tan complicado, pero todo pasaba por saber dónde guardaba el programa la contraseña de los usuarios y cómo eliminarla (o leerla, si estaba en claro). Por lo pronto, esta información debe ser común a todo el programa. Un rápido vistazo al árbol de directorios del programa me llevó a la carpeta “comunes” y ahí encontrar el archivo “usuarios”. Concretamente, tres archivos, con extensión .cdx, .dbf y .fpt. Ya tenía la tabla usuarios localizada, sólo quedaba abrirla.

Ups, mira que llevo tiempo diciéndome que debo aprender a usar las herramientas de gestión de base de datos que incluye la aplicación. Las he visto usar cuando nos han dado asistencia remota con un problema recurrente que tenemos y son muy completas. El caso es que no sé cómo funcionan y tampoco tenía tiempo en ese momento de ponerme a averiguarlo. Necesitaba abrir esa base de datos de Visual FoxPro con una herramienta conocida por mí, y ya está, así que recurrí a Visual Basic 2005, con idea de generar una aplicación simple con un dataset tipado, rezando para que Visual Estudio fuera capaz de abrir una base de Visual FoxPro como origen de datos.

Dicho y hecho: elegí como origen de datos OBDC y en Especificación del origen de datos marqué Usar cadena de conexión y pulsé en Generar. Buceando por la pestaña Origen de datos de equipo encontré directamente el origen de datos COMUN001 que quería. Así da gusto. En la cadena de conexión, de todos modos, cambié la ruta por una copia de la base de datos que me llevé al disco duro local. El resto de los pasos para generar el dataset tipado fueron los normales. Efectivamente, en la base de datos comunes había una tabla usuarios con un campo llamado clave. Metí en el formulario una rejilla vinculada al dataset por el procedimiento del tirón (o sea, arrastra y suelta) y listo.

Bueno, casi. Al ejecutar la miniaplicación efectivamente accedí a la tabla de usuarios y vi las claves, pero se presentaron dos problemas. El primero es que las claves no estaban en claro. Éste fue el de menos, ya que uno de los usuarios tiene la clave en blanco, así que tenía que coger los caracteres de la clave de este usuario y ponérselos al superusuario para tener la clave de éste en blanco. Aquí llegó el segundo problema: Visual Basic no fue capaz de generar la sentencia UPDATE al crear el dataset tipado.

Pues nada, que tocó escribir código. 3 minutos más de trabajo, total de 15 (incluyendo el repaso rápido del UPDATE, que siempre se me olvida cómo va). Agregué un botón al formulario con lo siguiente:

Private Sub Button1_Click(ByVal sender As System.Object, _
            ByVal e As System.EventArgs) Handles Button1.Click
    Dim ocConexion As New Odbc.OdbcConnection( _
                My.Settings.ConnectionString)
    Dim coComando As New Odbc.OdbcCommand
    Dim Usuario As String
    Dim Clave As String
    Dim msg As Microsoft.VisualBasic.MsgBoxResult
    msg = MsgBox(My.Settings.ConnectionString, MsgBoxStyle.OkCancel)
    If msg = MsgBoxResult.Cancel Then Exit Sub
    Usuario = InputBox("Usuario")
    Clave = InputBox("clave")
    coComando.CommandText = "UPDATE usuarios SET clave='" _
            & Clave & "' WHERE nombre='" & Usuario & "'"
    ocConexion.Open()
    coComando.Connection = ocConexion
    coComando.ExecuteNonQuery()
    ocConexion.Close()
    MsgBox("Ok")
End Sub

Por último, cogí la tabla de usuarios así modificada (los tres archivos), se la encasqueté a la base de datos buena del servidor, inicié la aplicación y listo, todo funcionando bien otra vez (durante media tarde, hasta que dio el siguiente error en la actualización, un error al acceder a una tabla en la que se había introducido un valor basura al ejecutar la primera parte de la actualización). Moraleja: no hay nada como un poco de pensamiento lateral y, sobre todo, si no tienes o no sabes manejar la herramienta adecuada, ten una que pueda hacer el trabajo y que sí sepas manejar.

Saludos desde el Forlon. Sed buenos y que os traigan muchas cosas los Reyes (por ejemplo, una canuta nuclear táctica). Yo quiero una furgoneta nueva, a ver si me dura más que las otras.

Tengo un pequeño picturebox en un formulario donde se muestra la imagen asociada al registro en el que estemos (me da igual si hablamos de series, actores, muebles o coches).
Hay algunas imágenes que son bastante grandes y muy bonitas y verlas en un picturebox de 100×63 es una pena,así que decidí añadir un formulario con un picturebox que me mostrara la imagen a tamañocompleto. Básicamente, cogí un formulario (frmMostrarImagen) y le quite el texto del título y los bordes (FormBorderStyle=None). Le añadí un picturebox que debía ocupar todo el formulario (Dock=Fill). Este picturebox (picImagen) debe ajustarse al tamaño de la imagen (AutoSize=True). De igual modo, el formulario debe ajustarse al tamaño del picturebox, asíque su AutoSize también está en True y AutoSizeMode debe estar en GrowAndShrink.

Con esto ya sólo quedó añadir elcódigo necesario para que, pasándole la imagen a mostrar, la ponga en el picturebox y muestre el formulario.

Peeeeero… No queda bien. Si se le pasa una imagen con mayor resolución que la pantalla, sólo se ve una parte de la imagen. Mal íbamos. Por fortuna en My.Computer encontramos Screen y, dentro de Screen, WorkingArea. Sabiendo las dimensiones del área de trabajo de la pantalla estrivial comprobar si la imagen es más alta o ancha que el área de trabajo. En este caso pasaremos del AutoSize y ajustaremos el tamaño del picturebox al máximo que nos permita la resolución de pantalla, manteniendolas proporciones de la imagen.

En resumen, esto:

 
''' <summary>
''' Carga la imagen a mostrar y muestra el formulario de modo modal
''' </summary>
Public Sub MostrarImagen(ByRef queImagen As Image)
    'Comprobamos si el tamaño de la imagen (alto o ancho) es mayor
    'al área de trabajo de la pantalla. Si es así, ajustamos la imagen
    'al área de trabajo manteniendo las proporciones.
    If queImagen.Height > My.Computer.Screen.WorkingArea.Height _
    	OrElse queImagen.Width > My.Computer.Screen.WorkingArea.Width Then
        'Lo primero es poner el autosize del formulario a false
        'Si no lo hacemos y quitamos el autosize del picbox, no se muestra nada
        '(el formulario queda con tamaño 0)
        Me.AutoSize = False
        Me.picImagen.SizeMode = PictureBoxSizeMode.Zoom
        'Vemos que dimensión (ancho, alto) es mayor, pues será sobre la que ajustemos
        If queImagen.Size.Width > queImagen.Size.Height Then
        	Me.Width = My.Computer.Screen.WorkingArea.Width
            Me.Height = Me.Width * queImagen.Height / queImagen.Width
        Else
            Me.Height = My.Computer.Screen.WorkingArea.Height
            Me.Width = Me.Height * queImagen.Width / queImagen.Height
        End If
    End If
    Me.picImagen.Image = queImagen
    Me.ShowDialog()
 End Sub

Sólo queda hacer que el formulario se cierre (no hay barra de título, no hay como cerrarlo en principio). Cada cual tendrá sus formas, yo lo hice al hacer click sobre el picturebox y al pulsar cualquier tecla. Esto último en el evento KeyPress del formulario, previo hacer que el formulario capture las pulsaciones de las teclas antes que el picturebox (KeyPreview=True). De paso añadí un tooltip que mostrase un mensajito del tipo “Pulse la tecla any para cerrar esta ventana” y listo.

Fin de la primera entrada, nos vemos en el Forlon.

Actualización 08 de enero de 2008: he corregido la línea Me.Height = Me.Width * queImagen.Height / queImagen.Width y su equivalente con Width ya que no aparecía el símbolo de la división entera (la otra barra inclinada). Lo he sustituido por la barra de división normal, peeeeeero tiene que ser una división entera, o bien convertir el resultado en un entero.