Arquitectura y funcionalidad de ADO.

NET
Los objetivos concretos de este tutorial son los siguientes:

1. Conocer los distintos conceptos relacionados con la Arquitectura de ADO.NET.

2. Usar algunos de los diferentes proveedores de datos .NET.
3. Conocer la estructura del NameSpaces relativos a datos y XML.
4. Aprender a usar los objetos: Connection, Command, DataReader, DataSet, DataAdapter.
5. Trabajar en modo conectado y desconectado.

NOTA: Este tutorial presenta información general de mucha importancia y omite algunos detalles para poder
presentar de manera sencilla conceptos relacionados a la integración de datos de ADO.NET. En primer lugar
empezamos haciendo un breve introducción al tema;sin embargo, si usted ya conoce estos conceptos puede
revisar el ejemplo que incluyo al final de este tutorial para mostrar las diferentes utilidades de la arquitectura
ADO.NET.

• Introducción
• Acceso a datos con ADO.NET
• Espacios de nombres para datos en el .NET Framework
• El proveedor de datos .NET Framework
• Objetos provistos por distintos proveedores de datos .NET
• Dataset
Ejemplo: manipular una base de datos de manera conectada

Introducción
La mayoría de las aplicaciones escritas en Visual Basic y Visual C# giran en torno a la lectura y actualización de
información de bases de datos. Para permitir la integración de datos en aplicaciones distribuidas y escalables,
Visual Studio .NET es compatible con una nueva generación de tecnología de acceso a datos: ADO.NET.
El problema es comunicar un programa o aplicación con una base de datos y más que comunicar se pretende que
el programa o aplicación realice una serie de procesos u operaciones con la base de datos o mejor aun con el
conjunto de tablas que contiene una base de datos.
La primera nota a recordar es que una base de datos puede estar físicamente en el servidor y en algún fólder o
directorio del disco duro de dicha maquina. Otra cosilla que debemos recordar es que así como existen servidores
de paginas (Web Server), servidores de correo (Mail Server), servidores de ftp (ftp Server),..., también existen
servidores de bases de datos (DataBase Server), los más comunes son el SqlServer de Microsoft, Oracle, MySql,
y muchos más, estos servidores también pueden crear, administrar y procesar una base de datos.
El modo de comunicación entre nuestra aplicación y la base de datos implica que ambos manejen un lenguaje de
programación común, es decir no se puede mandar una instrucción en csharp .net, o en visual Basic .net o en
Basic o pascal...o en cualquier otro lenguaje, a la base de datos y además esperar que esta última la entienda.
Para entender esto, una razón muy sencilla es que la base de datos tendría que conocer o comprender todos los
lenguajes de programación, ahora dime, no sería más fácil que exista un lenguaje común...?, entonces para
resolver este problema de comunicación es que se usa un lenguaje común de bases de datos que tanto los
lenguajes de programación existentes como las bases de datos entienden, este lenguaje común de bases de
datos es el SQL (Structured Query Languaje) o lenguaje estructurado de consultas.
La pregunta es ahora como mandamos las instrucciones SQL a la base de datos, la respuesta es mediante los
OBJETOS ADO.NET, las cuales proporcionan acceso coherente a orígenes de datos como Microsoft SQL Server,
así como a orígenes de datos expuestos mediante OLE DB y XML.
En la actualidad ADO.NET ya es parte del .NET Framework, esto quiere decir que es, de alguna manera, parte del
sistema operativo y no más un redistribuible de 4 ó 5 MB que se necesita alojar junto al cliente o junto al instalador
de una aplicación. Esto significa que nosotros, como desarrolladores, estaremos enfocados más al acceco a datos
y a la lógica para manipular estos datos, y no tendremos porqué precuparnos en cómo a los clientes la librería.
La mayoría de las aplicaciones necesitan algún mecanismo de acceso a datos. Si está creando una aplicación
nueva, dispone de tres opciones excelentes para obtener acceso a los datos: ADO.NET, ADO y OLE DB. Si
necesita modificar el mecanismo de acceso a datos de una aplicación existente, debería seguir utilizando la
tecnología actual de acceso a datos de la aplicación por cuestiones de mantenimiento.
Si usted prevé que la aplicación va a tener un ciclo de vida largo, entonces debe considerar la posibilidad de
rediseñar la tecnología de acceso a datos de la aplicación y utilizar ADO.NET en aplicaciones administradas o
ADO en aplicaciones nativas. A largo plazo, el uso de las tecnologías más modernas de acceso a datos reduce el
tiempo de desarrollo, simplifica el código y proporciona un rendimiento excelente.
A continuación detallaré muchos conceptos importantes a cerca de ADO.NET.
Acceso a datos con ADO.NET
• ADO.NET es una tecnología de acceso a datos que se basa en los objetos ADO (Objetos de Datos
ActiveX) anteriores.
• Es una manera nueva de acceder a los datos construida sobre ADO. ADO.NET puede coexistir con ADO.
• También podemos decir que ADO.NET es un conjunto de clases que exponen servicios de acceso a datos
al programador de .NET.
• ADO.NET proporciona un conjunto variado de componentes para crear aplicaciones distribuidas de uso
compartido de datos. Forma parte integral de .NET Framework, y proporciona acceso a datos relacionales,
datos XML y datos de aplicaciones.
• ADO.NET es compatible con diversas necesidades de programación, incluida la creación de clientes de
bases de datos clientes y objetos empresariales de nivel medio utilizados por aplicaciones, herramientas,
lenguajes o exploradores de Internet.
• ADO.NET utiliza un modelo de acceso pensado para entornos desconectados. Esto quiere decir que la
aplicación se conecta al origen de datos, hace lo que tiene que hacer, por ejemplo seleccionar registros,
los carga en memoria y se desconecta del origen de datos.
• ADO.NET es un conjunto de clases que usted utiliza para acceder y manipular orígenes de datos como
por ejemplo, una base de datos en SQL Server o una planilla Excel.
• ADO.NET utiliza XML como el formato para transmitir datos desde y hacia su base de datos y su
aplicación Web.
• Hay 3 espacios de nombres que se importará en un formulario Web o formulario windows si esta usando
ADO.NET:
• System.Data.
• System.Data.SqlClient.
• System.Data.OleDb.
• El modelo de objetos ADO.NET provee una estructura de acceso a distintos orígenes de datos. Tiene 2
componentes principales: El Dataset y el proveedor de Datos .NET

Espacios de nombres para datos en el .NET Framework

Entre los espacios de nombres de .NET Framework relativos a datos y XML se incluyen:
System.Data

Consiste en las clases que constituyen la arquitectura ADO.NET, que es el método primario
para tener acceso a los datos de las aplicaciones administradas. La arquitectura ADO.NET
permite crear componentes que administran eficientemente datos procedentes de múltiples
orígenes. ADO.NET también proporciona las herramientas necesarias para solicitar,
actualizar y reconciliar datos en aplicaciones distribuidas.
System.Data.Common

Contiene las clases que comparten los proveedores de datos .NET Framework. Dichos
proveedores describen una colección de clases que se utiliza para obtener acceso a un
origen de datos, como una base de datos, en el espacio administrado.
System.Xml

Clases que proporcionan funcionalidad basada en estándares para procesar código XML.
System.Data.OleDb

Clases que componen el proveedor de datos de .NET Framework para orígenes de datos
compatibles con OLE DB. Estas clases permiten conectarse a un origen de datos OLE DB,
ejecutar comandos en el origen y leer los resultados.
System.Data.SqlClient

Clases que conforman el proveedor de datos de .NET Framework para SQL Server, que
permite conectarse a un origen de datos SQL Server 7.0, ejecutar comandos y leer los
resultados. El espacio de nombres System.Data.SqlClient es similar al espacio de nombres
System.Data.OleDb, pero optimizado para el acceso a SQL Server 7.0 y versiones
posteriores.
System.Data.SqlTypes
 Proporciona clases para tipos de datos nativos de SQL Server. Estas clases ofrecen una
alternativa más segura y más rápida a otros tipos de datos.
System.Data.OleDb

Clases que componen el proveedor de datos de .NET Framework para OLE DB. Estas
clases permiten el acceso a orígenes de datos ODBC en el espacio administrado.
System.Data.OracleClient

Clases que componen el proveedor de datos de .NET Framework para Oracle. Estas clases
permiten el acceso a orígenes de datos Oracle en el espacio administrado.

El proveedor de datos .NET Framework

El proveedor de datos .NET provee del enlace entre el Origen de Datos y el DataSet.
Un proveedor de datos de .NET Framework sirve para conectarse a una base de datos, ejecutar comandos y
recuperar resultados. Esos resultados se procesan directamente o se colocan en un DataSet de ADO.NET con el
fin de exponerlos al usuario para un propósito específico, junto con datos de varios orígenes, o de utilizarlos de
forma remota entre niveles. El diseño del proveedor de datos de .NET Framework hace que sea ligero, de manera
que cree un nivel mínimo entre el origen de datos y su código, con lo que aumenta el rendimiento sin sacrificar la
funcionalidad.

Proveedor de datos de .NET

Descripción
Framework
Proveedor de datos de .NET para SQL
Para Microsoft® SQL Server™ versión 7.0 o posteriores.
Server
Proveedor de datos de .NET para OLE
Para orígenes de datos que se exponen mediante OLE DB.
DB
Proveedor de datos de .NET para
Para orígenes de datos que se exponen mediante ODBC.
ODBC
Para orígenes de datos de Oracle. El proveedor de datos de .NET
Proveedor de datos de .NET para
Framework para Oracle es compatible con la versión 8.1.7 y posteriores
Oracle
del software del cliente de Oracle.

Objetos provistos por distintos proveedores de datos .NET

Los objetos Connection, Command, DataReader y DataAdapter son los elementos fundamentales del modelo de
proveedor de datos de .NET Framework. En la tabla siguiente se describen estos objetos.

Objeto SQL Objeto para un

Objeto Descripción
Server 7.0 o 2000 origen OLEDB
Establece una conexión a un origen de datos
Connection SqlConnection OleDBConnection
determinado.
Command Ejecuta un comando en un origen de datos. SqlCommand OleDBCommand
Lee una secuencia de datos de sólo avance y
DataReader OleDBDataReader OleDBConnection
sólo lectura desde un origen de datos.
Llena un DataSet y realiza las actualizaciones OleDBDataAdapt
DataAdapter SqlDataAdapter
necesarias en el origen de datos. er
La siguiente ilustración muestra los componentes principales de una aplicación ADO.NET.
La siguiente tabla resume los componentes ADO.NET que se ilustran anteriormente. Además puede revisar el
ejemplo de aplicación.
Componente u objeto
Conjunto de datos (DataSet, DataTable,
DataColumm, DataRow, DataRelation,
constraint)
Adaptador de datos
(OleDbDataAdapter,SqlDataAdapter,
OdbcDataAdapter,OracleDataAdapter,
SqlDataReader,OleDbDataReader,
OdbcDataReader,OracleDataReader)
Conexión de datos
(SqlConnection,OleDbConnection,
OdbcConnection,OracleConnection)
Formulario Windows Forms
Página de Formulario Web Forms
Detalle
Los conjuntos de datos almacenan datos en una
memoria caché desconectada. La estructura de un
conjunto de datos es similar a la de una base de
datos relacional; expone un modelo jerárquico de
tablas, filas y columnas. Además, contiene
restricciones y relaciones definidas para el conjunto
de datos.
Los adaptadores de datos son una parte integral de
los proveedores administrados por ADO.NET, que
son el conjunto de objetos que se utiliza para la
comunicación entre un origen de datos y un conjunto
de datos. Esto significa leer datos de una base de
datos para un conjunto de datos y, a continuación,
volver escribir en la base de datos los datos
modificados del conjunto de datos. Sin embargo, un
adaptador de datos puede trasladar datos entre
cualquier origen y un conjunto de datos. Por ejemplo,
podría haber un adaptador que trasladara datos entre
un servidor Microsoft Exchange y un conjunto de
datos.
Para trasladar datos entre un almacén de datos y una
aplicación, en primer lugar deberá tener una conexión
con el almacén de datos.
Windows Forms es la nueva plataforma de desarrollo
de aplicaciones para Microsoft Windows, basada en
.NET Framework. Este marco de trabajo proporciona
un conjunto de clases claro, orientado a objetos y
ampliable, que permite desarrollar complejas
aplicaciones para Windows. Además, los formularios
Windows Forms pueden actuar como interfaz de
usuario local en una solución distribuida de varios
niveles.
Las páginas de formularios Web Forms pueden
usarse para crear páginas Web programables que
sirvan como interfaz de usuario de las aplicaciones
Web. Este tipo de páginas presenta la información al
usuario en cualquier explorador o dispositivo cliente e
implementa lógica de aplicación mediante el código
de la parte servidor. La salida de las páginas de
formularios Web Forms puede contener casi cualquier
lenguaje compatible con HTTP, incluidos HTML, XML,
WML y ECMAScript (JScript, JavaScript).
Ahora trataremos algunos conceptos sobre la funcionalidad del DataSet, además veremos lo importante que es
este objeto.

Dataset
Un DataSet guarda información en un entorno desconectado. Después de que usted establece una conexión con
una Base de Datos entonces puede acceder a sus datos.
Practicamente un DataSet viene a ser una caché de memoria interna de datos recuperados de un origen de datos,
representa un componente fundamental de la arquitectura de ADO.NET. Así mismo un DataSet está compuesto
por una colección de objetos DataTable que se pueden relacionar entre ellos mediante objetos DataRelation.
También se puede imponer la integridad de los datos de DataSet mediante los objetos UniqueConstraint y
ForeignKeyConstraint.
El Dataset está formado por uno o más objetos de tipo DataTables. fue pensado para acceder a datos
independientemente del origen. Por ejemplo, un DataSet puede obtener datos de SQL Server, Oracle o de un
archivo XML. Puede utilizar un objeto llamada DataView para ver los datos de distintas maneras. Mientras que los
objetos DataTable contienen los datos, DataRelationCollection permite desplazarse por la jerarquía de la tabla.
Las tablas están incluidas en un DataTableCollection al que se obtiene acceso a través de la propiedad Tables. Al
obtener acceso a los objetos DataTable, hay que tener en cuenta que éstos distinguen entre mayúsculas y
minúsculas condicionalmente. Por ejemplo, si un objeto DataTable se denomina "mydatatable" y otro
"Mydatatable", se considerará que una cadena utilizada para buscar una de las tablas distingue entre mayúsculas
y minúsculas. Sin embargo, si existe "mydatatable" pero no existe "Mydatatable", se considerará que la cadena de
búsqueda no distingue entre mayúsculas y minúsculas. Para mejor comprensión de la importancia del DataSet,
vea el artículo Mejorando el rendimiento de la aplicación trabajando en modo desconectado en la cual se detalla
de forma clara mediante un ejemplo cómo se obtiene beneficios usando el DataSet.
Un DataSet puede leer y escribir datos y esquemas como documentos XML. Los datos y esquemas pueden
transportarse, a continuación, a través de HTTP y cualquier aplicación puede utilizarlos en cualquier plataforma
que sea compatible con XML. Los esquemas se pueden guardar como esquemas XML mediante el método
WriteXmlSchema, y tanto los esquemas como los datos se pueden guardar mediante el método WriteXml. Hay
que utilizar el método ReadXml para leer un documento XML que incluya esquema y datos.
El DataSet es la principal forma de guardar datos cuando usted utiliza ADO.NET El DataSet le permite a usted
guardar datos que se obtuvieron de un origen de datos. Los datos en un DataSet pueden ser manipulados sin
necesidad que el formulario Web mantenga la conexión con el origen de datos. La conexión se reestablece recién
cuando usted necesita actualizar los cambios.
Hay típicamente 3 pasos para acceder a los datos.
1. Acceder al Origen de Datos y mostrar los datos en el formulario Web
2. Manipular los Datos
3. Retornar los datos para actualizar la base de datos
Muchos de ustedes amigos lectores deben estar preguntando: ¿y los métodos? ¿y las propiedades? del DataSet,
para buena suerte anteriormente publiqué un artículo sobre el uso del Dataset y el DataAdapter donde explico
muchas de las propiedades y métodos del DataSet, así que visita este artículo.
Puede hacer click aquí para ver un apéndice sobre ActiveX Data Object, donde se detalla muchos de las
propiedades, métodos y eventos.

Ejemplo: manipular una base de datos de manera

conectada
Bueno hemos llegado a la parte final de este artículo. Este ejemplo que detallaré a continuación le ayudará a
comprender mejor los conceptos que expliqué anteriormente. La aplicación que implementé se basa en trabajar
con una base de datos u origen de datos de manera desconectada, donde para realizar determinadas operaciones
en el origen de datos, procederemos de la siguiente manera:
1. Nos conectamos a la base de datos y mostramos los datos en el formulario.
2. Manipulamos los Datos.
3. Finalmente retornamos los datos para actualizar la base de datos.
Por motivos de tiempo, tan sólo me limito a manejar una tabla (con 7 registros) dentro de una base de datos.
Manejaré una sóla tabla (sólo con fines de ilustrar el ejemplo, opcionalmente pueden usarse más tablas), la cual
será previamente creada en la Base de Datos northwind ,luego realizaremos algunas operaciones como por
ejemplo insertar registros en la tabla, visualizarlos, actualizar los datos, eliminar registros y modificarlos de
acuerdo a la situación.
Algo a resaltar es que este tipo de acceso a la base de datos, es decir trabajar en modo conectado, puede
consumir grande recursos sacrificando el rendimiento al mantener conexiones abiertas a la base de datos. Cada
enfoque, modo conectado o desconectado, ofrece una serie de beneficios y desventajas. La elección del enfoque
depende en gran medida de las características de la arquitectura y las plataformas que vayan a utilizarse para el
intercambio de los datos.
Expongo el código de la aplicación, la cual voy detallando paso a paso, explicando los métodos usados y cuales
son los resultados. Para entender este código usted debe tener conocimientos previos respecto al manejo de
instrucciones Transact-SQL. Espero sinceramente que sea de utilidad lo poco que estoy aportando, deseo que
comprendas muchas cosillas referente a ADO .NET, por eso incluí conceptos muy importantes las cuales debes
asimilar con cuidado. Si encuentras alguna manera de mejorar la aplicación no dudes en escribirme al correo, ya
que todos somos eternos aprendices. Bueno ahora te dejo que revises el código.
Imports System.Data
Imports System.Data.SqlClient

Module Module1
Public Estado As New Boolean
Public Reader As SqlDataReader
Public conection As New SqlConnection("data source=(local); integrated security=SSPI; initial
catalog=northwind")
End Module

Public Class Form1

Inherits System.Windows.Forms.Form
Private Sub Btnsalir_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
Btnsalir.Click
Me.Close()
End Sub
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
MyBase.Load
Try
'Nos conéctamos a la base de datos.
conection.Open()
'Creamos la tabla.
Dim comando As New SqlCommand("create table vendedores(codigo int not null primary " + _
" key identity, nombres varchar(25),apellidos varchar(25),dirección varchar(60)," + _
" e_civil char(1),sexo integer, sueldo numeric(10,2),retirado bit)", conection)
comando.ExecuteNonQuery()
'Confirmamos con un mensaje al cliente la creación de la tabla.
MsgBox("Tabla creada satisfactoriamente...")
'Nos desconectamos de la base de datos.
conection.Close()
Catch ex As Exception
'Si sucede alguna excepción, entonces nos desconectamos de todas
'maneras de la base de datos.
conection.Close()
MsgBox(ex.Message)
End Try
End Sub
 Private Sub BtnRefrescar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles BtnRefrescar.Click
Try
ListView1.Items.Clear()
'Nos conéctamos a la base de datos.
conection.Open()
'Instanciamos un objeto Command para ejecutar la instrucción sql en
'el origen de datos. Este objeto recibe dos parámetros:la instrucción
'sql y el objeto Connection para establecer la conección.
Dim Micomando As New SqlCommand("select * from vendedores", conection)
'Mediante el objeto Reader procedemos a leer los resultados de la consulta sql.
Reader = Micomando.ExecuteReader
Dim oreg As New ListViewItem
While Reader.Read = True
oreg = ListView1.Items.Add(Reader("codigo"))
oreg.SubItems.Add(Reader("nombres"))
oreg.SubItems.Add(Reader("apellidos"))
oreg.SubItems.Add(Reader("dirección"))

Select Case Reader("e_civil")

Case "C" : oreg.SubItems.Add("Casado")
Case "S" : oreg.SubItems.Add("soltero")
Case "D" : oreg.SubItems.Add("Divorciado")
Case "V" : oreg.SubItems.Add("Viudo")
End Select

Select Case Reader("sexo")

Case 1 : oreg.SubItems.Add("Masculino")
Case 0 : oreg.SubItems.Add("Femenino")
End Select

oreg.SubItems.Add(Reader("Sueldo"))

Select Case Reader("Retirado")

Case "0" : oreg.SubItems.Add("No")
Case "1" : oreg.SubItems.Add("Sí")
End Select
End While
'Nos desconéctamos de la base de datos.
conection.Close()
Reader.Close()
Catch ex As Exception
MsgBox(ex.Message)
End Try
End Sub

Private Sub BtnNuevo_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _

Handles BtnNuevo.Click
instanciar_form(True)
End Sub

Private Sub BtnModificar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _

Handles BtnModificar.Click
instanciar_form(False)
End Sub

Private Sub BtnEliminar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _

Handles BtnEliminar.Click
'Capturamos el código del registros a eliminar.
Dim cod_eliminar As String = InputBox("Por favor asegúrese de ingresar el código correcto" _
+ vbCrLf + vbCrLf + vbCrLf + "Ingrese código", "Eliminar registro", "1", Me.Width / 2, Me.Height / 2)
Dim respuesta As MsgBoxResult = MsgBox("Seguro de eliminar", MsgBoxStyle.Exclamation +
MsgBoxStyle.YesNo, "Aviso")
'En caso de confirmar la eliminación del registro, entonces...
If respuesta = MsgBoxResult.Yes Then
'...Eliminamos el registro conéctandonos al origen de datos
 Dim sql As New String("delete from vendedores where codigo=@codigo")
Dim ocmd As New SqlCommand
ocmd.Parameters.Add(New SqlParameter("@codigo", SqlDbType.Int)).Value = cod_eliminar
'Nos conéctamos a la base de datos.
conection.Open()
ocmd.CommandText = sql
ocmd.Connection = conection
ocmd.ExecuteNonQuery()
MsgBox("El registro ha sido eliminado con éxito")
conection.Close()
End If
End Sub
Sub instanciar_form(ByVal valor_estado As Boolean)
Dim oForma As New auxiliar
Estado = valor_estado
oForma.ShowDialog()
End Sub
End Class

Private Sub BtnCancelar_Click(ByVal sender As System.Object, ByVal e _

As System.EventArgs) Handles BtnCancelar.Click
Me.Close()
End Sub

Private Sub Guardar_cambios_Click(ByVal sender As System.Object, ByVal e _

As System.EventArgs) Handles BtnGuardar_cambios.Click
'guardamos los cambios realizados
Dim sqlcadena As String
sqlcadena = New String("update vendedores set nombres=@nombres,apellidos=@apellidos," + _
"dirección=@dirección,e_civil=@civil,sexo=@sexo, sueldo=@sueldo,retirado=@retirado where
codigo=@codigo")
Dim ocmd As New SqlCommand
ocmd.Parameters.Add(New SqlParameter("@codigo", SqlDbType.Int)).Value = CboCodigo.Text
ocmd.Parameters.Add(New SqlParameter("@nombres", SqlDbType.Text, 25)).Value = Txtnom.Text.ToString
ocmd.Parameters.Add(New SqlParameter("@apellidos", SqlDbType.Text, 25)).Value = Txtapel.Text.ToString
ocmd.Parameters.Add(New SqlParameter("@dirección", SqlDbType.VarChar, 60)).Value = Txtdir.Text
ocmd.Parameters.Add(New SqlParameter("@sueldo", SqlDbType.Decimal)).Value = Txtsueldo.Text
Select Case CboCivil.Text
Case Is = "Casado"
ocmd.Parameters.Add("@civil", SqlDbType.Char, 1).Value = "C"
 Case Is = "Soltero"
ocmd.Parameters.Add("@civil", SqlDbType.Char, 1).Value = "S"
Case Is = "Viudo"
ocmd.Parameters.Add("@civil", SqlDbType.Char, 1).Value = "V"
Case Is = "Divorciado"
ocmd.Parameters.Add("@civil", SqlDbType.Char, 1).Value = "D"
End Select

If CboSexo.Text = "Masculino" Then

ocmd.Parameters.Add("@sexo", SqlDbType.Int, 1).Value = 1
ElseIf CboSexo.Text = "Femenino" Then
ocmd.Parameters.Add("@sexo", SqlDbType.Int, 1).Value = 0
End If
If chkRetirado.Checked = True Then
ocmd.Parameters.Add("@retirado", SqlDbType.Bit, 1).Value = chkRetirado.Checked
ElseIf chkRetirado.Checked = False Then
ocmd.Parameters.Add("@retirado", SqlDbType.Bit, 1).Value = chkRetirado.Checked
End If
conection.Open()
ocmd.CommandText = sqlcadena
ocmd.Connection = conection
ocmd.ExecuteNonQuery()
conection.Close()
End Sub
'Este evento lo que hace es guardar los datos del nuevo registro en la base de datos
Private Sub BtnGuardar_nuevo_Click(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles BtnGuardar_nuevo.Click
Dim ocmd As New SqlCommand
Dim sqlcadena As New String("Insert into vendedores(nombres,apellidos," + _
"dirección,e_civil,sexo,sueldo,retirado) values (@nombres,@apellidos,@dirección," + _
"@e_civil,@sexo,@sueldo,@retirado)")
ocmd.Parameters.Add(New SqlParameter("@nombres", SqlDbType.Text, 25)).Value = Txtnom.Text.ToString
ocmd.Parameters.Add(New SqlParameter("@apellidos", SqlDbType.Text, 25)).Value = Txtapel.Text.ToString
ocmd.Parameters.Add(New SqlParameter("@dirección", SqlDbType.VarChar, 60)).Value = Txtdir.Text.ToString
ocmd.Parameters.Add(New SqlParameter("@sueldo", SqlDbType.Real)).Value = CDbl(Txtsueldo.Text)
Select Case CboCivil.Text
Case "Casado"
ocmd.Parameters.Add("@e_civil", SqlDbType.Char, 1).Value = "C"
Case "Soltero"
ocmd.Parameters.Add("@e_civil", SqlDbType.Char, 1).Value = "S"
Case "Viudo"
ocmd.Parameters.Add("@e_civil", SqlDbType.Char, 1).Value = "V"
Case "Divorciado"
ocmd.Parameters.Add("@e_civil", SqlDbType.Char, 1).Value = "D"
End Select
If CboSexo.Text = "Masculino" Then
ocmd.Parameters.Add("@sexo", SqlDbType.Int).Value = 1
ElseIf CboSexo.Text = "Femenino" Then
ocmd.Parameters.Add("@sexo", SqlDbType.Int).Value = 0
End If
If chkRetirado.Checked = True Then
ocmd.Parameters.Add("@retirado", SqlDbType.Bit).Value = 1
ElseIf chkRetirado.Checked = False Then
ocmd.Parameters.Add("@retirado", SqlDbType.Bit).Value = 0
End If
conection.Open()
ocmd.CommandText = sqlcadena
ocmd.Connection = conection
'el método ExecuteNonQuery() del objeto Command ejecuta una instrucción
'de Transact-SQL en la conexión y devuelve el número de filas afectadas.
ocmd.ExecuteNonQuery()
conection.Close()
End Sub

Private Sub BtnMostrar_datos_Click(ByVal sender As System.Object, ByVal e As _

System.EventArgs) Handles BtnMostrar_datos.Click
'Muestra los datos del registro tomando como parámetro el código.
 Dim sql As New String("select * from vendedores where codigo=@codigo")
Dim ocmd As New SqlCommand(sql, conection)
conection.Open()
'Haciendo uso de parámetros
ocmd.Parameters.Add("@codigo", SqlDbType.Int).Value = CboCodigo.Text
Reader = ocmd.ExecuteReader
Reader.Read()

'A continuación leemos todos los campos, excepto el campo código, del
'registro dónde el código se especificó en la instrucción Transact-SQL

'Leemos el campo "nombres"

Txtnom.Text = Reader("nombres")
'Leemos el campo "apellidos"
Txtapel.Text = Reader("apellidos")
'Leemos el campo "dirección"
Txtdir.Text = Reader("dirección")
'Leemos el campo "sueldo"
Txtsueldo.Text = Reader("sueldo")
'Leemos el campo "e_civil"
Select Case Reader("e_civil")
Case Is = "C" : CboCivil.SelectedIndex = 0
Case Is = "S" : CboCivil.SelectedIndex = 1
Case Is = "V" : CboCivil.SelectedIndex = 2
Case Is = "D" : CboCivil.SelectedItem = 3
End Select

'Leemos el campo "sexo"

Select Case Reader("sexo")
Case Is = 1 : CboSexo.SelectedIndex = 0
Case Is = 0 : CboSexo.SelectedIndex = 1
End Select
'Leemos el campo "retirado"
chkRetirado.Checked = Reader("retirado")
Reader.Close()
conection.Close()
End Sub

Private Sub auxiliar_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) _

Handles MyBase.Load
If Estado = True Then
CboCodigo.Visible = False
Label1.Visible = False
BtnMostrar_datos.Visible = False
BtnGuardar_cambios.Visible = False
Else

BtnGuardar_nuevo.Visible = False
Dim o As New SqlCommand("select * from vendedores", conection)
conection.Open()
'El método ExecuteReader() envía CommandText a Connection y crea un SqlDataReader.
Reader = o.ExecuteReader
While Reader.Read = True
'Leemos el campo "codigo" de cada uno de los registros.
CboCodigo.Items.Add(Reader("codigo"))
End While
conection.Close()
CboCodigo.SelectedIndex = 0
End If

End Sub
End Class