Entrada muy rápida y sin código explicativo, pero que quizás sirva a alguien como me ha servido a mí.

El problema es la necesidad de validar los datos que el usuario introduce en un DataGridView. Si controlo el evento RowValidating sólo muestro aviso del error cuando el usuario ha rellenado toda la fila, con el consiguiente problema visual (la celda afectada puede estar fuera de la pantalla visible en ese momento). Si lo que hago es controlar el evento CellValidating, impido que el usuario pueda salir de la celda sin meter un valor válido, lo que puede no interesarme.

Sin embargo, puedo controlar el evento CellEndEdit para ir evaluando los datos introducidos por el usuario y, para aquellos no válidos, usar el ErrorText de la celda en cuestión para avisar del valor no válido. Esto es meramente informativo y usaríamos el evento RowValidating para hacer la validación real de los datos (evitando evaluar nada si IsNewRow es True).

Me he instalado la versión de prueba de Visual Studio 2012 para cacharrear con ella y ver qué tiene de interesante. Con un poco de suerte, pasaré de VB Express a VS Pro en el curro y estoy evaluando tanto VS2010 como VS2012. La verdad es que, si por mi fuera, me quedaba con VS2010. La interfaz de la versión 2012 es un horror de proporciones bíblicas, un canto al ego exacerbado de los diseñadores de interfaces, con un diseño esclavo del minimalismo total de Windows 8 (si Windows Vista y 7 compartían aire y filosofía con KDE, el nuevo Windows es la rendición al estilo Gnome) y sin la más mínima concesión a los pobres currantes que debemos pasarnos horas delante suya.

Resumiendo mucho, la interfaz de VS2012 es como retroceder 20 años al pasado: un entorno monocromo. Iconos en blanco y negro, fondos en grises claros, ninguna concesión al color. Bueno, miento: la Beta era total y absolutamente en blanco y negro, pero ante las quejas los diseñadores han dado unas pequeñas concesiones al color. Por ejemplo, resaltar en un azul plano la pestaña seleccionada o indicar en azul o verde las clases de VB o de C#. Pero todo lo demás (los iconos de controles para el diseñador de formularios, los iconos de todos los demás objetos del explorador de soluciones, como formularios, controles de usuario, carpetas, datasets…), todo lo demás, digo, en blanco y negro.

Menos mal que la comunidad resiste por el bien de nuestra salud visual y mental y nos ofrece herramientas para convertir VS2012 en algo aceptable (aunque no para las versiones Express, me temo).

Para empezar, Visual Studio 2012 Color Theme Editor es una extensión que nos permite crear y editar temas de escritorio: colores de menús, barras de herramientas y tal. Trae varios creados y uno de ellos, Blue, es muy similar al cómodo tema azul de Visual Studio 2010.

Para seguir, la herramienta Visual Studio Icon Patcher nos permite extraer los iconos de VS2010 y metérselo a VS2012. No reemplaza a todos los iconos, pero volveremos a tener los coloristas y fácilmente identificables iconos del Explorador de soluciones y del Cuadro de herramientas. Con eso, me vale. También nos permite dejar la barra de menús en formato normal (primera letra en mayúsculas, resto en minúsculas), no con todo en MAYÚSCULAS, QUE QUEDA HORROROSO DE VERDAD.

Con estas dos herramientas la cosa cambia y podemos centrarnos en descubrir qué trae VS2012.

Acabo de instalar en el curro la versión de prueba de VS2012. He conseguido convencerles de que VB Express no da más de sí y necesito algo más «tocho» (es totalmente cierto) y la duda está entre VS2010 y la nueva versión que sale estos días. La primera intención sería tirar por VS2012 si no da problemas con la conversión y compilación de las aplicaciones que estoy desarrollando. Desde VB2005 he ido cambiando de versión tan pronto me era posible. Pero esta vez…

En Visual Studio 2010 teníamos un esquema de colores que delimitaba muy bien las áreas de trabajo y la ventana o pestaña activa. Los iconos eran fácilmente reconocibles por su color antes incluso que por su forma (por ejemplo, amarillo para datos o carpetas… cosas así).

En VS2012, no. Toda el área de trabajo es gris sucio o gris oscuro. Todos los iconos son en blanco y negro, con pequeñas (pequeñísimas) notas de color plano. Si no fuera por esas notas de color disperso y la nitidez del texto y grises, me parecería estar frente al viejo Mac de mi tío, allá cuando mi padre y yo tirábamos de MS-DOS 4.01 y lo de la Multimedia sonaba a cosa futurista.

Menos mal que el código mantiene sus colores. Imagino que eso ha sido una exigencia de los desarrolladores frente al bello monocromo minimalista que proponían los diseñadores. Un poco en plan «si trabajamos con VB4 y 5, a esto sobrevivimos».

No entiendo ni entenderé ese minimalismo conceptual que nos ha caído encima con Windows 8 (y que sufrí en tiempos con Gnome, antes de huir corriendo a KDE). El sufrir con un entorno espartano y retro, como si fuera pecado que nuestras máquinas puedan mostrar millones de colores, texturas, bordes redondeados, sombras…

Visualmente, VS2012 es una rendición a los diseñadores. Sin la ayuda de contrastes, de iconos identificables y agrupables de un vistazo es cansado para la vista y para el cerebro trabajar con él.

Me encuentro con que hay un error en el encabezado de ciertos mensajes de correo enviados automáticamente por el gestor de incidencias (SOS). Debía poner «SOSNext: aviso de cierre de la acción de mejora nº tal», pero llega cortado en la «ó» de acción, que es sustituida por un carácter raro. Lo curioso es que el resto de correos con la palabra «acción» en el título llegan sin problemas.

Lo más curioso es que la contrapartida al cierre llega sin problemas: «SOSNext: aviso de reapertura de la acción de mejora nº tal». Curioso, ¿por qué?, diréis. Bueno, pues por el código que genera el título del mensaje es similar en ambos casos:

Titulo = «SOSNext: Aviso de cierre de la « & Singular & » nº « & Id

Y

Titulo = «SOSNext: Aviso de reapertura de la « & Singular & » nº « & Id

¿Cuál es la diferencia?

La longitud de la cadena. No sé el porqué, pero el problema está en los seis caracteres que ocupa «cierre». Cambiando la longitud de la palabra o, como he hecho, añadiendo un espacio más antes de «cierre», problema solucionado.

Aunque la cara de pasmo tardará más en quitárseme.

El otro día, intentando filtrar un DataView, me encontré con un problema pintoresco: quería filtrar los usuarios con determinados permisos en la aplicación, para lo cual necesitaba hacer una comparación bit a bit. Hacer esa comparación en SQL no supone problema (Permisos & PermisoPedido = PermisoPedido). En VB, tampoco (UsuarioActivo.Permisos AND PermisoPedido = PermisoPedido), pero la propiedad RowFilter del DataView es mucho más restrictiva. Usa sintaxis SQL, pero con muchas limitaciones.

En la Geekpedia encontré una solución al problema: pasar de las operaciones bit a bit y resolver el problema con operaciones decimales normales y corrientes:

(Convert((Permisos – Permisos % PermisoPedido) / PermisoPedido,’System.Int32′) % PermisoPedido = 1)

Donde PermisoPedido es el valor numérico buscado de nuestra enumeración (1, 2, 4, 8, 16…). El operador % es, en Visual Basic, el módulo (resto de la división entera).

He tenido durante meses un problema pintoresco: en una aplicación de Windows Forms con enlace de datos (datasets tipados, BindingSource y demás) se me cambiaba el estado de las datarow a modificadas sólo con navegar entre los registros. Dado cómo se actualizaban los datos a la base de datos, resultó ser un problema menor, pero molesto. El problema parecía estar en el enlace de datos (binding) de usercontrols. En su día no encontré nada en MSDN y lo dejé para otra ocasión. Ayer, buscando otra cosa, encontré la solución al problema.

Resumiendo: si buscamos ayuda sobre cómo hacer un enlace de datos simple en nuestro control personalizado, nos dicen que usemos <BindableAttribute(True)>:

<BindableAttribute(True)>
Public Property IdAccion As Integer

Pero resulta que, con sólo eso, el BindingSource supone que siempre cambian los valores enlazados y actualiza el origen de datos. Resulta que además debemos implementar la interface INotifyPropertyChanged y notificar cuándo cambia el valor, tal que de esta forma:

<BindableAttribute(True)>
Public Property IdAccion As Integer
    Get
        Return Me._IdAccion
    End Get
    Set(value As Integer)
        If _IdAccion <> value Then
            Me._IdAccion = value
            RaiseEvent PropertyChanged(Me, _
                    New PropertyChangedEventArgs("IdAccion"))
            Me._IdAccion = value
        End If
    End Set
End Property

Sigo, eso sí, sin haberlo visto tan bien explicado en la documentación. Menos mal que existen los foros y los blogs.

Pero, ajá, no es la panacea. Ahora me encuentro con que, a veces, el valor no cambia aunque debería. Por ejemplo, al añadir un nuevo registro que tiene (o tendrá) el mismo valor de la propiedad que el anterior. Hay que revisar estos casos con cuidado para, o bien asegurarnos de que cambia el valor de la propiedad o bien provocar a mano el evento cuando lo creamos necesario. En fin, problemas del enlace a datos.

El año pasado, intentando desembarazarme de una tarea tediosa que dejaba frito mi equipo, usé mi primera función recursiva con utilidad práctica. Como la tarea consumía su tiempo, tiré de un BackGroundWorker. Componente sencillo de usar y con ejemplos bastante claros en la ayuda de Visual Studio. No problem: tenía un valor de entrada pedido por el usuario, se realizaban n operaciones de forma recursiva, se obtenía un valor de salida.

Como el proceso era algo largo (mínimo unos diez segundos, pero podía llegar superar el minuto en la versión 2, que admitía de entrada una serie de valores), se me ocurrió usar una barra de progreso para mantener informado al usuario.

Entonces empezaron los problemas.

Todos los ejemplos que he visto que usan el evento ProgressChanged del BackGroundWorker para alimentar una barra de progreso presentan una serie de operaciones en secuencia con llamadas a ProgressChanged entre ellas, es decir: hago paso 1; progreso cambiado; hago paso 2; progreso cambiado… Sin embargo, mi problema era otro: tengo una instancia de mi clase de trabajo, cojo los valores del usuario (a través de DoWorkEventArgs.Argument), se los paso, y le digo «ea, majo. Tú puedes» llamando al método MiClase.HacerCurro. Ahí dentro se harán las n operaciones (recursivas), número desconocido hasta que se hagan.

Vale, pensé. Puedo provocar un evento OperaciónCompletada cada vez que complete una operación. Pero la instancia de MiClase está declarada dentro del DoWork del BackGroundWorker. No tengo acceso desde fuera. ¿Cómo lo hago?

¿Y si meto alguien que escuche en el DoWork? De esta forma tendría mi «escuchador» de eventos en el mismo hilo. Es decir, una clase, digamos Escuchante, a la que le paso mi instancia de MiClase y la del BackGroundWorker. Escuchante gestiona el evento OperacionCompletada provocando a su vez el ProgressChanged, que actualiza la barra de progreso.

No sé si será una solución muy limpia, pero funcionó.

En resumen, algo así:

Public Class Escuchante

Private WithEvents _MiClase as MiClase

Private _MiBGW as BackGroundWorker

Public Sub New(mc as MiClase, bw as BackGroundWorker)

_MiClase=mc

_MiBGW=bw

End Sub

Private Sub OpCompletada(sender as Object, e as OperacionCompletadaEventArgs) _

        Handles _MiClase.OperacionCompletada

_MiBGW.ReportProgress=e.NumOp

End Sub

End Class

Quiero mi bo cadillo decía ese gran filósofo moderno que es Homer Simpson. Algo parecido he estado yo pidiendo estos días. El problema se me ha presentado en una aplicación con acceso a datos, con un montaje convencional: dataset tipado + bindingsource + controles en el formulario. Uno de los campos era una fecha y podía tener valores nulos. Hasta ahí bien. El problema es que en ediciones podía recuperar el valor nulo. En esos casos, fallaba la validación de datos y no se guardaba nada, aunque tampoco conseguía saber por qué: tuve que echar mano del evento BindingComplete del BindingSource para enterarme que se producía un error en la conversión de tipos. El tipo Date no acepta nulos.

Tras una larga búsqueda en internet, casi todo en inglés, averigüé dos cosas: que era un problema común y muy molesto y que no tenía solución fácil. También hallé unas pistas que me indicaron el camino. Un trabajo no muy limpio, pero que funciona, dividido en dos partes: el enlace al control y la datatable correspondiente.

En enlace, usando el diseñador (DataBindings, Avanzado) para asignar un formato de fecha corta, queda así:

Sigue leyendo →