ACCESO DESCONECTADO TEMA 02

Vista previa del material en texto

Acceso a datos con Microsoft ADO.NET 1 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Docente: 
M.A. Alex Pacheco Moya 
S3 
ACCESO DESCONECTADO 
CONTENIDO 
 
• DataSets 
• DataAdapter 
• Control Enlazado 
2 Acceso a datos con Microsoft ADO.NET 
 
 
◼ Crear un DataAdapter 
◼ Crear un DataSet 
◼ Demostración: utilizar programáticamente un DataSet 
◼ Utilizar un DataView 
◼ Práctica: organizar código para crear un DataSet 
◼ Vincular un DataSet a un control enlazado a lista 
◼ Práctica dirigida por el instructor: visualizar un 
DataSet 
◼ Gestión de errores 
 
Lección: acceso a datos con DataSets 
 
 
 
Introducción 
 
 
 
 
 
 
 
 
 
 
Objetivos de la lección 
El objeto DataSet representa una copia local de los datos que provienen de una 
o más fuentes de datos. El uso de un objeto DataSet permite que un formulario 
Web Form se ejecute de forma semi-independiente de las fuentes de datos. El 
objeto DataSet puede utilizar un objeto DataAdapter para cargar los datos de 
una fuente de datos y puede desconectarse de la misma. El usuario puede 
entonces utilizar y manipular los datos. Cuando los datos necesitan ser 
actualizados contra la fuente de datos, se utiliza un objeto DataAdapter para 
volver a conectarse y actualizar la fuente de datos. 
En esta lección, estudiaremos cómo utilizar los objetos DataSet para soportar el 
almacenamiento local de datos y los requerimientos de manipulación de los 
formularios Web Forms. 
En esta lección, aprenderemos a: 
◼ Crear un objeto DataAdapter para enlazar un objeto DataSet a una fuente 
de datos. 
◼ Crear un objeto DataSet para guardar datos de una fuente de datos. 
◼ Utilizar objetos DataView para guardar un subconjunto de datos de un 
objeto DataSet. 
◼ Vincular un objeto DataSet y un objeto DataView a un control enlazado a 
lista. 
◼ Gestionar los errores típicos que nos encontramos en el acceso a datos. 
Acceso a datos con Microsoft ADO.NET 3 
 
Dim da As New SqlDataAdapter _ 
("select from Authors", conn) 
da.SelectCommand.CommandText 
da.SelectCommand.Connection 
SqlDataAdapter da = new SqlDataAdapter 
("select from Authors",conn); 
da.SelectCommand.CommandText; 
da.SelectCommand.Connection; 
◼ Almacenar la consulta en un DataAdapter 
Dim da As New SqlDataAdapter _ 
("select from Authors", conn) 
◼ El constructor DataAdapter establece la propiedad 
SelectCommand 
◼ Establecer las propiedades InsertCommand, 
UpdateCommand y DeleteCommand si fuera necesario 
da.SelectCommand.CommandText; 
da.SelectCommand.Connection; 
da.SelectCommand.CommandText 
da.SelectCommand.Connection 
SqlDataAdapter da = new SqlDataAdapter 
("select from Authors",conn); 
 
Crear un DataAdapter 
 
 
 
Introducción 
 
 
 
 
 
 
DataAdapter 
El objeto DataSet representa una copia local de datos de una fuente de datos. 
Cuando se utiliza sin una fuente de datos, el objeto DataSet resulta útil para 
guardar datos locales a los cuales pueden acceder los formularios Web Forms. 
Sin embargo, para actuar como una herramienta de gestión de datos real, un 
objeto DataSet debe poder interactuar con una o más fuentes de datos. Para 
conseguir esta interacción, el .NET Framework proporciona las clases 
SqlDataAdapter y OleDbDataAdapter. 
Un objeto DataAdapter actúa como enlace entre un objeto DataSet y una 
fuente de datos que puede utilizarse para recuperar y guardar datos. La clase 
DataAdapter representa un conjunto de comandos de base de datos y una 
conexión a una base de datos que utilizamos para rellenar un objeto DataSet y 
actualizar la fuente de datos. Cada objeto DataAdapter intercambia datos entre 
un único objeto DataTable en un objeto DataSet y un único conjunto de 
resultados de una instrucción SQL o un procedimiento almacenado. 
Visual Studio .NET pone a disposición dos clases principales DataAdapter 
para su uso con bases de datos: 
◼ Clase OleDbDataAdapter 
Esta clase es adecuada para utilizarse con cualquier fuente de datos expuesta 
por un OLE DB Data Provider. 
◼ Clase SqlDataAdapter 
Esta clase es específica para una base de datos SQL Server versión 7.0 o 
posterior. El objeto SqlDataAdapter es más rápido que el objeto 
OleDbDataAdapter porque funciona directamente con SQL Server y no 
debe funcionar a través de una capa OLE DB Data Provider. 
 
Además, las clases DataAdapter para otros tipos de fuentes de datos pueden 
integrarse con Visual Studio .NET. 
4 Acceso a datos con Microsoft ADO.NET 
 
 
Propiedades del 
DataAdapter 
Cuando utilizamos objetos DataAdapter para intercambiar datos entre un 
objeto DataSet y una fuente de datos, podemos especificar las acciones que 
deseamos realizar utilizando una de las cuatro propiedades DataAdapter. Las 
propiedades DataAdapter ejecutan una instrucción SQL o invocan un 
procedimiento almacenado. 
Las propiedades que están disponibles con la clase DataAdapter se muestran 
en la siguiente tabla. 
Propiedad Función 
SelectCommand 
InsertCommand 
UpdateCommand 
DeleteCommand 
La propiedad SelectCommand recupera filas de la fuente de 
datos. 
La propiedad InsertCommand escribe filas insertadas del 
DataSet a la fuente de datos. 
La propiedad UpdateCommand escribe filas modificadas del 
DataSet a la fuente de datos. 
La propiedad DeleteCommand elimina filas en la fuente de 
datos. 
Ejemplo de 
SqlDataAdapter 
Visual Basic .NET 
 
 
 
 
 
 
 
C# 
El siguiente código de ejemplo muestra cómo crear un objeto SqlDataAdapter 
denominado da que contiene una sentencia de consulta: 
 
'Create a connection 
Dim conn As New SqlConnection _ 
("data source=localhost;initial catalog=pubs;" & _ 
"integrated security=true;persist security info=True;") 
 
'Create the DataAdapter 
Dim da As New SqlDataAdapter _ 
("select from Authors", conn) 
 
//Create a connection 
SqlConnection conn = new SqlConnection 
("data source=localhost; initial catalog=pubs; " + 
"integrated security=true; persist security info=True;"); 
 
//Create the DataAdapter 
SqlDataAdapter da = new SqlDataAdapter 
("select from Authors", conn); 
Acceso a datos con Microsoft ADO.NET 5 
 
Dim ds As New DataSet() 
da.Fill(ds, "Authors") 
Dim r As DataRow 
Dim str As String 
For Each r in _ 
ds.Tables("Authors").Rows 
str &= r(2) 
str &= r("au_lname") 
Next 
ds.Tables("Authors").Rows.Count 
DataSet ds = new DataSet(); 
da.Fill(ds, "Authors"); 
ds.Tables["Authors"].Rows.Count; 
string str=""; 
 
foreach(DataRow r in 
ds.Tables["Authors"].Rows) 
{ 
str += r[2]; 
str += r["au_lname"]; 
} 
◼ Crear y poblar un DataSet con DataTables 
 El método Fill ejecuta el SelectCommand 
◼ Acceder a DataTable 
ds.Tables("Authors").Rows.Count ds.Tables["Authors"].Rows.Count; 
Dim ds As New DataSet() 
da.Fill(ds, "Authors") 
DataSet ds = new DataSet(); 
da.Fill(ds, "Authors"); 
 
Dim r As DataRow 
Dim str As String 
For Each r in _ 
ds.Tables("Authors").Rows 
str &= r(2) 
str &= r("au_lname") 
Next 
string str=""; 
 
foreach(DataRow r in 
ds.Tables["Authors"].Rows) 
{ 
str += r[2]; 
str += r["au_lname"]; 
} 
 
Crear un DataSet 
 
 
 
Introducción 
 
Crear a DataSet 
 
Visual Basic .NET 
C# 
Rellenar el DataSet 
 
 
 
 
Visual Basic .NET 
 
C# 
Para crear una copia local de una base de datos, creamos y poblamos un objeto 
DataSet utilizando objetos DataTable. 
El primer paso para crear un objeto DataSet es declarar el nombre del objeto 
DataSet. El siguiente código crea un objeto DataSet denominado ds: 
 
Dim ds As New DataSet() 
DataSet ds = new DataSet(); 
Tras crear un objeto DataSet, rellenamos los objetos DataTable creando un 
objeto DataAdapter. Invocamos el método Fill en el objeto DataAdapter y 
especificamos el objeto DataTable que deseamos rellenar. El siguiente código 
rellena la tabla Authors del objeto DataSet ds utilizando un DataAdapter 
denominado da: 
 
da.Fill(ds, "Authors") 
 
da.Fill(ds,"Authors"); 
 
El método Fill ejecuta implícitamente una consulta SQL en la propiedad 
SelectCommand del objeto DataAdapter. Los resultados de la consulta SQL se 
utilizan para definir la estructura del objeto DataTable, y para poblar la tabla 
con datos. 
6 Acceso a datos con Microsoft ADO.NET 
 
 
 
 
 
Visual Basic .NET 
El siguiente código de ejemplo muestra cómo crear un objeto SqlDataAdapter 
da, e invocar a continuación el método Fill para almacenar los datos en el 
objeto DataSet ds. 
 
'Create a connection 
Dim conn As New SqlConnection _ 
("data source=localhost;initial catalog=pubs;" & _ 
"integrated security=SSPI;persist security info=True;") 
 
'Create the DataSet 
Dim ds As New DataSet() 
 
'Create the DataAdapter 
Dim da As New SqlDataAdapter _ 
("select from Authors", conn) 
 
'Fill the DataSet ds 
da.Fill(ds, "Authors") 
C# //Create a connection 
SqlConnection conn = new SqlConnection 
("data source=localhost;initial catalog=pubs; " + 
"integrated security=SSPI;persist security info=True;"); 
 
//Create the DataSet 
DataSet ds = new DataSet(); 
 
//Create the DataAdapter 
SqlDataAdapter da = new SqlDataAdapter 
("select from Authors", conn); 
 
//Fill the DataSet ds 
da.Fill(ds, "Authors"); 
 
 
 
Acceder a DataTable 
 
 
 
Visual Basic .NET 
 
 
C# 
El segundo argumento del método Fill es un nombre para el objeto DataTable 
que está creado. Utilizamos este nombre para acceder a los datos devueltos. 
Una vez insertados los datos en un objeto DataSet, podemos acceder 
programáticamente a los datos. Como muestra el siguiente código, cada objeto 
DataSet está formado por uno o más objetos DataTable a los que podemos 
hacer referencia por su nombre o posición ordinal: 
 
ds.Tables("Authors") 
-o- 
ds.Tables(0) 
 
ds.Tables["Authors"]; 
-o- 
ds.Tables[0]; 
Acceso a datos con Microsoft ADO.NET 7 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Visual Basic .NET 
 
 
 
C# 
Las clases DataRow y DataColumn son los componentes principales de una 
clase DataTable. Utilizaríamos un objeto DataRow con sus propiedades y 
métodos para recuperar y evaluar los valores de un objeto DataTable. 
DataRowCollection representa los objetos DataRow reales que se encuentran 
en el objeto DataTable, y DataColumnCollection contiene los objetos 
DataColumn que describen el esquema del objeto DataTable. La propiedad 
Rows del objeto DataTable proporciona acceso programático a 
DataRowCollection. La propiedad Columns del objeto DataTable 
proporciona acceso programático a DataColumnCollection. 
El siguiente código de ejemplo agrega los nombres de columnas de un objeto 
DataSet al control ListBox denominado lstItems: 
 
Dim col As DataColumn 
For Each col In ds.Tables(0).Columns 
lstItems.Items.Add(col.ColumnName) 
Next 
 
foreach(DataColumn col in ds.Tables[0].Columns) 
{ 
lstItems.Items.Add(col.ColumnName); 
} 
 
 
 
 
 
 
Visual Basic .NET 
 
 
C# 
 
 
 
 
 
 
Visual Basic .NET 
 
 
C# 
Tanto el objeto DataRowCollection como el objeto DataColumnCollection 
tienen una propiedad Count que nos permite determinar el número de filas o 
columnas de un objeto DataTable, como muestra el siguiente código de 
ejemplo: 
 
ds.Tables("Authors").Rows.Count 
ds.Tables("Authors").Columns.Count 
 
ds.Tables["Authors"].Rows.Count; 
ds.Tables["Authors"].Columns.Count; 
 
Contar las filas y columnas del objeto DataTable nos permite acceder a campos 
individuales del objeto DataTable. Podemos acceder a campos por posición 
ordinal (basada-en-0) o por el nombre. En el siguiente código, x es el índice de 
la fila de datos a la que deseamos acceder: 
DataSet.Tables(0).Rows(x)(1) 
DataSet.Tables(0).Rows(x)("fieldname") 
 
ds.Tables["Authors"].Rows[x][1]; 
ds.Tables["Authors"].Rows[x]["fieldname"]; 
8 Acceso a datos con Microsoft ADO.NET 
 
 
 
 
 
 
Visual Basic .NET 
 
 
 
 
 
C# 
El siguiente código recorre en bucle cada fila del objeto DataTable 
denominado Authors y crea una cadena utilizando los campos segundo y 
au_lname de Authors: 
Dim r As DataRow 
Dim str As String 
For Each r in ds.Tables("Authors").Rows 
str &= r(1) 
str &= r("au_lname") 
Next 
 
string str = ""; 
foreach(DataRow r in ds.Tables["Authors"].Rows) 
{ 
str += r[1]; 
str += r["au_lname"]; 
} 
Acceso a datos con Microsoft ADO.NET 9 
 
 
◼ Crear una conexión 
◼ Crear DataAdapter 
◼ Crear DataSet 
◼ Leer los datos del DataSet 
programáticamente 
 
Demostración: utilizar programáticamente un DataSet 
 
 
 
Introducción En esta demostración, examinaremos código que crea y rellena un objeto 
DataSet, y veremos cómo ese código rellena dinámicamente un control 
ListBox desde el objeto DataSet. 
⚫Ejecutar la demostración 
1. Abrir la página UseDataSet.aspx del proyecto Demo08VB o Demo08CS 
que se pueden encontrar dentro del fichero demos08.zip. 
2. Generar y examinar la página. 
La primera vez que se carga la página, el cuadro de lista lstItems se rellena 
dinámicamente con los nombres de las columnas del DataSet. 
El botón Get Number of Rows y el botón Get Values leen la información 
del DataSet. 
3. Hacer clic en Get Number of Rows. 
El código en el procedimiento de evento click muestra la propiedad Count 
de la colección Rows. 
4. Seleccionar una columna en el cuadro de lista y hacer clic en Get Values. 
El código en el procedimiento de evento click recorre en bucle las filas del 
DataSet y muestra el campo seleccionado. 
5. En Visual Studio .NET, visualizar la página de código subyacente de la 
página UseDataSet.aspx. 
10 Acceso a datos con Microsoft ADO.NET 
 
 
6. En el procedimiento de evento Page_Load, mostrar el código que crea los 
siguientes objetos: 
• SqlConnection 
• SqlDataAdapter 
• DataSet 
7. En el procedimiento de evento Page_Load, mostrar cómo la primera vez 
que se muestra la página, el cuadro lista se rellena únicamente con los 
nombres de columnas. 
8. En el procedimiento de evento cmdRows_Click, mostrar cómo se recupera 
el número de filas desde el DataSet. 
9. En el procedimiento de evento cmdGetValues_Click, mostrar cómo se 
recupera el campo seleccionado desde el DataSet. 
Acceso a datos con Microsoft ADO.NET 11 
 
 
◼ Los estudiantes: 
 Reordenarán líneas de código para crear 
un DataSet 
◼ Tiempo: 5 minutos 
 
Práctica: organizar código para crear un DataSet 
 
 
 
En esta práctica, reordenaremos líneas de código ADO.NET en el orden 
correcto para crear un objeto DataSet. 
⚫Ejecutar la práctica 
• Visualizar la página http://localhost/Mod10VB/DataSetCode.aspx o 
http://localhost/Mod10CS/DataSetCode.aspx y organizar las líneas de 
código ADO.NET en el orden correcto para crear un objeto DataSet. 
 
Nota Hay varias respuestas correctas para esta práctica. 
 
http://localhost/Mod10VB/DataSetCode.aspx
http://localhost/Mod10CS/DataSetCode.aspx
12 Acceso a datos con Microsoft ADO.NET 
 
dg.DataSource = ds 
dg.DataMember = "Authors" 
dg.DataBind() 
<asp:DataGrid id="dg" runat="server" /> 
dg.DataSource = ds; 
dg.DataMember = "Authors"; 
dg.DataBind(); 
 
◼ Crear el control 
<asp:DataGrid id="dg" runat="server" /> 
 
◼ Vincular a un DataSet o un DataView 
dg.DataSource = ds 
dg.DataMember = "Authors" 
dg.DataBind() 
dg.DataSource = ds; 
dg.DataMember = "Authors"; 
dg.DataBind(); 
 
Vincular un DataSet a un control enlazado a lista 
 
 
 
Introducción 
 
 
 
 
Crear el control 
 
 
 
 
Vincular a un Dataset o 
DataView 
 
 
 
 
 
 
 
 
 
Visual Basic .NET 
 
 
C# 
ASP.NET incluye un conjunto de controles enlazados a listas, como los 
controles DataGrid, DataList y DataRepeater, que facilitan y flexibilizan la 
visualización de datos desde una fuente de datos. Los desarrolladores 
únicamente deben vincular estos controles a una fuente de datos para mostrar 
los datos seleccionados. 
El primer paso para vincular el objeto DataSet al control enlazado a lista es 
crear el control. El siguiente código muestra cómo crear un control DataGrid 
dg queproduce la salida HTML parecida a una hoja de cálculo: 
 
<asp:DataGrid id="dg" runat="server" /> 
 
Para vincular un objeto DataSet a un control DataGrid, en primer lugar 
debemos establecer la propiedad DataSource del control DataGrid a un objeto 
DataSet, DataTable o DataView, e invocar el método DataBind. 
Si establecemos la propiedad DataSource del control DataGrid directamente a 
un objeto DataSet, el objeto DataTable con el índice 0 se utiliza de forma 
predeterminada. Para especificar otro objeto DataTable, establecer la propiedad 
DataMember del control DataGrid con el nombre del objeto DataTable 
deseado. 
El siguiente código de ejemplo muestra cómo vincular la tabla Authors, del 
objeto DataSet ds, a un control DataGrid denominado dg: 
dg.DataSource = ds 
dg.DataMember = "Authors" 
dg.DataBind() 
 
dg.DataSource = ds; 
dg.DataMember = "Authors"; 
dg.DataBind(); 
Acceso a datos con Microsoft ADO.NET 13 
 
 
 
 
 
 
Visual Basic .NET 
 
 
C# 
 
 
 
 
 
Ejemplo de uso de una 
vista personalizada 
Visual Basic .NET 
 
 
 
C# 
El siguiente código muestra cómo podemos utilizar también la colección Tables 
del objeto DataSet ds para asignar el objeto DataTable Authors directamente a 
la propiedad DataSource del control DataGrid denominado dg: 
dg.DataSource = ds.Tables("Authors") 
dg.DataBind() 
 
dg.DataSource = ds.Tables["Authors"]; 
dg.DataBind(); 
 
Si deseamos mostrar una vista distinta de los datos del control DataGrid, 
deberemos crear un nuevo objeto DataView desde el objeto DataSet y vincular 
ese objeto al control. 
El siguiente código de ejemplo muestra cómo vincular un objeto DataView dv, 
filtrado para el estado de California, a un control DataGrid dg: 
Dim dv As New DataView(ds.Tables("Authors")) 
dv.RowFilter = "state = 'CA'" 
dg.DataSource = dv 
dg.DataBind() 
 
DataView dv = new DataView(ds.Tables["Authors"]); 
dv.RowFilter = "state = 'CA'"; 
dg.DataSource = dv; 
dg.Databind(); 
 
La siguiente ilustración muestra el formato predeterminado del control 
DataGrid, mostrando datos de autores que viven en el estado de California. 
 
 
14 Acceso a datos con Microsoft ADO.NET 
 
 
◼ Crear una conexión 
◼ Crear un DataAdapter 
◼ Crear un DataSet 
◼ Crear un DataView 
◼ Vincular DataSet y DataView a controles 
DataGrid 
 
Práctica dirigida por el instructor: mostrar un DataSet 
 
 
 
Introducción En esta práctica dirigida por el instructor, examinaremos código que crea y 
rellena un objeto DataSet, crea un objeto DataView utilizando datos 
clasificados y filtrados del objeto DataSet, y vincula los controles DataGrid a 
los objetos DataSet y DataView. 
⚫Ejecutar la práctica dirigida por el instructor 
1. Abrir la página UseGrid.aspx del proyecto Mod10VB o Mod10CS de la 
solución 2310Demos. 
2. Generar y examinar la página UseGrid.aspx. 
Hay dos controles DataGrid vinculados al mismo objeto DataSet. El 
primer control DataGrid muestra todos los datos del objeto DataSet. El 
segundo control DataGrid está vinculado a un objeto DataView, que filtra 
y clasifica los datos. El segundo control DataGrid también implementa la 
clasificación estableciendo la propiedad Sort del objeto DataView. 
3. En Visual Studio .NET, visualizar el código subyacente de la página 
UseGrid.aspx. 
4. En el procedimiento de evento Page_Load, mostrar el código que hace lo 
siguiente: 
• Crea el objeto SqlConnection. 
• Crea el objeto SqlDataAdapter. 
• Crea un objeto DataSet. 
• Vincula el primer control DataGrid con el objeto DataSet. 
• Crea un objeto DataView y establece las propiedades RowFilter y Sort. 
• Vincula el segundo control DataGrid con el objeto DataView. 
Acceso a datos con Microsoft ADO.NET 15 
 
 
◼ La conexión no se abre 
 La cadena de conexión no es válida 
 El servidor o la base de datos no se encuentran 
 Fallo de inicio de sesión 
◼ El DataAdapter no puede crear un DataSet 
 Sintaxis SQL no válida 
 Nombre de tabla o campo no válido 
 
Gestión de errores 
 
Código de ejemplo 
 
 
Introducción 
 
 
La conexión no se abre 
Existen dos fuentes principales de error cuando intentamos acceder a datos 
desde un formulario Web Form utilizando ADO.NET: problemas de conexión y 
una falta de alineación con la base de datos. 
Cuando se invoca el método Open, puede producirse más de un error. Ante la 
posibilidad de que ocurra más de un error, debemos ser capaces de gestionar 
múltiples errores utilizando las instrucciones Try…Catch…Finally. Si se 
produce una o más excepciones SqlException, podemos recorrer todos los 
objetos de excepciones SQL devueltos a nuestra aplicación Web. 
El siguiente código muestra cómo utilizar una instrucción Try...Catch para 
capturar múltiples tipos de excepciones. En este ejemplo, el código captura el 
tipo de excepción InvalidOperationException, junto con otras excepciones, 
utilizando un procesador de excepciones genérico: 
16 Acceso a datos con Microsoft ADO.NET 
 
 
Visual Basic .NET 
 
Try 
Dim conn As New SqlConnection(...) 
Dim da As New SqlDataAdapter(..., conn) 
Dim ds As New DataSet() 
da.Fill(ds) 
 
Catch ex1 As System.Data.SqlClient.SqlException 
Select Case ex1.Number 
Case 17 
lblErrors.Text = lblErrors.Text & _ 
("invalid Server name") 
Case 156, 170 'bad SQL syntax 
lblErrors.Text = lblErrors.Text & _ 
("incorrect syntax") 
Case 207 'bad field name in select 
lblErrors.Text = lblErrors.Text & _ 
("invalid column name") 
Case 208 'bad table name in select 
lblErrors.Text = lblErrors.Text & _ 
("invalid object name") 
Case 18452 
lblErrors.Text = lblErrors.Text & _ 
("invalid user name") 
Case 18456 
lblErrors.Text = lblErrors.Text & _ 
("invalid password") 
Case 4060 
lblErrors.Text = lblErrors.Text & _ 
("invalid database") 
End Select 
 
Catch ex2 As System.Exception 
lblErrors.Text = lblErrors.Text & _ 
("Unexpected exception: " & ex2.Message & ". ") 
End Try 
Acceso a datos con Microsoft ADO.NET 17 
 
 
C# try 
{ 
SqlConnection conn = new SqlConnection("..."); 
SqlDataAdapter da = new SqlDataAdapter("...",conn); 
DataSet ds = new DataSet(); 
da.Fill(ds); 
} 
catch (System.Data.SqlClient.SqlException ex1) 
{ 
switch(ex1.Number) 
{ 
case 17: 
lblErrors.Text = lblErrors.Text + 
("invalid Server name"); 
break; 
case 156: 
case 170: //bad SQL syntax 
lblErrors.Text = lblErrors.Text + 
("incorrect syntax"); 
break; 
case 207: //bad field name in select 
lblErrors.Text = lblErrors.Text + 
("invalid column name"); 
break; 
case 208: //bad table name in select 
lblErrors.Text = lblErrors.Text + 
("invalid object name"); 
break; 
case 18452: 
lblErrors.Text = lblErrors.Text + 
("invalid user name"); 
break; 
case 18456: 
lblErrors.Text = lblErrors.Text + 
("invalid password"); 
break; 
case 4060: 
lblErrors.Text = lblErrors.Text + 
("invalid database"); 
break; 
} 
} 
catch (System.Exception ex2) 
{ 
lblErrors.Text = lblErrors.Text + 
("Unexpected exception: " + ex2.Message + ". "); 
} 
18 Acceso a datos con Microsoft ADO.NET 
 
 
El DataAdapter no 
puede crear un DataSet 
 
 
 
 
 
 
 
 
 
 
Visual Basic .NET 
 
 
 
 
 
 
 
C# 
La clase SqlException contiene la excepción que se lanza cuando SQL Server 
devuelve un aviso o error. Esta clase se crea siempre que el Proveedor de Datos 
.NET de SQL Server encuentra una situación que no puede gestionar. La clase 
SqlException siempre contiene al menos la instancia de un objeto SqlError. 
Podemos utilizar el nivel de severidad de la clase para que nos ayude a 
determinar el contenido de un mensaje mostrado por una excepción. 
Para capturar objetos SqlException, debemos buscar errores de tipo 
System.Data.SqlClient.SqlException. Cuando se produce un objeto 
SqlException, el objeto de excepción contiene una colección Errors. 
El siguiente ejemplo muestra cómo podemos recorrer la colección Errors para 
encontrar información sobre los errores que se han producido: 
Dim erData As SqlClient.SqlErrorCollection= ex1.Errors 
Dim i As Integer 
For i = 0 To erData.Count - 1 
lblErrors.Text &= ("Error " & i & ": " & _ 
erData(i).Number & ", " & _ 
erData(i).Class & ", " & _ 
erData(i).Message & "<br>") 
Next i 
 
SqlErrorCollection erData = ex1.Errors; 
for(int i = 0; i < erData.Count; i++) 
{ 
lblErrors.Text += "Error" + i + ": " + 
erData[i].Number + ", " + 
erData[i].Class + ", " + 
erData[i].Message + "<br>"; 
} 
 
Errores de SQL Server Los errores de SQL Server comparten propiedades comunes y están 
identificados por un número y un nivel de gravedad: 
◼ La clase SqlError y propiedades comunes 
Cada objeto SqlError tiene las propiedades comunes que se muestran en la 
siguiente tabla. 
Propiedad Descripción 
Class 
LineNumber 
 
 
Message 
Number 
Obtiene el nivel de gravedad del error devuelto por SQL Server. 
Obtiene el número de línea del archivo de proceso por lotes con 
comandos Transact-SQL o el procedimiento almacenado que 
contiene el error. 
Obtiene el texto que describe el error. 
Obtiene un número que identifica el tipo de error. 
 
 
Nota Para una lista completa de las propiedades de la clase SqlError, 
consultar la documentación de Visual Studio .NET. 
Acceso a datos con Microsoft ADO.NET 19 
 
 
◼ Números de error de SQL Server 
La propiedad Number permite determinar el error específico que se ha 
producido. Por ejemplo, la siguiente tabla ofrece una lista de algunos 
números de errores SQL Server más habituales y sus descripciones. 
Número Descripción 
17 
4060 
18456 
Nombre de servidor no válido 
Nombre de base de datos no válido 
Nombre de usuario o contraseña no válidos 
 
◼ Niveles de gravedad de SQL Server 
La siguiente tabla describe niveles de severidad de errores de SQL Server, a 
los que se accede a través de la propiedad Class de la clase SqlError. 
Gravedad Descripción Acción 
11-16 
17-19 
Generado por usuario 
Errores de software o 
hardware 
Puede ser corregido por el usuario. 
Podemos seguir trabajando, pero es posible 
que no podamos ejecutar una instrucción 
determinada. SqlConnection permanece 
abierto. 
2
0
-
2
5
E
r
r
o
r
e
s
 
d
e
 
s
o
f
t
w
a
r
e
 
o
 
h
a
r
d
w
a
r
e 
El servidor cierra SqlConnection. El usuario puede volver a abrir la conexión.