DataTable desde Microsoft Access en ASP .NET con C# y VB

Leer una base de datos de Microsoft Access, presentar los datos en un objeto DataTable de ASP .NET, generar por código los encabezados y las columnas y mostrar la ruta a la base de datos en una etiqueta con diseño personalizado, en C# y VB .NET

Microsoft tiene un artículo titulado «How to retrieve and display records from an Access database by using ASP.NET, ADO.NET and Visual C# .NET» para .NET Framework 1. Basado en ese artículo se presenta este ejercicio que consiste en leer una base de datos de Microsoft Access y presentar los datos en un objeto DataTable de ASP .NET. El ejercicio tiene 2 versiones: C# y VB, y una base de datos llamada Clientes.accdb con una única tabla llamada ClientesTb y 5 campos: Id, Nombre, Apellidos, Cargo y Teléfono.

Se comenta el ejercicio en C# y al final se proporciona el código completo tanto para C# como para VB .NET, las diferencias entre ambos son pequeñas.

Archivo de código C#

Se requiere la importación de varios espacios de nombres. La cadena de conexión se construye con el proveedor Microsoft.ACE.OleDb.12.0 que es el indicado para archivos .accdb y el método Server.MapPath pasando como cadena el nombre del archivo. Lo que hace Server.Mappath es devolver la ruta física en disco que se corresponde con la ruta virtual del archivo en el servidor web.

using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data.OleDb;

//variable para la cadena de conexión
string conectar = "Provider=Microsoft.ACE.OleDb.12.0;Data Source=" + Server.MapPath("Clientes.accdb");

Se pueden modificar aspectos de los controles asp:label mediante código HTML en el archivo de código C#, en ocasiones es más potente esta forma de hacerlo que directamente en las propiedades del control en el archivo .aspx aunque en este lugar también se configura alguna propiedad.

//texto de la etiqueta Titulo
Titulo.Text = "<H2>DataTable desde Microsoft Access en C#</H2>";

//propiedades del texto mostrado en Etiqueta1: color y margen entre borde y texto
//Etiqueta1.ForeColor = System.Drawing.Color.Navy;
Etiqueta1.Text = "<span style='padding:4px;display:block;'>" + conectar + "</span>";

Se generan varios objetos: conexión, cadena para pasarla como sentencia SQL, objeto de comando para manejar la sentencia SQL y lector para contener el resultado del comando mediante el método ExecuteReader. El objeto OleDbDataReader solamente lee hacia adelante y no permite modificar los datos, es un objeto de sólo lectura.

Los objetos de comando sean OleDb o Sql disponen de 3 métodos para actuar sobre los datos:

  • ExecuteReader: envía la sentencia SQL a la conexión y rellena un objeto OleDbDataReader con los registros devueltos, se usa con SELECT
  • ExecuteNonQuery: envía sentencias SQL que no devuelven datos como INSERT, UPDATE y DELETE
  • ExecuteScalar: envía sentencias SQL para obtener un valor único de la base de datos, si devuelve varios valores toma sólo el de la primera celda o columna y el resto de valores son ignorados, se usa con funciones como Count y Sum.
//crear un objeto OleDbConnection y pasarle la cadena de conexión al constructor
OleDbConnection conectarOleDb = new OleDbConnection(conectar);
//abrir la conexión
conectarOleDb.Open();
//variable para la cadena de la sentencia SQL
string cadena = "SELECT Id, Nombre, Apellidos, Cargo, Teléfono FROM ClientesTb";
//crear un objeto OleDbCommand y pasarle la cadena de conexión y OleDbConnection al constructor
OleDbCommand comando = new OleDbCommand(cadena, conectarOleDb);
//enviar el OleDbCommand a la conexión y generar un objeto OleDbDataReader que solamente lee hacia adelante
OleDbDataReader lector = comando.ExecuteReader();

Se generan los encabezados de las columnas, una por cada campo de la tabla: Id, Nombre, Apellidos, Cargo y Teléfono. Primero se crea una fila para las cabeceras. Después se crean celdas del tipo TableHeaderCell para cada columna y se van añadiendo a la fila de cabeceras. Por último se añade la fila creada al conjunto de filas de DateTable.

//nueva fila para el encabezado de la tabla
TableRow Encabezado = new TableRow();
//
//crear y añadir las celdas con el texto del encabezado de la columna Id
TableHeaderCell EncabezadoID = new TableHeaderCell();
EncabezadoID.Text = "ID";
EncabezadoID.HorizontalAlign = HorizontalAlign.Left;
Encabezado.Cells.Add(EncabezadoID);
//
//crear y añadir las celdas para el resto de encabezados Nombre, Apellidos, Cargo y Teléfono
//
//generar la fila del encabezado
Tabla1.Rows.Add(Encabezado);

Una vez constituida la fila de los encabezados, el objeto OleDbDataReader itera recorriendo los datos obtenidos desde la consulta SQL y añade los valores encontrados a la celda de las columnas. El proceso es así: en cada iteración se crea una fila nueva, se añaden las celdas correspondientes a cada columna con los valores encontrados y se añade la fila al conjunto de filas de DataTable.

El campo teléfono se muestra como 11 números sin separación entre ellos. Con el método Insert de la clase String se inserta un carácter que se especifica en la posición que se indica. Se insertan paréntesis envolviendo los 2 primeros números como si fuese el prefijo del país y se insertan espacios en blanco separando el resto de números en grupos de 3.

//por cada columna en la tabla
while (lector.Read())
{
//variable fila de DataTable
TableRow filas = new TableRow();

//añadir valores de las celdas de la columna Id
TableCell IdCelda = new TableCell();
IdCelda.Text = lector["Id"].ToString();
filas.Cells.Add(IdCelda);
//
//añadir valores de las celdas de las columnas Nombre, Apellidos y Cargo
//
//añadir valores de las celdas de la columna Teléfono
TableCell TelefonoCelda = new TableCell();
String telefono2 =  lector["Teléfono"].ToString();
//el teléfono en DataTable se muestra con este formato 00000000000 sin separar el prefijo del país
//para mejorar su aspecto se colocan los 2 primeros números entre paréntesis como prefijo
//nota: en esta tabla el prefijo es 81 que corresponde a Japón y los teléfonos son números elegidos al azar
telefono2 = telefono2.Insert(0,"(");
telefono2 = telefono2.Insert(3,")");
TelefonoCelda.Text = telefono2;
filas.Cells.Add(TelefonoCelda);
//
//añadir las filas a la tabla
Tabla1.Rows.Add(filas);

Finalmente se cierran los objetos OleDbDataReader y OleDbConnection.

lector.Close();
conectarOleDb.Close();

Aplicación desde el servidor web local

Para probar la aplicación en IIS local hay que colocar en una carpeta del servidor los archivos .aspx y .cs junto a la base de datos Clientes.accdb y dirigir el navegador hacia el archivo .aspx.

En la aplicación disponible para su descarga he incluido los archivos de código C# y VB (datatableaccess.aspx.cs y datatableaccess.aspx.vb) junto con 2 versiones del archivo .aspx (datatableaccess-cs.aspx y datatableaccess-vb.aspx) para poder probar los 2 lenguajes sin tener que modificar los archivos. La diferencia entre estos últimos está solamente en la primera línea con la directiva del lenguaje utilizado y el archivo de código al que hace referencia la directiva CodeFile:

<%@ Page Language="C#" Debug="true" AutoEventWireup="true" CodeFile="datatableaccess.aspx.cs" Inherits="datatableaccessForm" %>

<%@ Page Language="VB" Debug="true" AutoEventWireup="true" CodeFile="datatableaccess.aspx.vb" Inherits="datatableaccessForm" %>

De esta forma dirigiendo el navegador a datatableaccess-cs.aspx o a datatableaccess-vb.aspx se ejecuta la página dinámica con los 2 lenguajes aunque el resultado es idéntico en ambos.

Puedes descargar la aplicación completa desde aquí.

2 respuesta a “DataTable desde Microsoft Access en ASP .NET con C# y VB”

  1. Veo que hay una diferencia en las directivas cuando se trabaja desde Visual Studio o «a mano» como parece ser este caso. Visual Studio coloca CodeBehind dirigido al archivo de código vb o c# y en Inherits se pone el nombre de la aplicación seguido del del formulario.

  2. Efectivamente. Si llevas los archivos sueltos .aspx y .cs o .vb a la carpeta del servidor web las directivas han de ser:
    – CodeFile dirigida al archivo de código vb o c#
    – Inherits dirigida al formulario (sin el nombre de la aplicación).

    Visual Studio en cambio hace como dices, utiliza CodeBehind en vez de CodeFile e Inherits dirige al nombre de la aplicación + el nombre del formulario unidos por un punto.

Deja un comentario

Tu dirección de correo electrónico no será publicada.