El aprendiz de brujo

Entre las diversas tareas que una aplicación debe realizar, a veces se encuentran ciertos procesos que pueden tomar un considerable tiempo en completarse. Ante este tipo de situaciones resulta una inestimable ayuda para el usuario la posibilidad de disponer de algún tipo de indicación visual, que le notifique cuándo ha terminado el proceso de ejecutarse.

Un recurso que podemos utilizar para conseguir este objetivo consiste en realizar una llamada a la función FlashWindowEx, perteneciente a la API de Windows, cuya finalidad consiste en hacer parpadear la ventana sobre la que se aplica esta función.

En las dos partes que componen el presente artículo describiremos -en esta primera parte- las características de esta función, así como la forma en que debemos declararla en nuestro código para poder llamarla posteriormente. En la segunda parte ilustraremos con varios ejemplos prácticos su modo de uso dentro de una aplicación.

El efecto de parpadeo conseguido mediante FlashWindowEx puede estar condicionado por diversos factores que nos permiten establecer su comportamiento; de esta forma podemos especificar, entre otras características, el número de veces en que se producirá el parpadeo, la frecuencia entre los mismos, la finalización del efecto, etc.

Elementos relacionados con FlashWindowEx

Para poder enviar toda la información necesaria a FlashWindowEx, esta función recibe como parámetro una estructura denominada FLASHWINFO en la documentación de Windows. Respecto al valor de retorno de FlashWindowEx, consiste en un dato numérico que nos indica el estado que originalmente tenía la ventana antes de realizar la llamada. La firma de esta función en la documentación es la siguiente.

BOOL WINAPI FlashWindowEx(__in PFLASHWINFO pfwi);

Volviendo a la estructura FLASHWINFO, la siguiente tabla describe cada uno de los miembros que la componen.

Como acabamos de observar, el elemento dwFlags de esta estructura admite una serie de valores, que pueden ser representados mediante un conjunto de constantes, cuyos nombres -tal y como aparecen en la documentación de Windows- se muestran relacionados a continuación.

Como fuente oficial de referencia, en los siguientes enlaces tenemos disponible la información tanto de FlashWindowEx como de FLASHWINFO, así como de otra función, FlashWindow, que abordaremos en la segunda parte del artículo.

Preparando el código

Y llegamos al momento de poner en práctica toda la teoría explicada anteriormente, para lo cual iniciaremos Visual Studio y crearemos un nuevo proyecto de tipo "Aplicación WPF" que utilizaremos como banco de pruebas. Todos los ejemplos aquí explicados resultan igualmente aplicables a un programa Windows Forms tradicional, con alguna ligera variante que puntualizaremos allá donde sea necesario.

En primer lugar vamos a declarar la estructura FLASHWINFO, cuyo código escribiremos en el mismo archivo de clase que la ventana del proyecto, a fin de simplificar este ejemplo.

namespace VentanasParpadeantes_CS
{
    public struct FLASHWINFO
    {
        public int cbSize;
        public IntPtr hwnd;
        public int dwFlags;
        public int uCount;
        public int dwTimeout;
    }
    //....
}

Continuaremos con las constantes que necesita el miembro dwFlags de esta estructura para poder aplicar el tipo de efecto adecuado. Estos valores podemos implementarlos de dos maneras: declarando las constantes dentro de la clase de la ventana.

public partial class Window1 : Window
{
    //....
    private const int FLASHW_CAPTION = 0x00000001;
    private const int FLASHW_TRAY = 0x00000002;
    private const int FLASHW_ALL = (FLASHW_CAPTION | FLASHW_TRAY);
    private const int FLASHW_STOP = 0;
    private const int FLASHW_TIMER = 0x00000004;
    private const int FLASHW_TIMERNOFG = 0x0000000C;
    //....
}

O bien, dado que se trata de un conjunto de valores relacionados, creando una enumeración e incluyéndolos como miembros de la misma.

namespace VentanasParpadeantes_CS
{
    //....
    public enum FlashStatus : int
    {
        FLASHW_CAPTION = 0x00000001,
        FLASHW_TRAY = 0x00000002,
        FLASHW_ALL = (FLASHW_CAPTION | FLASHW_TRAY),
        FLASHW_STOP = 0,
        FLASHW_TIMER = 0x00000004,
        FLASHW_TIMERNOFG = 0x0000000C
    }
    //....

Para terminar con esta parte del ejemplo declararemos la función FlashWindowEx aplicándole el atributo DllImport, al que pasaremos como parámetro una cadena con el nombre de la librería de la API de Windows a utilizar, en este caso user32.dll, ya que es la que contiene la función a emplear. Igualmente será necesario declarar el espacio de nombres InteropServices, como vemos a continuación.

using System.Runtime.InteropServices;
//....
namespace VentanasParpadeantes_CS
{
    //....    
    public partial class Window1 : Window
    {
        //....
        [DllImport("user32.dll")]
        public static extern int FlashWindowEx(ref FLASHWINFO pfwi);
        //....

Nótese que la estructura FLASHWINFO debe pasarse a FlashWindowEx por referencia, para lo cual emplearemos la palabra clave ref junto a la estructura.

En el caso de encontrarnos trabajando con VB, además de poder declarar la función con el atributo DllImport, podemos emplear también la palabra clave Declare; ambos modos de declaración en este lenguaje se muestran a continuación.

<DllImport("user32.dll")> _
Public Shared Function FlashWindowEx(ByRef pfwi As FLASHWINFO) As Integer
End Function

Declare Function FlashWindowEx Lib "user32.dll" (ByRef pfwi As FLASHWINFO) As Integer

Una vez finalizados todos estos pasos, ya nos encontramos en disposición de usar esta función en nuestra ventana, para lo que añadiremos a la misma varios botones que nos sirvan para poner en funcionamiento los diversos ejemplos a ilustrar. El aspecto de la ventana podemos verlo en la siguiente imagen.

El código XAML utilizado para definir la interfaz de usuario lo vemos a continuación.

<Window xmlns:my1="clr-namespace:System.Windows.Controls;assembly=PresentationFramework"  
    xmlns:my="clr-namespace:System.Windows.Controls;assembly=PresentationFramework"  
    x:Class="VentanasParpadeantes_CS.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Pruebas con FlashWindowEx" 
    Height="220" Width="300"
    Loaded="Window_Loaded" 
    StateChanged="Window_StateChanged">

    <my:StackPanel Background="LightYellow">
        <my1:Button Name="btnBasico" Margin="10" Width="110" Click="btnBasico_Click">Básico</my1:Button>
        <my1:Button Name="btnComenzar" Margin="10" Width="110" Click="btnComenzar_Click">Comenzar</my1:Button>
        <my1:Button Name="btnTerminar" Margin="10" Width="110" Click="btnTerminar_Click">Terminar</my1:Button>
</Window>

Y llegados a este punto terminamos la primera parte de este artículo; en la siguiente entrega abordaremos con varios ejemplos la manera de implementar esta función dentro de un programa.

No obstante, pensando en los más impacientes, vamos a proporcionar los enlaces con el código fuente de los ejemplos en C# y VB.

Un saludo.

En el presente post se proporciona una relación de los artículos que he publicado, organizada por las distintas publicaciones técnicas en que han aparecido.

dNM

Se trata de una publicación dedicada a la plataforma .NET y a otras tecnologías de desarrollo, en la que colaboro como redactor. El siguiente enlace ofrece el acceso a su portal Web.

Una vez que hayamos accedido a la Web de dNM, encontraremos los nombres de los artículos correspondientes al número más reciente publicado, mientras que el enlace revista nos llevará a una página conteniendo la relación de todos los números publicados, existiendo incluso la posibilidad de descargar el ejemplar en formato electrónico, en aquellos números en los que esta característica se encuentre habilitada. También podremos descargar el material de apoyo asociado al artículo, en el caso de que exista. 

A continuación se muestra una relación de los artículos que he publicado en este medio.

Modelos tabulares en SQL Server 2012 Analysis Services
Nº 93. Junio 2012

Ordenación de fechas en PowerPivot
Nº 88. Enero 2012

PowerPivot, DAX y Excel. Business Intelligence para todos los públicos
Nº 83. Julio-Agosto 2011

Optimizando el filtrado de datos en el control DomainDataSource
Nº 79. Marzo 200

DomainDataSource. Un gestor de datos en Silverlight para la interfaz de usuario
Nº 78. Febrero 2011

Cubos de datos en SQL Server 2008 Analysis Services
Nº 77. Enero 2011

Edición de entidades con el control DataForm de Silverlight
Nº 74. Octubre 2010

Visual Basic 2010. Novedades del lenguaje
Nº 69. Abril 2010

Acceso a datos en Silverlight con WCF RIA Services
Nº 68. Marzo 2010

Manipulación de datos en Silverlight mediante ADO.NET Data Services (y III)
Nº 60. Junio 2009

Manipulación de datos en Silverlight mediante ADO.NET Data Services (II)
Nº 59. Mayo 2009

Manipulación de datos en Silverlight mediante ADO.NET Data Services (I)
Nº 58. Abril 2009

Sustituyendo el editor de celdas del control DataGridView
Nº 47. Abril 2008

El evento CellPainting del control DataGridView. Vía libre a la creatividad
Nº 43. Diciembre 2007

Aplicación de formato y selección manual de columnas sobre el control DataGridView
Nº 42. Noviembre 2007

DataGridView y estilos. Presentaciones de datos visualmente atractivas
Nº 39. Julio-Agosto 2007

Estilos en XAML
Nº 27. Junio 2006

El IDE de Visual Studio 2005
Nº 20. Noviembre 2005

Ordenación de datos en Reporting Services
Nº 18. Septiembre 2005

Integración del CLR con SQL Server 2005. Ejecutando código administrado desde el núcleo del motor de datos
Nº 17. Julio-Agosto 2005

Emitir código JavaScript desde WebForms y controles Web personalizados
Nº 15. Mayo 2005

Manipulación de imágenes con ADO.NET
Nº 14. Abril 2005

Aplicando código y herencia en la configuración visual del control DataGrid
Nº 7. Septiembre 2004

Configurando la apariencia del control DataGrid
Nº 6. Julio-Agosto 2004

Relleno de formas gráficas, texturas, degradados y otros efectos avanzados con GDI+
Nº 4. Mayo 2004

Introducción a GDI+
Nº 3. Abril 2004

AlgoritmoDigital

Se trata de una revista electrónica de suscripción gratuita que actualmente ya no se encuentra disponible online. No obstante, la siguiente lista ofrece enlaces a los contenidos de los artículos que allí publiqué.

Inyectando código personalizado en los informes
Diciembre 2004

Tablas y formateo de valores en Reporting Services
Noviembre 2004

Manipulación de encabezados y pies de página en Reporting Services
Octubre 2004

Manipulación de código por bloques en el editor de Visual Studio .NET
Agosto 2004

Eliminando el blindaje de seguridad de .NET Framework ante aplicaciones rebeldes
Junio 2004

Aquí estación orbital C# llamando a estación base VB.NET ¿Me oyen?
Junio 2004

¿Por qué mi DataGrid no muestra datos?
Mayo 2004

Primer contacto con SQL Server Reporting Services
Mayo 2004

Creación de scripts de inserción en SQL Server a partir de una consulta de selección
Abril 2004

Desarrollo de controles Windows propios (II)
Abril 2004

Controlar el número de ejecuciones de un programa en VB.NET
Marzo 2004

Declarar en línea el contador de una estructura For...Next usando VB.NET
Marzo 2004

Desarrollo de controles Windows propios (I)
Marzo 2004

Recuperar los parámetros de inicio de la aplicación en VB.NET
Febrero 2004

Serialización o persistencia de objetos (II)
Febrero 2004

Definición y desplazamiento a tareas en el editor de código de Visual Studio .NET
Enero 2004

Serialización o persistencia de objetos (I)
Enero 2004

Vistas de ayuda simultáneas en Visual Studio .NET
Diciembre 2003

.NET, la evolución continúa
Diciembre 2003

Comprobación de valores con las funciones IsNothing e IsDBNull
Noviembre 2003

Creación de controles heredados
Noviembre 2003

Formularios siempre en primer plano
Octubre 2003

Crystal Reports para Visual Studio .NET
Octubre 2003

Arrays personalizados
Junio 2002

Colecciones, la potencia oculta de los arrays
Febrero 2002

Arrays en Visual Basic .NET
Enero 2002

Origen de datos sin proveedor
Noviembre 2001

Más difícil todavía: haciendo equilibrios en la hebra
Junio 2001

Delegación de código con Visual Basic .NET
Junio 2001

Cansado de los formularios de siempre...
Mayo 2001

Insertar datos en memoria
Abril 2001

Mudanza de información
Diciembre 2000

Declaraciones estrictas
Diciembre 2000

Pase de backstage para usuarios
Septiembre 2000

Facilitando el cambio de foco entre los controles de un formulario
Julio 2000

Creación de ventanas de inicio de aplicación (II)
Julio 2000

Creación de ventanas de inicio de aplicación (I)
Junio 2000

Objetos de datos y SQL
Enero 1997

Algoritmo

La versión en formato impreso de esta revista comenzó su andadura en plena efervescencia de aquellos tiempos pioneros de la programación Windows, cuando el desarrollo en Clipper dio paso a su versión en Windows con Visual Objects. En aquella etapa publiqué los siguientes artículos, que a pesar de haber sido editados originalmente en papel, también estaban disponibles en AlgoritmoDigital.

La invasión de las ventanas clónicas
Junio 1996

Atacando directamente el Recordset
Mayo 1996

No se complique la vida, use un DataControl
Abril 1996

Nuevos controles, nuevas validaciones (III)
Diciembre 1995

Nuevos controles, nuevas validaciones (II)
Noviembre 1995

Nuevos controles, nuevas validaciones (I)
Octubre 1995

Ventanas mutantes (II)
Septiembre 1995

Ventanas mutantes (I)
Julio 1995

Adiestrando los datos
Junio 1995

Un menú para cada gusto
Marzo 1995

Un ratón en el menú
Febrero 1995

Clippermanía

Esta revista en formato impreso se constituyó como referencia clave en castellano para toda la comunidad de desarrolladores Clipper de su época, abordando también el periodo de transición que supuso el paso de la programación en entorno MS-DOS a Windows, utilizando para esto último Visual Objects como herramienta de desarrollo. Para esta publicación escribí los siguientes artículos.

Charlas con ficheros DBF (III)
Noviembre 1994

Charlas con ficheros DBF (II)
Octubre 1994

Charlas con ficheros DBF (I)
Septiembre 1994

Objetos a la herencia (II)
Marzo 1994

Menús del día: objetos a la herencia (I)
Febrero 1994

De caja a caja y edito porque me toca
Enero 1994

Campos, registros y otras divagaciones estivales (II)
Octubre 1993

Campos, registros y otras divagaciones estivales (I)
Septiembre 1993

Dale "Clase" a tus etiquetas
Julio 1993

Encuentros 1993 de usuarios Clipper (crónica del evento)
junio 1993

La clase Indexes
Mayo 1993

Guía Microsoft de gestión de memoria con el DOS 5 (reseña bibliográfica)
Mayo 1993

Cuando desde Visual Studio 2008 nos encontramos utilizando alguno de los asistentes visuales que nos permiten establecer y configurar una conexión contra SQL Server 2008, en concreto, la CTP de Febrero de 2008, es posible que nos encontremos con un error de conexión como el que muestra la siguiente imagen. 

Para solucionar este problema, existe un parche disponible con el nombre "Visual Studio 2008 support for SQL Server 2008, CTP", al que podemos acceder en este enlace.

Una vez instalado, ya deberíamos poder conectar a SQL Server desde el entorno de Visual Studio 2008.

Espero que os resulte de utilidad.

Un saludo.

Luismi.

Ayer me encontré con un problema realmente curioso, de esos que te hacen pensar en algunas ocasiones que hay "meigas" y brujería en estas cuestiones del desarrollo de software ;-D.

Resulta que hice un formateo del disco de mi equipo -que ya me lo venía pidiendo a gritos-y comencé el tedioso, pero necesario, proceso de instalación de todo el conjunto de aplicaciones que necesitamos para "montar" nuestro entorno de trabajo.

Después de instalar Windows Vista pasé a la instalación de Visual Studio 2008, la cual se realizó correctamente, y a su finalización comprobé que en general todo estaba correcto, iniciando el entorno de desarrollo y creando algunas aplicaciones de prueba de tipo WPF, Web, etc.

A continuación comencé con la incorporación del paquete de controles "Ajax Control Toolkit" al IDE de Visual Studio 2008, utilizando los pasos que creo todos empleamos para esta labor:

-Creación, dentro de la carpeta "Program Files" de nuestra máquina, de una carpeta para contener los archivos del paquete de controles. La ruta completa resultante podría ser, por ejemplo, la siguiente: "C:\Program Files\Ajax Control Toolkit".

-Descomprimir el archivo que contiene este conjunto de controles: AjaxControlToolkit-Framework3.5.zip - que podemos obtener de CodePlex-, sobre la ruta mencionada en el punto anterior.

-Copiar los archivos contenidos en la ruta "C:\Program Files\Ajax Control Toolkit\SampleWebSite\Bin", dentro de esta otra ruta: "C:\Program Files\Ajax Control Toolkit\Binaries".

-Abrir Visual Studio 2008 y crear un nuevo proyecto Web.

-Hacer clic derecho en el Cuadro de herramientas, y seleccionar la opción "Add Tab" para crear una nueva pestaña; como nombre podemos utilizar el mismo del paquete de controles: "Ajax Control Toolkit".

-Hacer clic derecho sobre la pestaña recién creada y elegir la opción "Choose Items" para añadirle los controles del Toolkit, ubicados en la librería AjaxControlToolkit.dll que está en la ruta "C:\Program Files\Ajax Control Toolkit\Binaries".

Tras realizar todas estas operaciones, ya tendríamos todo lo necesario para utilizar los controles del Ajax Control Toolkit en nuestras aplicaciones Web. Pues bien, en mi caso, me encontré ante un problema consistente en que la pestaña "Ajax Control Toolkit" desaparecía del Cuadro de herramientas tras añadirle los controles.

Para obligar a Visual Studio a mostrarme todos los elementos del Cuadro de herramientas, hice clic derecho sobre este y seleccioné la opción "Show All", y en efecto, apareció la pestaña "Ajax Control Toolkit", pero ante mi sorpresa, todos los controles que contenía estaban deshabilitados 8-¿?!!!!.

Empecé a rastrear en la Web buscando posibles casos similares al mío, y me encontré con este post en el blog de Bill Evjen, donde se comentaba que una posible solución consistía en situarnos en la siguiente ruta de nuestra máquina: "C:\Users\[NombreUsuario]\AppData\Local\Microsoft\VisualStudio\9.0", y borrar todos los archivos con la extensión tbd; operación que debemos hacer con Visual Studio 2008 cerrado, y comprobando desde el administrador de tareas del sistema, que su proceso -dev.exe-  se encuentre realmente detenido.

No obstante, antes de probar esta solución seguí revisando los comentarios existentes en el hilo de este post, y me encontré con uno que me llamó especialmente la atención; en él se explicaba que el origen del problema podía deberse a la utilización de un conjunto de teclado y ratón inalámbricos de Microsoft, ya que esta persona había sustituido estos periféricos por otros con cable, y a partir de ese momento, todo había vuelto a funcionar con normalidad.

Casualmente este escenario se parecía al mío, ya que hacía pocos días que había sustituido mi teclado y ratón por una pareja de estos dispositivos inalámbricos, en concreto el modelo Microsoft Wireless Optical Desktop 1000, pero desde que los instalé no había necesitado abrir o crear un proyecto Web en Visual Studio 2008, por lo que no fue hasta el formateo de mi disco y reinstalación de las aplicaciones que no me percaté del problema.

Dado que parecía una solución bastante curiosa, antes que probar cualquier otro truco, desenchufé el ratón y teclado inalámbricos, volviendo a poner unos con cable; abrí de nuevo el proyecto Web de Visual Studio 2008, y ¡¡¡sorpresa!!!, allí estaba la pestaña "Ajax Control Toolkit" en el Cuadro de herramientas, con sus controles correspondientes habilitados.

Realmente no sé si el origen principal de este, cuanto menos curioso, problema será el uso de una pareja de ratón y teclado inalámbricos, por lo que creo importante considerar también alguna de las otras soluciones que se comentan en el mencionado post, tales como el borrado de los archivos tdb, comprobar que el proyecto esté trabajando contra la versión 3.5 de .NET Framework, etc., pero si alguien lee este artículo y el escenario del problema coincide con el que he explicado, puede que le resulte más simple empezar a acotar este inconveniente sustituyendo el ratón y teclado, por probar no se pierde nada.

Espero que os pueda resultar de utilidad.

Un saludo.
Luismi

Como colofón a esta serie de artículos, en esta entrega explicamos el modo de aplicar formatos a las columnas del DataGridView en función del tipo de su dato, mediante expresiones reguladas y sobre filas completas del control.

Aplicar un estilo como formato según el tipo de dato

En caso de que en un mismo proceso de formato necesitemos manipular columnas de distintos tipos de datos, aplicando también diferentes características visuales a cada celda, puede resultar de utilidad crear en primer lugar un estilo para el tipo de dato a formatear, en el que configuremos cada uno de los aspectos visuales, y aplicarlo en el evento CellFormatting al detectar que la celda actual contiene dicho tipo de dato.

Basándonos en este supuesto, dentro del siguiente ejemplo creamos dos objetos de tipo DataGridViewCellStyle, que instanciamos y configuramos al cargar el formulario, para finalmente, asignar en el evento CellFormatting, cuando la celda a manipular corresponda a dicho tipo de dato y su valor cumpla cierta condición, como vemos en el siguiente código.

public partial class frmFormatoTipoDato : Form
{
    // declarar dos estilos
    DataGridViewCellStyle styFecha;
    DataGridViewCellStyle styDecimal;
    //....
    public frmFormatoTipoDato()
    {
        InitializeComponent();
    }

    private void frmFormatoTipoDato_Load(object sender, EventArgs e)
    {
        // instanciar un estilo para mostrar los tipos fecha y decimal
        styFecha = new DataGridViewCellStyle();
        styFecha.BackColor = Color.Gold;
        styFecha.ForeColor = Color.DarkOliveGreen;
        styFecha.Format = "dd/MMM/yyyy";
        styFecha.Font = new Font("Magneto", 10, FontStyle.Bold);

        styDecimal = new DataGridViewCellStyle();
        styDecimal.BackColor = Color.LightGreen;
        styDecimal.ForeColor = Color.DarkOrchid;
        styDecimal.Format = "C";
        styDecimal.Font = new Font("Lucida Calligraphy", 10);

        this.dataGridView1.DataSource = ConstruirDatos.ObtenerTabla();
    }

    private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
    {
        // comprobar el tipo de dato que contiene la celda
        // y aplicarle el estilo
        if (e.Value.GetType() == typeof(DateTime))
        {
            if (((DateTime)e.Value).Year > 1970)
            {
                e.CellStyle = styFecha;
            }
        }

        if (e.Value.GetType() == typeof(decimal))
        {
            if ((decimal)e.Value == 30000)
            {
                e.CellStyle = styDecimal;
            }
        }
    }
}

El efecto puede apreciarse en esta imagen.

Formateando mediante expresiones reguladas

A través de la clase Regex podemos construir un formato basado en un patrón de sustitución que pasamos como cadena de caracteres al constructor de la expresión regulada.

Tomemos como base para esta demostración el campo CustomerAlternateKey, que muestra un código alfanumérico. Suponiendo que necesitemos visualizar los valores de esta columna en grupos de dígitos que sigan un patrón como este: XX-XXX-XX-XXX, el código para formatear estos valores sería similar al siguiente.

using System.Text.RegularExpressions;
//....
private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    if (this.dataGridView1.Columns[e.ColumnIndex].Name == "CustomerAlternateKey")
    {
        // crear una expresión regulada con un patrón de formato
        Regex oExpRegulada = new Regex(@"(\D{2})(\d{3})(\d{2})(\d{3})");
        
        // sustituir las partes del valor a formatear mediante la expresión regulada
        e.Value = oExpRegulada.Replace(e.Value.ToString(), "$1-$2-$3-$4");
    }
}

Mientras que los resultados serían los que vemos en esta imagen.

Aplicando formato a filas completas

Si el requerimiento de formato consiste en aplicarlo a la totalidad de una fila, podríamos pensar que la forma de resolver la situación pasaría por recorrer la colección Cells de cada objeto fila del DataGridView, y manipular la propiedad Style de dichas celdas individuales. Sin embargo existe un medio más fácil de lograr este objetivo, consistente en manipular, dentro del evento CellFormatting, la propiedad DefaultCellStyle del objeto DataGridViewRow actual que obtenemos de la colección Rows del control DataGridView.

private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    // si la celda corresponde a los ingresos anuales
    if (this.dataGridView1.Columns[e.ColumnIndex].Name == "YearlyIncome")
    {
        // y el valor cumple con cierta condición
        if ((decimal)e.Value > 50000)
        {
            // aplicar formato a la totalidad de la fila
            this.dataGridView1.Rows[e.RowIndex].DefaultCellStyle.BackColor = Color.Aquamarine;
        }
    }
}

En la imagen mostrada a continuación podemos apreciar este efecto.

Y con este ejemplo damos por concluida esta pequeña serie de artículos dedicados a las diferentes posibilidades de formato que podemos utilizar con el control DataGridView, espero que os resulte de utilidad. Al igual que en las anteriores entregas, los ejemplos están disponibles en estos enlaces: C# y VB.

Un saludo.

Siguiendo con los aspectos relacionados con el formateo de valores utilizando este evento, en la presente entrega abordaremos la posibilidad de aplicar formatos basados en una condición y sobre una columna a partir de los valores existentes en otras.

Formato condicional

Las operaciones tratadas hasta el momento podríamos haberlas realizado prescindiendo del evento CellFormatting, ya que al aplicar el formato a la totalidad de la columna, habría bastado con seleccionar de la colección DataGridView.Columns aquella columna a formatear, y mediante la propiedad DefaultCellStyle -que contiene un tipo DataGridViewCellStyle-asignar a la propiedad Format la cadena de formato adecuada. Esto podemos hacerlo, por ejemplo, en el evento Load.

private void frmFormatoCondicional_Load(object sender, EventArgs e)
{
    this.dataGridView1.DataSource = ConstruirDatos.ObtenerTabla();
    this.dataGridView1.Columns["BirthDate"].DefaultCellStyle.Format = "MMMM (yyyy)";
}

Es por ello que un uso más conveniente del evento CellFormatting consistiría en utilizarlo para formatear las celdas de una columna que cumplan una determinada condición, como podemos ver en el siguiente bloque de código, donde tras verificar que para la columna de tipo fecha, la celda a formatear contiene valor, si este corresponde al mes de febrero, se le aplica una cadena de formato para resaltar dicha celda.

private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    if (this.dataGridView1.Columns[e.ColumnIndex].Name == "BirthDate")
    {
        try
        {
            // comprobar si la celda tiene contenido válido
            if (e.Value.GetType() != typeof(System.DBNull))
            {
                // si la celda tiene valor y el mes es febrero 
                // formatear el contenido
                if (((DateTime)e.Value).Month == 2)
                {
                    e.CellStyle.Format = "D";
                    e.CellStyle.BackColor = Color.Aqua;
                }
            }
        }
        catch (NullReferenceException oException)
        {
        }
    }
}

Formato condicional aplicado a la totalidad de la columna

En ciertas ocasiones puede resultar interesante aplicar una operación de formato de modo global a todos los valores de una misma columna, consistente por ejemplo en modificar el texto original por otro más extenso, como podemos ver en el siguiente código, donde sustituimos los valores que inicialmente provienen de la columna Title de la tabla de datos.

private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    // cambiar el valor del campo Title
    if ((this.dataGridView1.Columns[e.ColumnIndex].Name == "Title") && (e.Value != null))
    {
        string TituloCortesia = string.Empty;

        switch (e.Value.ToString())
        {
            case "Sr.":
            case "Mr.":
                TituloCortesia = "Señor";
                break;

            case "Mrs.":
                TituloCortesia = "Señora";
                break;

            case "Ms.":
            case "Ms":
                TituloCortesia = "Señorita";
                break;
        }

        e.Value = TituloCortesia;
    }
}

Debido a la naturaleza del formato a realizar, este no puede acometerse asignando valores a los miembros de la propiedad DefaultCellStyle, perteneciente a la colección DataGridView.Columns -como veíamos en un caso anterior. Dado que los cambios necesarios no siguen un patrón prefijado, resulta necesario resolver el problema desde el flujo del código, dentro del  evento CellFormatting.

Formato indirecto

Como acabamos de comprobar, el formato condicional resulta de utilidad cuando deseamos aplicar un formato a las celdas de una columna en base a una expresión evaluada contra los valores de dicha columna. Sin embargo también podemos aplicar una variante de esta técnica que consistiría en realizar el formato sobre una celda, pero esta vez en función de la información proveniente de celdas pertenecientes a otras columnas.

Pongamos como ejemplo, que en los datos con los que estamos operando, necesitamos destacar el nombre de los clientes cuyos ingresos anuales superen una determinada cantidad. Para ello, dentro del evento CellFormatting, cuando corresponda aplicar formato a las columnas FirstName y LastName, comprobaremos el valor de la celda correspondiente a la columna YearlyIncome, y según sea su valor, resaltaremos o no las celdas del nombre. Todo esto podemos comprobarlo en el siguiente código.

private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    // si la celda a formatear corresponde al nombre del cliente...
    if ((this.dataGridView1.Columns[e.ColumnIndex].Name == "FirstName") ||
        (this.dataGridView1.Columns[e.ColumnIndex].Name == "LastName"))
    {
        //...y sus ingresos superan una cierta cantidad, 
        // formatear las celdas del nombre
        if ((decimal)this.dataGridView1.Rows[e.RowIndex].Cells["YearlyIncome"].Value >= 100000)
        {
            e.CellStyle.BackColor = Color.PaleGreen;
            e.Value = e.Value.ToString().ToUpper();
        }
    }
}

La siguiente imagen muestra el resultado de este tipo de formato.

Formato indirecto utilizando una columna con imágenes

Una variante de la técnica ofrecida en el apartado anterior consistiría en utilizar una columna de tipo imagen -DataGridViewImageColumn- para mostrar una figura que represente el valor de una columna. Dentro de la tabla que estamos usando para nuestros ejemplos, un claro candidato lo representaría la columna Gender, que nos informa acerca del género -masculino o femenino-correspondiente al cliente.

A efectos visuales, dicha columna podemos sustituirla por una de imagen, que muestre una figura identificativa, pero sin eliminar la columna Gender -que quedaría oculta-, ya que necesitaremos recurrir a ella para consultar su valor y saber qué imagen situar en la celda en curso.

En primer lugar agregaremos al proyecto sendos archivos de tipo imagen, que configuraremos en su propiedad Build Action para que se comporten como recursos incrustados -Embedded Resource.

A continuación pasaremos al código del formulario, donde en el evento Load ocultaremos la columna Gender y crearemos una nueva para contener las imágenes. Por otro lado, en el evento CellFormatting detectaremos cuando debe ser dibujada la celda de la nueva columna de imagen, y en dicho momento, comprobaremos el valor de la columna oculta Gender, asignando la imagen correcta. Todas estas operaciones las podemos ver en el siguiente código fuente.

private void frmFormatoIndirectoImagen_Load(object sender, EventArgs e)
{
    this.dataGridView1.DataSource = ConstruirDatos.ObtenerTabla();

    // ocultar la columna que indica el género del cliente
    this.dataGridView1.Columns["Gender"].Visible = false;

    // crear una nueva columna de tipo imagen
    // para mostrar un icono indicativo del género del cliente
    // y agregarla a la colección de columnas del control
    DataGridViewImageColumn colGenero = new DataGridViewImageColumn();
    colGenero.Name = "colGenero";
    this.dataGridView1.Columns.Add(colGenero);
}

private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    // cuando se vaya a pintar la celda de la columna de imagen
    if (this.dataGridView1.Columns[e.ColumnIndex].Name == "colGenero")
    {
        // establecer la altura de la fila para que se pueda visualizar correctamente
        this.dataGridView1.Rows[e.RowIndex].Height = 40;

        // asignar la imagen adecuada
        switch ((string)this.dataGridView1.Rows[e.RowIndex].Cells["Gender"].Value)
        {
            case "M":
                e.Value = new Bitmap(this.GetType(), "SimboloMasculino.jpg");
                break;

            case "F":
                e.Value = new Bitmap(this.GetType(), "SimboloFemenino.jpg");
                break;
        }
    }
}

En la siguiente imagen podemos observar el efecto de esta nueva columna en tiempo de ejecución. Como dato curioso, el valor del campo Gender en la tabla de la base de datos no se corresponde correctamente en todas las ocasiones.

La próxima entrega, que finaliza esta serie de artículos, abordará algunos aspectos adicionales de este tipo de operaciones. Como ya comentamos en la primera parte, los ejemplos están disponibles en estos enlaces: C# y VB.

Un saludo.

Aunque las capacidades de formato que proporciona el control DataGridView puedan resultar, en principio, sencillas de implementar, con cierta regularidad encuentro en los foros de Microsoft consultas referentes a cómo conseguir que la información de las celdas que este control muestra sea personalizable, para adaptarse a las exigencias del usuario.

DataGridView es un control potente, que nos permite visualizar una gran cantidad de datos en forma tabular, pero su aspecto predeterminado no resulta demasiado atractivo si lo que necesitamos es resaltar ciertos elementos para llamar la atención del usuario.

Sin embargo esto no quiere decir que carezca de la funcionalidad necesaria para ofrecer, si es menester, una imagen lo suficientemente atrayente.

Como ejemplo de dichas características, en esta serie de artículos abordaremos el evento CellFormatting, que combinado con las capacidades de creación y aplicación de estilos visuales, ofrece al programador un potente y flexible mecanismo que le permite formatear y resaltar los datos presentados.

CellFormatting es un evento que se desencadena para cada celda del DataGridView que es dibujada. Su funcionamiento por defecto consiste en convertir el dato a mostrar en el valor más adecuado a efectos de presentación (habitualmente texto). Pero dado que para ciertos valores, una manipulación más elaborada del dato puede ser necesaria, se expone el evento al programador para que pueda adaptarlo a sus necesidades.

Seguidamente vamos a mostrar un conjunto de los modos más habituales en que podemos formatear los valores de las celdas del control utilizando este evento.

El proyecto base de los ejemplos

Una  vez creado un nuevo proyecto en Visual Studio que nos sirva como banco de pruebas, y dado que para cada ejemplo a mostrar utilizaremos un formulario diferente, emplearemos el formulario por defecto que incluye el proyecto como "lanzadera" del resto de formularios, donde añadiremos un ListBox con los nombres de cada tipo de operación de formato junto a un botón para abrir el correspondiente formulario.

A continuación podemos ver el código necesario para las mencionadas operaciones.

private void btnVisualizar_Click(object sender, EventArgs e)
{
    Form frmFormulario;

    switch (this.listBox1.SelectedIndex)
    {
        case 0:
            frmFormulario = new frmFormatoBasico();
            frmFormulario.Show();
            break;

        case 1:
            frmFormulario = new frmFormatoColores();
            frmFormulario.Show();
            break;

        case 2:
            frmFormulario = new frmFormatoCondicional();
            frmFormulario.Show();
            break;

        case 3:
            frmFormulario = new frmFormatoCondicionalCambiarTodo();
            frmFormulario.Show();
            break;

        case 4:
            frmFormulario = new frmFormatoIndirecto();
            frmFormulario.Show();
            break;

        case 5:
            frmFormulario = new frmFormatoIndirectoImagen();
            frmFormulario.Show();
            break;

        case 6:
            frmFormulario = new frmFormatoTipoDato();
            frmFormulario.Show();
            break;

        case 7:
            frmFormulario = new frmFormatoExpresionRegulada();
            frmFormulario.Show();
            break;

        case 8:
            frmFormulario = new frmFormatoFilaCompleta();
            frmFormulario.Show();
            break;
    }
}

Preparación de los datos a visualizar

En todos los ejemplos mostrados vamos a utilizar una consulta contra la tabla DimCostumer, perteneciente a la base de datos AdventureWorksDW. Para evitar en cada formulario del proyecto la repetición del código que conecta con la fuente de datos y construye el DataSet encargado de rellenar el control DataGridView, vamos a crear una clase con un método estático, que nos devuelva la mencionada tabla, la cual asignaremos a la propiedad DataSource del control DataGridView.

class ConstruirDatos
{
    public static DataTable ObtenerTabla()
    {
        // crear la sentencia sql para obtener las filas
        StringBuilder sbSQL = new StringBuilder();
        sbSQL.Append("SELECT CustomerAlternateKey, ");
        sbSQL.Append("Title, FirstName, LastName, ");
        sbSQL.Append("BirthDate, YearlyIncome, Gender ");
        sbSQL.Append("FROM DimCustomer ");
        sbSQL.Append("WHERE Title IS NOT NULL");

        // conectar con la base de datos,
        // ejecutar la consulta y devolver el resultado
        SqlConnection cnConexion = new SqlConnection();
        cnConexion.ConnectionString = "Data Source=localhost;" +
            "Initial Catalog=AdventureWorksDW;" +
            "Integrated Security=True";

        SqlCommand cmdComando = new SqlCommand(sbSQL.ToString(), cnConexion);
        SqlDataAdapter daAdaptador = new SqlDataAdapter(cmdComando);
        DataSet dsDatos = new DataSet();

        cnConexion.Open();
        daAdaptador.Fill(dsDatos, "DimCustomer");
        cnConexion.Close();

        return dsDatos.Tables[0];
    }
}

Formato básico. La primera aproximación a CellFormatting

Nuestro primer ejemplo consistirá en aplicar un formato a los datos que con mayor frecuencia se prestan a realizar este tipo de acción: fechas y números; por lo que tras crear en primer lugar el manipulador de evento para CellFormatting, procederemos a dotarle de funcionalidad.

El evento CellFormatting recibe como parámetro un tipo DataGridViewCellFormattingEventArgs, cuyas propiedades serán las que nos proporcionen la información y soporte para aplicar el formato necesario en cada ocasión.

Debemos comenzar comprobando que la columna sobre la que se está produciendo el evento corresponde a aquella que necesitamos formatear, para lo que utilizaremos la propiedad DataGridViewCellFormattingEventArgs.ColumnIndex aplicada a la colección Columns del DataGridView. Una vez realizada esta verificación, con la propiedad DataGridViewCellFormattingEventArgs.CellStyle accederemos a un tipo DataGridViewCellStyle, cuyos miembros serán los que nos ofrezcan todas las posibilidades de formato, efectos de colores, alineación, etc., disponibles para adaptar la visualización del dato existente en la celda.

En este caso concreto emplearemos la propiedad DataGridViewCellFormattingEventArgs.CellStyle.Format para asignar una cadena de formato sobre las columnas BirthDate y YearlyIncome del control. Dicha cadena puede estar basada en una de las predefinidas por la plataforma .Net Framework, o ser una personalizada, construida por el programador empleando los caracteres de formato especiales disponibles a tal efecto. En el siguiente bloque de código mostramos un ejemplo de cada tipo.

public partial class frmFormatoBasico : Form
{
    public frmFormatoBasico()
    {
        InitializeComponent();
    }

    //....

    private void frmFormatoBasico_Load(object sender, EventArgs e)
    {
        this.dataGridView1.DataSource = ConstruirDatos.ObtenerTabla();
    }

    private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
    {
        // formatear fecha
        if (this.dataGridView1.Columns[e.ColumnIndex].Name == "BirthDate")
        {
            e.CellStyle.Format = "D";
        }

        // formatear valor numérico monetario
        if (this.dataGridView1.Columns[e.ColumnIndex].Name == "YearlyIncome")
        {
            e.CellStyle.Format = "#,#.0 €";
        }
    }
}

En la siguiente imagen podemos apreciar el resultado de esta operación de formato.

Aplicando colores al formato

Además de los procedimientos de formato, que como acabamos de ver, modifican la manera en que el dato es mostrado, podemos cambiar otros aspectos en la visualización de la celda tales como la combinación de colores -en estado normal y seleccionado-, alineación del contenido, etc.

Las propiedades BackColor, ForeColor, SelectionBackColor, SelectionForeColor y Alignment, de la clase DataGridViewCellStyle, nos ofrecen la posibilidad de manipular estas características, tal y como vemos en el siguiente bloque de código. Nótese que para los colores en estado seleccionado de la columna LastName, aplicamos una técnica consistente en asignar la combinación de colores normales pero en sentido inverso.

private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{
    if (this.dataGridView1.Columns[e.ColumnIndex].Name == "FirstName")
    {
        // aplicar colores a celda en estado normal
        e.CellStyle.BackColor = Color.MediumTurquoise;
        e.CellStyle.ForeColor = Color.DarkOrchid;

        // aplicar colores a celda en estado seleccionado
        e.CellStyle.SelectionBackColor = Color.DarkOliveGreen;
        e.CellStyle.SelectionForeColor = Color.Yellow;

        // establecer alineación del texto
        e.CellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
    }

    if (this.dataGridView1.Columns[e.ColumnIndex].Name == "LastName")
    {
        // aplicar colores a celda en estado normal
        e.CellStyle.BackColor = Color.MediumSeaGreen;
        e.CellStyle.ForeColor = Color.LightYellow;

        // aplicar colores a celda en estado seleccionado
        e.CellStyle.SelectionBackColor = e.CellStyle.ForeColor;
        e.CellStyle.SelectionForeColor = e.CellStyle.BackColor;

        // establecer alineación del texto
        e.CellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
    }
}

El efecto del uso de estas propiedades de estilo podemos apreciarlo en la siguiente imagen, donde vemos las celdas con los colores asignados para su estado normal y seleccionado.

El código fuente de los ejemplos puede descargarse desde los siguientes enlaces: C# y VB. Estos proyectos contienen los ejemplos al completo pertenecientes a toda esta serie de artículos.

En la siguiente entrega, más características interesantes de este evento.

Un saludo.

A continuación se acompaña una relación del conjunto de libros que he publicado, junto a una breve descripción de su contenido y una ficha editorial.

Diseño de informes con SQL Server Reporting Services

Editorial: Netalia

ISBN: 84-934895-0-6

Páginas: 208

Año de publicación: 2006

Se trata de una obra orientada a la elaboración de informes utilizando SQL Server Reporting Services. Mediante un enfoque eminentemente práctico, se dirige tanto a desarrolladores que quieran integrar informes en sus aplicaciones Web o Windows, pasando por usuarios avanzados que necesiten diseñar informes corporativos, y finalizando por el usuario final, que precisa de informes sencillos, pero que puedan ser confeccionados de forma rápida.

Desarrollo de aplicaciones Windows. Aspectos avanzados

Editorial: LaLibreriaDigital.com

ISBN: 978-84-88457-85-1

Páginas: 527

Año de publicación: 2007

Este libro se orienta hacia aquellos programadores que trabajen con la tecnología Windows Forms de la plataforma .NET Framework y necesiten profundizar en las características avanzadas de dicha tecnología.

Por tal motivo, se trata de una obra que abarca aspectos tales como la manipulación gráfica utilizando la interfaz GDI+, el desarrollo de controles personalizados, el mantenimiento y presentación de datos, la impresión de contenidos, gestión del sistema de archivos, programación asíncrona, y un largo etcétera, que permitirán ahondar en aquellas cuestiones de cierta complejidad, con las que debemos enfrentarnos en determinadas ocasiones durante la fase de desarrollo de cualquier aplicación.

Empleando Visual Studio 2005 como entorno de desarrollo de aplicaciones, a lo largo de los diferentes capítulos que componen el libro, encontraremos gran profusión de ejemplos escritos en Visual Basic y C#, que servirán como base práctica para aplicar los conocimientos adquiridos.

Desarrollo de aplicaciones Windows. Aspectos básicos

Editorial: LaLibreriaDigital.com

ISBN: 978-84-88457-84-4

Páginas: 666

Año de publicación: 2007

Este libro va dirigido a aquellas personas que quieran iniciarse en la creación de aplicaciones para entorno Windows, empleando Visual Studio 2005. Como lenguajes de programación se utilizan Visual Basic y C#.

Se trata de una obra organizada alrededor de tres bloques principales de contenidos. El primer bloque abarca los capítulos versados en la creación de proyectos sencillos, utilizando Visual Studio 2005 como herramienta de desarrollo. El segundo bloque se adentra en los dos lenguajes de programación, explicando aquellas características más importantes de cada uno. Finalmente, el tercer bloque se encuentra enfocado en el diseño e implementación de aplicaciones Windows, haciendo uso del conjunto de tipos ofrecidos por la plataforma .NET Framework al programador, así como del numeroso grupo de diseñadores y asistentes del entorno de desarrollo.

A lo largo de todo el libro, encontraremos un gran número de ejemplos prácticos que permitirán aplicar de forma inmediata todos aquellos conceptos aprendidos en los diferentes capítulos de que se compone esta obra.

Introducción a Visual Studio 2005 y .NET Framework 2.0 (*)

Editorial: LaLibreriaDigital.com

ISBN: 978-84-88457-78-3

Páginas: 313

Año de publicación: 2006

Libro que sirve como introducción a la programación en .NET Framework, y revisa los conceptos y técnicas más sobresalientes de la versión 2.0.

Incluye capítulos de carácter introductorio para aquellos lectores que, teniendo alguna experiencia en programación, no conozcan los entresijos de .NET Framework o quieran revisar los conceptos más importantes que presenta la nueva versión.

Todos los ejemplos presentados en el texto se encuentran codificados en los dos lenguajes más populares: VB.NET y C#.

SQL Server Reporting Services

Editorial: LaLibreriaDigital.com

ISBN: 84-88457-72-3

Páginas: 111

Año de publicación: 2004

Libro orientado a describir los procesos necesarios para diseñar informes con SQL Server Reporting Services.

Se cubren aspectos de diseño y programación de informes, por lo que resulta adecuado tanto para usuarios avanzados que necesiten diseñar informes corporativos, como para programadores, que precisen la integración en sus desarrollos.

Se precisan conocimientos básicos de SQL Server y del entorno de desarrollo Visual Studio .NET, siendo recomendable conocer alguno de los lenguajes principales de dicho entorno (Visual Basic .NET o C#) para la manipulación programática de un informe.

Crystal Reports para Visual Studio .NET (Visual Basic .NET)

Editorial: LaLibreriaDigital.com

ISBN: 978-84-88457-65-3

Páginas: 112

Año de publicación: 2003

Este libro introduce al lector en el diseño y generación de informes con Crystal Reports para Visual Studio .NET, utilizando como base el lenguaje Visual Basic .NET.

Se cubren tanto aspectos elementales como avanzados, de manera que el lector pueda confeccionar variados tipos de informes en función de las diversas necesidades de impresión que precisan las aplicaciones.

Como requisitos previos, se recomienda el conocimiento del lenguaje Visual Basic .NET, así como estar familiarizado con el sistema operativo Windows a nivel de usuario.

Desarrollo e implementación de aplicaciones Windows con Microsoft Visual Basic .NET y Microsoft C# .NET (*)

Editorial: LaLibreriaDigital.com

ISBN: 84-88457-62-6

Páginas: 918

Año de publicación: 2003

Se trata de un libro orientado a ilustrar acerca del desarrollo de aplicaciones para entorno Windows, basadas en la plataforma .NET Framework, utilizando Visual Basic .NET y C# .NET como lenguajes.

Se cubren tanto aspectos básicos como avanzados, abordando el lenguaje, programación orientada a objetos, el entorno de desarrollo de Visual Studio .NET, acceso a datos con ADO.NET, etc. Incluye numerosos ejemplos listos para ser utilizados en cualquiera de los dos lenguajes tratados.

Fundamentos de programación con Visual Basic .NET

Editorial: LaLibreriaDigital.com

ISBN: 84-88457-40-5

Páginas: 403

Año de publicación: 2002

Este libro enfoca el aprendizaje a la manera clásica de la asignatura de Fundamentos y Metodología de Programación, tal y como se imparte en la enseñanza reglada. La única diferencia con este enfoque es que se sustituyen lenguajes como Pascal o C, con los que habitualmente se imparte la asignatura, por Visual Basic .NET, que dispone de un entorno de desarrollo mucho más actualizado, y que servirá a quienes lean este texto en mayor medida de la que esos otros lenguajes pueden hacerlo.

De modo adicional a los aspectos fundamentales del lenguaje, se realiza una introducción a la programación orientada a objeto, y el enfoque que de la misma se efectúa desde Visual Basic .NET.

Programación en Visual Basic .NET

Editorial: LaLibreriaDigital.com

ISBN: 84-88457-53-7

Páginas: 721

Año de publicación: 2002

Se trata de un libro orientado a la enseñanza en profundidad del desarrollo de aplicaciones Windows basadas en la plataforma .NET Framework, utilizando Visual Basic .NET como lenguaje.

El texto cubre tanto aspectos básicos como avanzados, abordando el lenguaje, programación orientada a objetos (OOP), el entorno de desarrollo de aplicaciones (IDE) de Visual Studio .NET, etc.

Se trata de un manual de muy amplio contenido en documentación, además de numerosos ejemplos listos para ser utilizados desde Visual Basic .NET.

Administración de bases de datos con SQL Server 7.0

Editorial: LaLibreriaDigital.com

ISBN: 84-88457-14-6

Páginas: 343

Año de publicación: 2000

En este libro se describen las características del sistema gestor de bases de datos SQL Server 7.0, relacionadas con su instalación, mantenimiento y administración.

Entre algunos de los temas abordados, se encuentran: la propia instalación del producto, configuración de usuarios, permisos, estrategias de copia de seguridad, transferencia de datos desde y hacia bases de datos distintas de SQL Server, etc., que permitirán al lector obtener los conocimientos para realizar todas las funciones propias de un administrador de bases de datos.

Fundamentos de programación con Visual Basic 6

Editorial: LaLibreriaDigital.com

ISBN: 84-88457-07-3

Páginas: 391

Año de publicación: 2000

En este libro se enfoca el aprendizaje a la manera clásica de la asignatura de Fundamentos y Metodología de Programación, tal y como se imparte en la enseñanza reglada. La única diferencia con este enfoque es que se sustituyen lenguajes como Pascal o C, con los que habitualmente se imparte la asignatura, por Visual Basic 6, con dispone de un entorno de desarrollo más actualizado, y que servirá a quienes lean este texto en mayor medida de la que esos otros lenguajes pueden hacerlo.

Programación con Visual Basic 6

Editorial: LaLibreriaDigital.com

ISBN: 84-88457-06-5

Páginas: 815

Año de publicación: 2000

Libro orientado a enseñar en profundidad a desarrollar aplicaciones Windows basadas en el lenguaje Visual Basic. Se cubren tanto aspectos básicos como avanzados, ya que no solamente se estudian los fundamentos del lenguaje, sino que también se tratan en profundidad el acceso a datos, la programación orientada a objeto, los componentes ActiveX, el acceso a la API de Windows, etc. Se trata de un libro de muy amplio contenido con numerosos ejemplos listos para ser probados desde el entorno de desarrollo de Visual Basic.

Visual Basic 5. Técnicas y aplicaciones (*)

Editorial: RA-MA

ISBN: 84-7897-298-6

Páginas: 444

Año de publicación: 1997

Se trata de un libro que abarca aspectos relacionados con la programación en Visual Basic 5 tales como el acceso a datos con DAO y RDO, programación distribuida con Transaction Server, desarrollo de componentes ActiveX, etc.

(*) Junto a otros autores