ADO .NET

Ejemplo básico de acceso a datos con ADO.NET a una base de datos de Access

Con código de ejemplo para Visual Basic y C# (cualquier versión)

Publicado el 06/Ene/2006
Actualizado el 05/Feb/2006
Autor: Guillermo 'guille' Som

Introducción

Este artículo en realidad consta de varias partes, aunque todas esas partes formarán un todo, y ese todo es un ejemplo muy básico de cómo acceder a una base de datos de Access usando ADO.NET, permitiendo navegar entre los registros, añadir nuevos datos y modificar los existentes, NO he usado ningún botón de eliminar, pero eso es algo que puedes hacer fácilmente.

Lo que te voy a explicar es:

Estructura de la base de datos de ejemplo

El formulario para acceder a la base de datos

Las variables comunes para todo el código

Form_Load: Deshabilitar los controles y asignar el path de la base de datos

Conectar a la base de datos

Obtener todos los datos (o los indicados en la cadena SELECT) y guardarlos en un objeto del tipo DataTable

Añadir nuevos registros

Actualizar los registros modificados

Moverse entre registros, con comandos para ir al primero, al último, al anterior y al siguiente

Los links al código y la base de datos de ejemplo

Espero que te sea de utilidad y que esté más claro y menos "enfollonado" que el otro ejemplo que ya tenía publicado.

Nota:
A lo largo de este artículo, te muestro el código de Visual Basic, el código de C# está más abajo.

Nos vemos
Guillermo

Nota del 05/feb/2006:
Pulsa aquí para ver este mismo ejemplo para SQL Server y Visual C#.
Pulsa este otro para ver este mismo ejemplo con SQL Server y Visual Basic.
En los ejemplos de SQL Server se incluye el código a usar para eliminar registros.

Estructura de la base de datos de ejemplo

La base de datos se incluye en los links, y hay dos, una con varios datos que he hecho de prueba y otra vacía con solo la definición de la tabla de forma que puedas ver cómo manejarte cuando no hay ningún dato.

La base de datos solo tiene una tabla llamada Prueba.
La estructura de esa tabla es como sigue:

Nombre campo Tipo Comentario

ID Numérico Clave principal autonumérica

Nombre Texto 50 caracteres

e-mail Texto 128 caracteres

FechaAlta Fecha/Hora -

Comentario Memo -

El formulario para acceder a la base de datos

La aplicación de ejemplo tiene un formulario con el siguiente aspecto:

El formulario de la aplicación de ejemplo

Como vemos, este formulario utiliza los campos que tiene la tabla que vamos a usar, por tanto, si vas a usar otra tabla diferente a la usada en el ejemplo, tendrás que crear tu propio diseño del formulario. En el código he intentado separar el código que depende de los campos, de forma que te resulte fácil de modificar.

Empezando por arriba, tenemos un botón para conectarnos a la base de datos (Conectar a la base)
En ese botón se crea la conexión a la base de datos y se asigna el DataAdapter que usaremos para conectar directamente con la base de datos. Por tanto será en el código de ese botón donde tendrás que escribir el código necesario para realizar la conexión, cargar los datos en la tabla (DataTable) y empezar a mostrar los datos.
También se comprueba si la base de datos indicada existe o no.

La caja de textos que hay junto al botón "Conectar a la base" servirá para indicar el path de la base de datos, el valor inicial lo asignamos en el evento Form_Load y ahí será donde debes indicar el path en el que la has copiado, por defecto tiene el path que he usado yo.

El botón de Examinar nos permitirá localizar la base de datos, cosa que tendremos que hacer antes de pulsar en Conectar a la base.

En el GroupBox tenemos los controles para mostrar los datos, navegar entre las filas, actualiza y crear nuevos registros.
Los botones de navegación (o movimiento) nos servirán para ir a los distintos registros: Primero, anterior, siguiente y último.
El botón de Actualizar lo usaremos para actualizar los datos del registro actual.
El botón Nuevo lo usaremos para añadir un nuevo registro. Cuando pulsamos en ese botón, se usarán los datos que actualmente tengamos en las cajas de textos, salvo el ID, ya que en la tabla de ejemplo es autonumérico, y por tanto se crea solo.

El resto de controles simplemente los usamos para mostrar los datos.

Las variables comunes para todo el código

A lo largo de la aplicación usaremos algunas variables comunes, en realidad son tres:
dt del tipo DataTable, será la tabla a la que asignaremos los datos de la tabla de la base de datos
da del tipo OleDbDataAdapter, será el adaptador que nos permitirá acceder a la base de datos, para leer los datos y actualizarlos.
fila del tipo Integer, será el índice de la fila actual, con idea de saber cual será la siguiente, la anterior o la fila que queremos actualizar.

Este es el código para Visual Basic, (el de C# lo puedes ver en este link):
Private dt As DataTable
Private da As OleDbDataAdapter
Private fila As Integer
Form_Load: Deshabilitar los controles y asignar el path de la base de datos

Al empezar la aplicación, en el evento Form_Load deshabilitaremos los controles que están en el GroupBox, además asignaremos el path inicial de la base de datos, que como te he comentado antes, debes indicar el que has usado, ya que seguramente será diferente al que he usado yo.

Este es el código para Visual Basic, (el de C# lo puedes ver en este link):
Private Sub Form1_Load( _
                ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles MyBase.Load
    ' Limpiar los controles del GroupBox y
    ' deshabilitarlos hasta que se conecte a la base de datos
    '
    For Each c As Control In Me.GroupBox1.Controls
        ' Limpiar los textbox
        If TypeOf c Is TextBox Then
            c.Text = ""
        End If
        ' Deshabilitarlos
        c.Enabled = False
    Next
    Me.GroupBox1.Enabled = False
    Me.GroupBox1.Text = "Debes conectar antes de usar los datos"
    '
    ' El nombre de la base de datos:
    ' (poner el path real de la base de datos de prueba)
    Me.txtBase.Text = "E:\gsCodigo_00\VS.NET\vb y cs\acceso a datos\ejemplo_elGuille\db2000.mdb"
End Sub
Conectar a la base de datos

Para conectar con la base de datos y obtener los datos necesitamos una cadena de conexión que indique que tipo de base de datos vamos a usar y dónde está localizada (el path).
Los datos los obtendremos mediante una cadena de selección (SELECT).

En el siguiente código comprobamos también si la base de datos existe físicamente, y si no existe (o se produce un error al comprobarlo), posicionamos el cursor en la caja de textos que indica el path de la base de datos y salimos del método.
En este caso, el nombre del método se llama btnConectar_Click.

Este sería parte del código de ese evento para Visual Basic (el de C# lo tienes en este link):
' Conectar y mostrar los datos
' Comprobar si existe la bse de datos
Try
    If System.IO.File.Exists(txtBase.Text) = False Then
        MessageBox.Show("No existe la base de datos indicada")
        txtBase.Focus()
        Exit Sub
    End If
Catch ex As Exception
    MessageBox.Show("ERROR: " & ex.Message & vbCrLf & "Seguramente porque no existe la base de datos")
    txtBase.Focus()
    Exit Sub
End Try
'
' La cadena de conexión
Dim sCnn As String = "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=" & txtBase.Text
' La cadena de selección
Dim sSel As String = "SELECT * FROM Prueba ORDER BY ID"
Obtener todos los datos (o los indicados en la cadena SELECT) y guardarlos en un objeto del tipo DataTable

Una vez que sabemos que la base de datos existe, crearemos los objetos que nos permitirán acceder a la base de datos (mediante el DataAdapter), y llenaremos el objeto DataTable con los datos que hayamos indicado en la cadena de selección.

Crearemos los comandos de conexión, (por medio del OleDbCommandBuilder) y los asignaremos a los objetos correspondientes del adaptador, esto en realidad no es necesario, pero algunas veces me ha dado error al no hacerlo, así que... ¡mejor estar seguros de que se asignan!.

Debido a que la tabla de ejemplo utiliza un campo autoincremental, tendremos que asignar a la propiedad MissingSchemaAction el valor AddWithKey, de esta forma, al añadir nuevos registros se incrementará el valor del ID.

En la tabla de ejemplo, estamos usando un campo que contiene caracteres que pueden ser conflictivos, en este caso es simplemente un guión, pero podría ser una vocal acentuada, una eñe o contener espacios, en este caso lo que hacemos es indicar en el objeto del tipo CommandBuilder que utilice prefijo y sufijo para "envolver" automáticamente esos campos conflictivos, esa indicación la hacemos mediante las propiedades QuotePrefix y QuoteSufix.

Por último creamos el nuevo objeto del tipo DataTable, que será el que usemos con el método Fill del adaptador, al usar el método Fill, será cuando se conecte con la base de datos y asigne a la tabla los datos indicados en la cadena de selección (SELECT).

En este ejemplo, le indico que traiga todos los datos, pero también podría haber seleccionado con una cláusula WHERE otros diferentes. Por ejemplo, si queremos solo los datos de los registros entre dos fechas podíamos hacerlo de esta forma:
sSel = "SELECT * FROM Prueba WHERE (FechaAlta >= #2006/01/05# AND FechaAlta <= #2006/01/06#)"

Otra cosa importante que debemos tener en cuenta con el código de selección (SELECT) es que si en lugar de indicar un asterisco para que se utilicen todos los campos ( SELECT * ), indicamos solo los campos que nos interesan, en las actualizaciones y lecturas de datos solo podremos incluir los campos indicados.
Por ejemplo, si hacemos: SELECT ID, Nombre FROM Prueba, tan solo tendremos acceso a esos dos campos, y cualquier intento de acceder a otros campos (aunque sean válidos y existan en la tabla) dará error.

Finalmente habilitamos nuevamente los controles que están en el GroupBox para que podamos navegar, añadir, actualizar y escribir en las cajas de texto.

También comprobamos si hay datos, y en caso de que haya mostramos el primer registro, para ello usamos el método del evento Click del botón de ir al primero. Si no hay datos, deshabilitamos el botón de Actualizar.
También podríamos haber deshabilitado los botones de movimiento, pero... eso te lo dejo para que lo hagas tú, como pista para volver a habilitarlos, decirte que cuando añadas uno nuevo, ya deberían estar habilitados... o casi.

Este es el código para Visual Basic, (el de C# lo tienes en este link):
' Comprobar si hay algún error
Try
    ' Crear un nuevo objeto del tipo DataAdapter
    da = New OleDbDataAdapter(sSel, sCnn)
    ' Crear los comandos de insertar, actualizar y eliminar
    Dim cb As New OleDbCommandBuilder(da)
    ' Como hay campos con caracteres especiales,
    ' al usarlos incluirlos entre corchetes.
    cb.QuotePrefix = "["
    cb.QuoteSuffix = "]"
    ' Asignar los comandos al DataAdapter
    ' (se supone que lo hace automáticamente, pero...)
    da.UpdateCommand = cb.GetUpdateCommand
    da.InsertCommand = cb.GetInsertCommand
    da.DeleteCommand = cb.GetDeleteCommand
    '
    ' Esta base de datos usa el ID con valores automáticos
    da.MissingSchemaAction = MissingSchemaAction.AddWithKey
    '
    dt = New DataTable
    ' Llenar la tabla con los datos indicados
    da.Fill(dt)
    '
    ' Habilitar los controles
    For Each c As Control In Me.GroupBox1.Controls
        c.Enabled = True
    Next
    Me.GroupBox1.Enabled = True
    Me.GroupBox1.Text = "Conexión realizada"

    ' Y mostrar el primer registro
    If dt.Rows.Count > 0 Then
        btnFirst_Click(Nothing, Nothing)
    Else
        fila = -1
        btnActualizar.Enabled = False
    End If
Catch ex As Exception
    MessageBox.Show("ERROR al conectar o recuperar los datos:" & vbCrLf & _
                    ex.Message, "Conectar con la base", _
                    MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
Añadir nuevos registros

Para añadir nuevos registros, lo primero que tenemos que hacer es crear una nueva fila.
Para ello utilizamos el método NewRow del objeto DataTable.

Al usar ese método, nos aseguramos que la nueva fila creada tiene todos los datos sobre la estructura de la tabla (o de la selección que hemos hecho), de forma que podamos asignar los campos, etc.

La asignación de los campos la hacemos mediante el método asignarDatos, aunque podríamos haberlo hecho directamente.
El hacerlo mediante ese método es para que nos resulte más cómo adaptar este ejemplo a otra tabla diferente a la que yo propongo, ya que en ese método haríamos todas las asignaciones que debamos hacer, salvo la del campo ID ya que al ser autonumérico no podemos asignarle un valor, porque ese valor lo asignará automáticamente ADO.NET.

Una vez que la fila tiene asignados los valores de los campos, la añadimos a las fila de la tabla. Esto es necesario, ya que el método NewRow solo crea una fila, pero no la "relaciona" (o añade) a la tabla actual.

Finalmente actualizamos los datos mediante el método Update del adaptador.
En realidad no hace falta hacer esa actualización en este preciso momento, pero si no lo hacemos, debemos añadir otro botón para que los datos se asignen a la base de datos, ya que al añadir un nuevo valor a la tabla, lo haremos en la "copia" que tenemos localmente en memoria, y no directamente en la base de datos, como ocurría, por ejemplo, con VB6 y los Recordsets.

Una vez actualizados los datos en la base de datos, le indicamos a la tabla que acepte los cambios que hayamos hecho, de forma que quede sincronizada nuevamente.
Esto es necesario, ya que si no lo hacemos, la tabla mantendrá los cambios que hayamos hecho y si nuevamente "sincronizamos" esos datos con la base real, se podrían producir errores.

Es importante que sepamos que cuando llamamos al método Update del adaptador, se realizan todas las actualizaciones, es decir, no solo añadir nuevos datos, como "se supone" que es lo que hace este método, sino que si hubiésemos eliminado filas, o modificado algunas, esas modificaciones también se reflejarían en la base de datos.

Debido a cómo funcionan los campos autincrementales, para asegurarnos de que en realidad el valor de ese ID se actualiza correctamente, si es el primer registro que añadimos (o vale cero, como es la comprobación que hacemos aquí), deberíamos volver a leer los datos reales de la base de datos (que será después de haber añadido el primer registro) con idea de que ese ID tenga el valor correcto. Esto no es necesario en los siguientes datos que vayamos añadiendo, ya que en otros casos el valor del ID se asignará correctamente.

Como ves, también controlamos los errores que se puedan producir... ¡nunca está de más!

Este código es para Visual Basic, (el de C# lo tienes en este link):
Private Sub btnNuevo_Click( _
                ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles btnNuevo.Click
    ' Crear un nuevo registro
    Dim dr As DataRow = dt.NewRow()
    ' Asignar los datos de los textbox a la fila
    asignarDatos(dr)
    ' Añadir la nueva fila a la tabla
    dt.Rows.Add(dr)
    ' Guardar físicamente los datos en la base
    Try
        da.Update(dt)
        dt.AcceptChanges()
        ' Si es el primer registro de la base,
        ' volver a leer los datos para actualizar los IDs
        If CInt("0" & dr("ID").ToString) = 0 Then
            dt = New DataTable
            da.Fill(dt)
        End If
        ' Posicionarlo en la última fila
        btnLast_Click(Nothing, Nothing)
    Catch ex As DBConcurrencyException
        MessageBox.Show("Error de concurrencia:" & vbCrLf & ex.Message)
    Catch ex As Exception
        MessageBox.Show(ex.Message)
    End Try
End Sub
Private Sub asignarDatos(ByVal dr As DataRow)
    ' Usar los datos que hay en los textbox
    dr("Nombre") = txtNombre.Text
    dr("e-mail") = txtEmail.Text
    dr("FechaAlta") = txtFechaAlta.Text
    dr("Comentario") = txtComentario.Text
End Sub
Actualizar los registros modificados

La actualización de los datos, es decir, cuando modificamos un registro (o fila) y queremos que esos datos se guarden, es muy simple. En el código del método de actualizar, primero comprobamos que el valor de la variable fila sea válido, es decir, esté dentro del rango de filas que tiene el DataTable.

Si es así, asignamos a una variable del tipo DataRow la fila en cuestión y posteriormente llamamos al método asignarDatos que vimos antes, que como sabes es el que se encarga de asignar las cajas de texto a los campos correspondientes.

Una vez que la fila tiene los nuevos datos, volvemos a llamar al método Update del adaptador, como comenté antes, esta llamada al método Update solo es necesario si queremos asignar directamente los datos en la base, es decir, hacer que los cambios se hagan en ese preciso momento.

También encerramos esa actualización dentro de un Try/Catch para detectar los errores que se puedan producir.

Este es el código para Visual Basic, (el de C# lo tienes en este link):
Private Sub btnActualizar_Click( _
                ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles btnActualizar.Click
    ' Actualizar los datos en la fila actual
    If fila < 0 OrElse fila > dt.Rows.Count - 1 Then Exit Sub

    Dim dr As DataRow = dt.Rows(fila)
    ' Asignar los datos de los textbox a la fila
    asignarDatos(dr)
    ' Guardar físicamente los datos en la base
    Try
        da.Update(dt)
        dt.AcceptChanges()
    Catch ex As DBConcurrencyException
        MessageBox.Show("Error de concurrencia:" & vbCrLf & ex.Message)
    Catch ex As Exception
        MessageBox.Show(ex.Message)
    End Try
End Sub
Moverse entre registros, con comandos para ir al primero, al último, al anterior y al siguiente

Para movernos entre los registros usaremos cuatro métodos, uno para ir al principio, otro para ir al final, otro para ir al registro anterior y otro para el siguiente.

En estos cuatro métodos usaremos un método extra que será el que se encargue de comprobar si todo está correcto (o casi) y de mostrar los datos adecuados en cada caja de texto. Al igual que antes con el método asignarDatos, lo he puesto por separado, entre otras cosas para facilitar la modificación del código para otras tablas.

También para que no haya que estar repitiendo en el resto de los métodos las comprobaciones de que el valor de fila indicado está dentro del rango válido. Ese rango debe estar entre cero para el primer registro y uno menos del número total de filas para el último, por tanto, si el valor del número de la fila indicado no es correcto, no hacemos nada, simplemente salimos del método.

En caso de que sigamos, quiere decir que es un valor correcto, por tanto leemos esa fila (asignándola a una variable de tipo DataRow) y asignamos los valores a las cajas de texto, en este caso si que usamos el valor del campo ID con idea de que veamos ese valor.

Por último habilitamos el botón de actualizar, ya que se supone que hay datos.

El código mostrado es para Visual Basic, (el de C# lo tienes en este link):
Private Sub mostrarDatos(ByVal f As Integer)
    Dim uf As Integer = dt.Rows.Count - 1
    If f < 0 OrElse uf < 0 Then Exit Sub
    '
    Dim dr As DataRow = dt.Rows(f)
    txtID.Text = dr("ID").ToString
    txtNombre.Text = dr("Nombre").ToString
    txtEmail.Text = dr("e-mail").ToString
    txtFechaAlta.Text = dr("FechaAlta").ToString
    txtComentario.Text = dr("Comentario").ToString
    '
    btnActualizar.Enabled = True
End Sub
Los cuatro métodos para movernos son los siguientes, veamos que es lo que hacemos en cada uno de ellos, aunque creo que viendo el código queda clara la intención.

Nota:
Como veremos en el código, en realidad no hace falta pasarle ningún parámetro al método mostrarDatos, ya que al tener la variable fila disponible en todo el formulario, pues podríamos usar esa variable, pero... lo dejo así por si se te ocurre hacer cambios y no usar esa variable, que hay gente que no le gusta usar variables "globales" al formulario o clase...

Para ir al primero, simplemente asignamos cero a la variable de la fila actual y llamamos al método de mostrar los datos.
Private Sub btnFirst_Click( _
                ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles btnFirst.Click
    ' Posicionarse en la primera fila
    fila = 0
    ' Mostrar los datos de la fila indicada
    mostrarDatos(fila)
End Sub
Para ir al último, averiguamos cual es la última fila, que como vemos es el valor devuelto por la propiedad Count de la colección de filas (Rows), menos uno, ya que como sabemos todos los arrays y colecciones de .NET siempre empiezan con el índice cero.
Private Sub btnLast_Click( _
                ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles btnLast.Click
    ' Posicionarse en la última fila
    fila = dt.Rows.Count - 1
    ' Mostrar los datos de la fila indicada
    mostrarDatos(fila)
End Sub
Para ir al anterior simplemente le restamos uno al valor de la fila actual, pero debemos hacer una comprobación de que no sea menor de cero, ya que es posible que estemos en el primer registro y pulsemos en el botón de ir al anterior. En caso de que estemos en el primero, seguiremos en ese mismo registro.
Private Sub btnPrev_Click( _
                ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles btnPrev.Click
    ' Posicionarse en la fila anterior
    fila = fila - 1
    If fila < 0 Then fila = 0
    ' Mostrar los datos de la fila indicada
    mostrarDatos(fila)
End Sub
Por último, para ir al siguiente, hacemos lo mismo que antes, pero en lugar de restar uno, lo que hacemos es añadir uno al valor de la fila actual, y en el caso de que sea mayor que la última fila, pues nos quedamos en esa última fila.
Private Sub btnNext_Click( _
                ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles btnNext.Click
    ' Posicionarse en la fila siguiente
    Dim uf As Integer = dt.Rows.Count - 1
    fila = fila + 1
    If fila > uf Then fila = uf
    ' Mostrar los datos de la fila indicada
    mostrarDatos(fila)
End Sub
Los links al código y la base de datos de ejemplo

Aquí tienes los links al código de ejemplo, tanto para Visual Basic como para C#. Los proyectos están creados con Visual Studio 2003, pero funcionarán igualmente en la versión 2005.

También tienes las bases de datos de ejemplo, hay dos:
db2000.mdb que tiene algunos registros y db2000_vacia.mdb que no tiene registros.
De la base de datos vacía deberías hacer una copia por si haces pruebas y quieres volver a dejarla en blanco, para comprobar cosas cuando no hay datos.

El código y las bases: ejemplo_access_adonet.zip - 38.2 KB

(MD5 checksum: EB202A5A9C404BF6DAC86651C7ACDED3)

El código de ejemplo para C#

Las variables comunes para todo el código
private DataTable dt;
private OleDbDataAdapter da;
private int fila;
Form_Load: Deshabilitar los controles y asignar el path de la base de datos
private void Form1_Load(System.Object sender, System.EventArgs e) 
{
    // Limpiar los controles del GroupBox y
    // deshabilitarlos hasta que se conecte a la base de datos
    //
    foreach(Control c in this.GroupBox1.Controls)
    {
        // Limpiar los textbox
        if( c is TextBox )
        {
            c.Text = "";
        }
        // Deshabilitarlos
        c.Enabled = false;
    }
    this.GroupBox1.Enabled = false;
    this.GroupBox1.Text = "Debes conectar antes de usar los datos";
    //
    // El nombre de la base de datos:
    // (poner el path real de la base de datos de prueba)
    this.txtBase.Text = @"E:\gsCodigo_00\VS.NET\vb y cs\acceso a datos\ejemplo_elGuille\db2000.mdb";
}
Conectar a la base de datos
// Conectar y mostrar los datos
// Comprobar si existe la bse de datos
try
{
    if( System.IO.File.Exists(txtBase.Text) == false )
    {
        MessageBox.Show("No existe la base de datos indicada");
        txtBase.Focus();
        return;
    }
}
catch(Exception ex)
{
    MessageBox.Show("ERROR: " + ex.Message + "\nSeguramente porque no existe la base de datos indicada");
    txtBase.Focus();
    return;
}
//
// La cadena de conexión
string sCnn = "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=" + txtBase.Text;
// La cadena de selección
string sSel = "SELECT * FROM Prueba ORDER BY ID";
// Para traer solo los registros entre dos fechas
// sSel = "SELECT * FROM Prueba WHERE (FechaAlta >= #2006/01/05# AND FechaAlta <= #2006/01/06#)";
Obtener todos los datos (o los indicados en la cadena SELECT) y guardarlos en un objeto del tipo DataTable
// Comprobar si hay algún error
try
{
    // Crear un nuevo objeto del tipo DataAdapter
    //Dim cnn As New OleDbConnection(sCnn)
    da = new OleDbDataAdapter(sSel, sCnn);
    // Crear los comandos de insertar, actualizar y eliminar
    OleDbCommandBuilder cb = new OleDbCommandBuilder(da);
    // Como hay campos con caracteres especiales,
    // al usarlos incluirlos entre corchetes.
    cb.QuotePrefix = "[";
    cb.QuoteSuffix = "]";
    // Asignar los comandos al DataAdapter
    // (se supone que lo hace automáticamente, pero...)
    da.UpdateCommand = cb.GetUpdateCommand();
    da.InsertCommand = cb.GetInsertCommand();
    da.DeleteCommand = cb.GetDeleteCommand();
    //
    // Esta base de datos usa el ID con valores automáticos
    da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
    //
    dt = new DataTable();
    // Llenar la tabla con los datos indicados
    da.Fill(dt);
    //
    // Habilitar los controles
    foreach(Control c in this.GroupBox1.Controls)
    {
        c.Enabled = true;
    }
    this.GroupBox1.Enabled = true;
    this.GroupBox1.Text = "Conexión realizada";
 
    // Y mostrar el primer registro
    if( dt.Rows.Count > 0 )
    {
        btnFirst_Click(null, null);
    }
    else
    {
        fila = -1;
        btnActualizar.Enabled = false;
    }
}
catch(Exception ex)
{
    MessageBox.Show("ERROR al conectar o recuperar los datos:\n" + ex.Message, 
                    "Conectar con la base", 
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
}
Añadir nuevos registros
private void btnNuevo_Click(System.Object sender, System.EventArgs e) 
{
    // Crear un nuevo registro
    DataRow dr = dt.NewRow();
    // Asignar los datos de los textbox a la fila
    asignarDatos(dr);
    // Añadir la nueva fila a la tabla
    dt.Rows.Add(dr);
    // Guardar físicamente los datos en la base
    try
    {
        da.Update(dt);
        dt.AcceptChanges();
        // Si es el primer registro de la base,
        // volver a leer los datos para actualizar los IDs
        if( Convert.ToInt32("0" + dr["ID"].ToString()) == 0 )
        {
            dt = new DataTable();
            da.Fill(dt);
        }
        // Posicionarlo en la última fila
        btnLast_Click(null, null);
    }
    catch(DBConcurrencyException ex)
    {
        MessageBox.Show("Error de concurrencia:\n" + ex.Message);
    }
    catch(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}
private void asignarDatos(DataRow dr) 
{
    // Usar los datos que hay en los textbox
    dr["Nombre"] = txtNombre.Text;
    dr["e-mail"] = txtEmail.Text;
    dr["FechaAlta"] = txtFechaAlta.Text;
    dr["Comentario"] = txtComentario.Text;
}
Actualizar los registros modificados
private void btnActualizar_Click(System.Object sender, System.EventArgs e)
{
    // Actualizar los datos en la fila actual
    if( fila < 0 || fila > dt.Rows.Count - 1 ) return;
 
    DataRow dr = dt.Rows[fila];
    // Asignar los datos de los textbox a la fila
    asignarDatos(dr);
    // Guardar físicamente los datos en la base
    try
    {
        da.Update(dt);
        dt.AcceptChanges();
    }
    catch(DBConcurrencyException ex)
    {
        MessageBox.Show("Error de concurrencia:\n" + ex.Message);
    }
    catch(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}
Moverse entre registros, con comandos para ir al primero, al último, al anterior y al siguiente
private void mostrarDatos(int f)
{
    int uf = dt.Rows.Count - 1;
    if( f < 0 || uf < 0 ) return;
    //
    DataRow dr = dt.Rows[f];
    txtID.Text = dr["ID"].ToString();
    txtNombre.Text = dr["Nombre"].ToString();
    txtEmail.Text = dr["e-mail"].ToString();
    txtFechaAlta.Text = dr["FechaAlta"].ToString();
    txtComentario.Text = dr["Comentario"].ToString();
    //
    btnActualizar.Enabled = true;
}
private void btnFirst_Click(System.Object sender, System.EventArgs e)
{
    // Posicionarse en la primera fila
    fila = 0;
    // Mostrar los datos de la fila indicada
    mostrarDatos(fila);
}  
 
private void btnPrev_Click(System.Object sender, System.EventArgs e) 
{
    // Posicionarse en la fila anterior
    fila = fila - 1;
    if( fila < 0 ) fila = 0;
    // Mostrar los datos de la fila indicada
    mostrarDatos(fila);
}  
 
private void btnNext_Click(System.Object sender, System.EventArgs e) 
{
    // Posicionarse en la fila siguiente
    int uf = dt.Rows.Count - 1;
    fila = fila + 1;
    if( fila > uf ) fila = uf;
    // Mostrar los datos de la fila indicada
    mostrarDatos(fila);
}  
 
private void btnLast_Click(System.Object sender, System.EventArgs e) 
{
    // Posicionarse en la última fila
    fila = dt.Rows.Count - 1;
    // Mostrar los datos de la fila indicada
    mostrarDatos(fila);
}

Nombre campo	Tipo	Comentario
ID	Numérico	Clave principal autonumérica
Nombre	Texto	50 caracteres
e-mail	Texto	128 caracteres
FechaAlta	Fecha/Hora	-
Comentario	Memo	-

Ejemplo básico de acceso a datos con ADO.NET a una base de datos de Access

Con código de ejemplo para Visual Basic y C# (cualquier versión)

Publicado el 06/Ene/2006Actualizado el 05/Feb/2006Autor: Guillermo 'guille' Som

Introducción

El código de ejemplo para C#

Publicado el 06/Ene/2006
Actualizado el 05/Feb/2006
Autor: Guillermo 'guille' Som