acceso a datos con ado .net 3.5 (ejemplo)

26
Acceso a datos con ADO .NET 3.5 José Luis Hevia / Ángel Rayo Ejemplo de lectura

Upload: didier-arvey-burgos-hernandez

Post on 16-Feb-2015

62 views

Category:

Documents


3 download

TRANSCRIPT

Page 1: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

Acceso a datos con

ADO .NET 3.5

José Luis Hevia / Ángel Rayo

Ejem

plo d

e lec

tura

Page 2: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

Sipnosis

Esta obra sirve como referencia para todo programador que trabaje en la plataforma .NET y necesiteacceso a datos desde sus aplicaciones.

Sirve, además como texto de base para la preparación del examen oficial 70-561 (ADO.NET), parte delas certificaciones MCTS y MCPD de Microsoft

La primera parte del libro muestra los conceptos de ADO.NET relativos a acceso a datos conectados,desconectado además del proceso de sincronización de ellos con los gestores de bases de datos rela-cionales.

Los últimos capítulos cubren las novedades de ADO.NET 3.5 como son LINQ y sus variantes LINQto Objects, LINQ to DataSet, LINQ to DataSet, LINQ to SQL y Entity Framework.

Jose Luis Hevia es ingeniero informático y llevamas de 12 años dedicado a la consultoría, la forma-ción y el desarrollo, especializado como arquitectode software en tecnologías como .NET framework,Java y COM y el ecosistema de productos que lasconforman. Ha escrito multitud de libros relaciona-dos con estas tecnologías y su aplicación prácticaen las arquitecturas empresariales. Colabora enrevistas especializadas del sector y mantiene supropio blog en:

www.heviatec.net.

Ángel Rayo es formador de Alhambra-Eidos desde 2004. Hasido el autor y coautor de varios libros entre los que destaca eltitulado "Administración y Desarrollo con WSS 3.0 y MOSS2007" centrado en Microsoft SharePoint así como otros relacio-nados con la plataforma .NET. Además, ha escrito artículos paradotnetmanía sobre el ciclo de vida de desarrollo de software conVisual Studio Team System, MSF y CMMI.

Ha participado en ponencias sobre SharePoint 2007, Visual Stu-dio Team System y Symbian. Posee las certificaciones MCPDEnterprise en .NET 3.5, MCITP en SQL Server 2008 y MCTSen SharePoint 2007 principalmente. Está certificado como for-mador oficial de Microsoft, EXIN y Nokia+Symbian, siendo enesta última certificación uno de los dos únicos profesionalesautorizados en España. Dentro de la gestión de procesos poseelas certificaciones en ITIL (v2 y v3), ISO 20000 y MOF v4.0.

Ejem

plo d

e lec

tura

Page 3: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

Luarna

Acceso a datos con ADO.NET 3.5© Jose Luis Hevia y Ángel Rayo, Alhambra Eidos© De esta edición: 2009, Luarna Ediciones, S.L.

www.luarna.com

Madrid, octubre de 2009

ISBN: 978-84-92684-47-2

Versión 1.0 (05-10-2009)

Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra solo puede ser realizadacon la autorización de sus titulares, salvo excepción prevista por la ley. Diríjase a CEDRO (Centro Español de DerechosReprográficos, www.cedro.org) si necesita fotocopiar, escanear o hacer copias digitales de algún fragmento de esta obra.

Ejem

plo d

e lec

tura

Page 4: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

Acceso a datos con ADO.NET 3.5

Jose Luis Hevia y Ángel Rayo

Ejem

plo d

e lec

tura

Page 5: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 5

Indice

ADO.NET 2.0 .................................................................................................................................. 11Introducción .................................................................................................................................. 11ADO.NET 1.1 versus ADO.NET 2.0. Madurez de una arquitectura. .............................................. 12Beneficios de ADO.NET ............................................................................................................... 14ADO.NET: Arquitectura de datos desconectados........................................................................... 16

Los Datos se almacenan en DataSets… y también en DataTables .............................................. 17Los DataSets/DataTables son independientes de los orígenes de datos ........................................... 18Los Datos persisten en forma de documento XML ........................................................................ 18

Los Esquemas: “Metadatos” de los documentos XML ............................................................... 19Componentes de ADO.NET ...................................................................................................... 20

Arquitectura orientada a conexión ................................................................................................. 22Los “proveedores gestionados” de datos. Los “.Net Providers” .................................................. 22La arquitectura de los .NET Provider ......................................................................................... 23Una nueva aproximación: Factorías de conexiones .................................................................... 24

Un nuevo participante: SQL Server 2005 ...................................................................................... 25Nuevas herramientas de diseño de capas de datos .......................................................................... 26Los ejemplos del texto .................................................................................................................. 26

La experiencia adquirida de ADO.NET ......................................................................................... 27Arquitecturas de aplicaciones ........................................................................................................ 27

Diferentes almacenamientos de los datos ................................................................................... 28Determinación del modo de recuperación de los datos ............................................................... 29Modelos de diseño de aplicaciones distribuidas ......................................................................... 30Buenas prácticas… .................................................................................................................... 31

ADO.NET .................................................................................................................................... 33DataSet ..................................................................................................................................... 35Las clases conectadas a datos ................................................................................................... 35Optimización de los recursos: patrones asíncronos ..................................................................... 37Transacciones distribuidas: una realidad .................................................................................... 38

ADO.NET y XML ........................................................................................................................ 38Las clases de ADO.NET ............................................................................................................... 39

NameSpaces.............................................................................................................................. 39Clases Desconectadas de datos .................................................................................................. 40Clases específicas de un proveedor de datos (Conectadas a Datos) ............................................. 40

Conexiones a Datos ......................................................................................................................... 42Las conexiones a datos .................................................................................................................. 42.NET Data Providers ..................................................................................................................... 43

Repasando lo existente: DAO y ODBC, ADO y OLEDB ........................................................... 44Proveedores de datos .NET........................................................................................................ 45

Definiendo conexiones .................................................................................................................. 47Cadenas de conexión ..................................................................................................................... 47

El buen hacer con los lenguajes… ............................................................................................. 50Algunos usos importantes de los objetos de conexión… ............................................................ 51Ejemplos de cadenas de conexiones........................................................................................... 52Seguridad en el acceso a los datos ............................................................................................. 55

Proceso de eventos de conexión .................................................................................................... 56Captura del evento StateChange ................................................................................................ 57Detección de mensajes de Error / Información ........................................................................... 61

InfoMessage .......................................................................................................................... 61Manejadores de excepciones estructurados ............................................................................ 66

El balanceo de conexiones............................................................................................................. 69Lo que había hasta ahora… ....................................................................................................... 69Ejem

plo d

e lec

tura

Page 6: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 6

El Pool de conexiones. ADO.NET Forever!............................................................................... 70Los parámetros de control del Pool de conexiones en la cadena de conexión .............................. 72Utilizar el Analizador de SQL Server 2000... ............................................................................. 73Otra demo, con el analizador de SQL 2005 ................................................................................ 76

Enumeración de servidores SQL Server ........................................................................................ 77Generación de cadenas de conexión .............................................................................................. 79

Operaciones Conectadas a Datos .................................................................................................... 82OPERACIONES conectadas a datos ............................................................................................. 82Ejecutar comandos: XxxCommand ............................................................................................... 83La creación de un objeto XxxCommand ........................................................................................ 83Las diferentes maneras de hacer las cosas. Tipos de comandos. ..................................................... 84

Ejecución de comandos y obtención de respuestas ..................................................................... 86ExecuteReader y los lectores de datos (DataReader) .............................................................. 87ExecuteScalar. Recuperación de valores “simples” ................................................................ 96DML de actualización, DCL y DDL ...................................................................................... 97

Los parámetros en SQL ................................................................................................................. 99Asignación de parámetros ....................................................................................................... 100Tipos de parámetros: Entrada, Salida, Valor de retorno... ......................................................... 102No sólo de procedimientos vive el hombre............................................................................... 105

Operaciones asíncronas ............................................................................................................... 107El API asíncrono de ADO.NET 2.0 ......................................................................................... 108El algoritmo asíncrono ............................................................................................................ 108

Nuevos comandos de SqlClient ................................................................................................... 113SqlBulkCopy .......................................................................................................................... 114SqlDependency ....................................................................................................................... 115

Consideraciones finales ............................................................................................................... 120

API independiente del fabricante ................................................................................................. 121Introducción ................................................................................................................................ 121Las factorías de clases ................................................................................................................. 122Factorías de clases de ADO.NET ................................................................................................ 123

El proceso de conexión............................................................................................................ 124Enumeración de los proveedores instalados ......................................................................... 124Especificar el proveedor en tiempo de ejecución .................................................................. 125Conexiones Parametrizadas ................................................................................................. 126

Operaciones conectadas independientes del proveedor ............................................................. 129

Operaciones Desconectadas de los Datos ..................................................................................... 133Operaciones desconectadas ......................................................................................................... 133

Evolución en ADO.NET 2.0 .................................................................................................... 135Arquitectura de DataSet .............................................................................................................. 135Independencia del origen............................................................................................................. 136Construyendo Dataset ................................................................................................................. 137

Creando la “base de datos”: DataSet, DataTable y DataColumn ............................................... 139Expresiones en las columnas: Campos Calculados ................................................................... 142Constraints y las propiedades de las columnas ......................................................................... 143

Claves primarias (PrimaryKey Constraints) ......................................................................... 145Claves ajenas (ForeignKey Constraints)............................................................................... 146

Relaciones entre tablas: DataRelation ...................................................................................... 147El proceso de los datos ................................................................................................................ 149

Consultas de tablas .................................................................................................................. 149Consultas a vistas .................................................................................................................... 152Inserciones, modificaciones y borrados ................................................................................... 154

Insertar nuevos datos ........................................................................................................... 154Modificar datos ................................................................................................................... 155Ejem

plo d

e lec

tura

Page 7: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 7

Borrar Datos ........................................................................................................................ 156Los eventos de las tablas. ........................................................................................................ 157El control de versiones ............................................................................................................ 158

XML. Persistencia estándar en ADO.NET ................................................................................... 161DataSet ................................................................................................................................... 162DataTable ............................................................................................................................... 167Lecturas de datos “conectadas” a DataTable ............................................................................ 170

Finalizando este tema… .............................................................................................................. 171

DataSet y las Fuentes de Datos ..................................................................................................... 172Una filosofía independiente del fabricante ................................................................................... 172

ANSI SQL’92. Primera solución a un problema....................................................................... 173ODBC, OLEDB, Conexiones, RPC... ...................................................................................... 173Ver la luz... con XML.............................................................................................................. 174

Carga desde un .NET Data Provider ............................................................................................ 176Carga de un DataSet a partir de consultas no XML. ................................................................. 177Carga de datos a partir de consultas XML................................................................................ 180Actualización de datos. Sincronización. ................................................................................... 185

El Diffgram ......................................................................................................................... 187Uso de GetChanges() ........................................................................................................... 188Merge( ) .............................................................................................................................. 189El método Select( ) .............................................................................................................. 189A vueltas con los conflictos de sincronización ..................................................................... 190

DbCommandbuilder ................................................................................................................ 192Actualizaciones en BATCH en ADO.NET 2.0 ..................................................................... 193Un ejemplo que lo resume… ............................................................................................... 193

Carga de datos desde XML ......................................................................................................... 197Visual Studio .NET y XML ..................................................................................................... 201

De esquema a XML ............................................................................................................. 201De XML a esquema ............................................................................................................. 206

Carga desde flujos de datos –streams- ......................................................................................... 207DataSet y orígenes heterogéneos ................................................................................................. 211

Transacciones con ADO.NET ....................................................................................................... 213Las operaciones protegidas: transacciones ................................................................................... 213Las transacciones al detalle ......................................................................................................... 215

La clase XxxTransaction ......................................................................................................... 217Los niveles de aislamiento ....................................................................................................... 218Transacciones desde el lenguaje SQL ...................................................................................... 221Subniveles transaccionales (sólo para SQL Server!) ................................................................ 222Procedimientos Almacenados .................................................................................................. 223Normas ACID ......................................................................................................................... 224

El nuevo API transaccional de ADO.NET 2.0 ............................................................................. 225Novedades del API System.Transactions ................................................................................. 225Para utilizar el nuevo API, se requiere un ensamblado… ......................................................... 226Transacciones explícitas .......................................................................................................... 227Transacciones implícitas ......................................................................................................... 229Transacciones distribuidas ....................................................................................................... 231EnterpriseServices ................................................................................................................... 231

DataSet y los Servicios WEB ........................................................................................................ 232De “una arquitectura distribuida” a “la arquitectura distribuida” .................................................. 232Los servicios web........................................................................................................................ 234Datos en servicios web ................................................................................................................ 235

Consumo de un Servicio Web Estándar. .................................................................................. 236Creación del servicio web .................................................................................................... 236Ejem

plo d

e lec

tura

Page 8: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 8

Creación del cliente web ...................................................................................................... 240Consumo de servicios web no estándar ........................................................................................ 243La evolución de la bestia: SQL Server Web services ................................................................... 244

Visual Studio .NET 2005 y los servicios de datos (I) .................................................................... 248Un IDE completamente renovado ................................................................................................ 248Diseñando la capa de datos: Data Designer .................................................................................. 251

Orígenes de datos. Comenzando con planificación… ............................................................... 252Data Source Explorer .............................................................................................................. 254El Diseñador de datos (Data Designer) .................................................................................... 258TableAdapter Configuration Wizard ........................................................................................ 260

Ampliando la funcionalidad de un adaptador ....................................................................... 263La infraestructura de la arquitectura ......................................................................................... 265Agregar nuevos orígenes a un componente ya configurado ...................................................... 266Establecer relaciones en la lógica de datos ............................................................................... 267

Otras herramientas del entorno .................................................................................................... 268

Visual Studio .NET 2005 y los servicios de datos (II): WinFORMS............................................ 271Vínculo a datos desde WinForms ................................................................................................ 271Preparar el entorno de la demo .................................................................................................... 272Vincular controles a datos… sin esfuerzo. Formularios sencillos. ................................................ 273

Modificar el diseño del formulario .......................................................................................... 275Formularios Maestro-Detalle ....................................................................................................... 276Vinculación avanzada de datos en Windows................................................................................ 281

Parámetros en consultas de datos ............................................................................................. 281Personalización avanzada de DataGridView: Imágenes. .......................................................... 284Personalización avanzada DataGridView: columnas multi-evaluadas....................................... 286Vincular origen de tipo Objeto a proyectos Windows .............................................................. 288

Consideraciones finales ............................................................................................................... 292

Visual Studio .NET 2005 y los servicios de datos (III): ASP.NET ............................................... 294Vínculo a datos desde ASP.NET ................................................................................................. 294El entorno de ASP.NET .............................................................................................................. 295Formularios sencillos enlazados a datos ...................................................................................... 296Formularios basados en parámetros ............................................................................................. 298Formulario maestro-detalle ......................................................................................................... 299Otros controles de datos, con más opciones ................................................................................. 303Un caso particular… ................................................................................................................... 304Y para terminar... ........................................................................................................................ 305

Fundamentos de LINQ ................................................................................................................. 307Consultas en LINQ .................................................................................................................. 308

Operaciones básicas de consulta en LINQ ............................................................................ 311Obtención de un origen de datos ...................................................................................... 312Filtrado de datos .............................................................................................................. 312Ordenación de los resultados ........................................................................................... 312Agrupación ...................................................................................................................... 313Unión .............................................................................................................................. 314Selección de datos ........................................................................................................... 314

Operadores de consulta estándar .............................................................................................. 315Modo de ejecución de los operadores de consulta estándar ................................................... 317

Modo de ejecución inmediata (Immediate) ....................................................................... 317Modo de ejecución aplazada (Deferred) ........................................................................... 317

Profundización en los operadores de consulta ...................................................................... 318Operaciones de proyección .............................................................................................. 320Operaciones de filtrado .................................................................................................... 325Ejem

plo d

e lec

tura

Page 9: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 9

Operaciones de ordenación .............................................................................................. 326Operaciones de agrupación .............................................................................................. 328Operaciones de manejo de conjuntos (Set) ....................................................................... 330Operaciones cuantificadoras ............................................................................................ 332Operaciones de particionado de datos .............................................................................. 334Operaciones de combinación ........................................................................................... 335Operaciones de generación .............................................................................................. 337Operaciones de igualdad .................................................................................................. 338Operaciones de elementos ................................................................................................ 339Operaciones de conversión de tipos de datos .................................................................... 340Operaciones de concatenación ......................................................................................... 343

LINQ to XML ............................................................................................................................... 346Diferencias entre tecnologías XML ......................................................................................... 346

LINQ to XML vs DOM ....................................................................................................... 346LINQ to XML vs XmlReader .............................................................................................. 350LINQ to XML vs XSLT ...................................................................................................... 350LINQ to XML vs MSXML .................................................................................................. 350LINQ to XML vs XmlLite ................................................................................................... 351

Clases de LINQ to XML ......................................................................................................... 351La clase XDocument ........................................................................................................... 352

Ejemplos de uso de los métodos y propiedades de la clase XDocument ............................ 353La clase XElement .............................................................................................................. 355La clase XAttribute ............................................................................................................. 358

Consultas de árboles XML con LINQ to XML ........................................................................ 359Búsqueda de elementos ....................................................................................................... 360

Seguridad en LINQ to XML .................................................................................................... 361Herramientas asociadas con LINQ to XML ............................................................................. 361

LINQ to DataSet ........................................................................................................................... 364Visión general de LINQ to DataSet ......................................................................................... 365Clases de LINQ to DataSet ...................................................................................................... 366

DataTableExtensions y DataRowExtensions ........................................................................ 366EnumerableRowCollectionExtensions ................................................................................. 367EnumerableRowCollection .................................................................................................. 367EnumerableRowCollection<TRow> .................................................................................... 367OrderedEnumerableRowCollection ..................................................................................... 369TypedTableBase<T> ........................................................................................................... 369

Consultas contra DataSet ......................................................................................................... 369Consultas contra un DataSet no tipado ................................................................................. 370Consulta contra un DataSet tipado ....................................................................................... 370Uso del método CopyToDataTable ...................................................................................... 371Modificación del valor de un campo de una tabla ................................................................. 371

LINQ to SQL ................................................................................................................................ 373Creación de la estructura de datos ............................................................................................ 375

Creación de las entidades ..................................................................................................... 375Creación de las columnas de las entidades ........................................................................... 379Creación de asociaciones ..................................................................................................... 381

Clase AssociationAttribute .............................................................................................. 383Clase EntitySet ................................................................................................................ 384

Creación de la estructura de datos con Visual Studio 2008 ................................................... 385Clase DataContext ............................................................................................................... 386

Uso del origen de datos LINQ en nuestras aplicaciones ........................................................... 396

ADO.NET Entity Framework ...................................................................................................... 401Ejem

plo d

e lec

tura

Page 10: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 10

Entity Data Model ................................................................................................................... 402Clase ObjectContext ............................................................................................................ 410

Servicios de Objetos ................................................................................................................ 412LINQ to Entities ...................................................................................................................... 413Lenguaje Entity SQL ............................................................................................................... 415

Introducción al desarrollo con SQL Server 2005: SQLCLRS ..................................................... 418La evolución de la bestia ............................................................................................................. 418Procedimientos almacenados estandar ......................................................................................... 420

Procedimiento almacenado sencillo ......................................................................................... 420Procedimientos con parámetros ............................................................................................... 424Consultas DML ....................................................................................................................... 425SQLContext ............................................................................................................................ 425

Procedimiento de cursores dinámicos .......................................................................................... 426

El diseño de nuestra BDD ACME ................................................................................................ 428El diseño de ACME .................................................................................................................... 428

Ajustar SQL Server 2005 ............................................................................................................. 431Instalar AdventureWorks ............................................................................................................ 431Ajustar las habilidades de SQL Server 2005 ................................................................................ 433

Ejem

plo d

e lec

tura

Page 11: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 11

ADO.NET 2.0

Introducción.NET es una tecnología ya más que asentada. Durante casi 2 años ha estado subiendo del podio de lanovedad al escalón de la necesidad. Para cualquier tipo de proyecto, .NET se ha convertido en unaherramienta más que valorada y de la que un alto porcentaje de negocios ya no pueden prescindir.Durante 2 años ha demostrado ser lo robusta y efectiva que es, recibiendo el apoyo total de todos losque estamos implicados en los departamentos de TI.

Durante estos 2 años de vida, la maquinaria de Microsoft no ha dejado de trabajar y pensar. .NET nose estanca y no hace más que crecer. Podríamos considerar estos dos años como un periodo de gesta-ción que ya llega a su madurez. Y el fruto de ese cambio de adolescente a adulto se plasma con la nue-va versión de estas herramientas: .NET 2.0. Y esa madurez nos trae una enorme cantidad de noveda-des que realmente justifican este cambio de versión.

Cambios en todos los niveles del framework, fruto de un estudio profundo de lo existente, y una cap-tura intensiva de nuevos requisitos en las que hemos estado implicados todos nosotros. Desde el pro-pio motor del CLR, pasando por la adición de numerosísimas clases nuevas, reestructurando por com-pleto el motor de ASP.NET… hasta llegar a la evolución de uno de los mejores editores de desarrollodel mundo: el flamante Visual Studio 2005.

De todas estas novedades, os iréis empapando a lo largo de toda la serie de textos que se os ofrecerá ennuestra editorial. Por la parte que me toca, me centraré en uno de los temas que a todos nos apasionanEj

emplo

de

lectu

ra

Page 12: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 12

y que son pieza estructural básica de todo sistema de información: las herramientas de la capa de da-tos. Y que mejor que el nuevo ADO.NET 2.0 para abordar esas tareas…

En el presente texto, hablaremos del modelo de clases de ADO.NET 2.0, pero haciendo un fuerte repa-so de aquel modelo que ya se planteaba desde ADO.NET 1.1, como no puede ser de otra forma. Si, yaexisten libros –incluso de este autor- que hablan de ADO.NET 1.1. Entonces… para qué hablar otravez de lo mismo… pues la razón es que hay novedades incluso en el modelo de clases que ya conoce-mos, por eso será bueno que repasemos y ampliemos.

Pues nada, pasamos a ver “a vista de pájaro” la lista de cambios y pasamos ya a la chicha…

ADO.NET 1.1 versus ADO.NET 2.0. Madurez de una ar-quitectura.ADO.NET 1.1 ya significó un cambio importante respecto al modelo planteado por las tecnologíaspre.net (ADO, OLE DB, COM). ADO.NET 2.0 no es un cambio tan trascendental, más bien es unarenovación basada en la madurez de la arquitectura anterior. Y en todo proceso de madurez siempreaparecen nuevas formas de hacer las mismas cosas además de mejorar aquellas existentes. Se asientanlas que ya funcionaban, se revisan las que podían mejorarse y se definen nuevas estrategias paraabordar más y más complejos contextos -Esta sería la mejor definición del modelo de ADO.NET 2.0-.

Si comparamos ambas arquitecturas, podremos sacar las siguientes conclusiones:

Lo que funciona no lo toques El modelo de clases de ADO.NET 1.1 se mantiene impecable.Esto facilita la transición a la nueva plataforma sobremanera.Pero con una ventaja: CLR 2.0 es más potente, más eficiente ymás seguro. Las mismas clases de ADO.NET 1.1 serán másefectivas en 2.0

Lo que funciona, amplíalo El modelo de clases de ADO.NET 1.1 ya cubría un extenso conjun-to de posibles contextos. Pero a veces en casos concretos no era tanpreciso tanto en funcionalidad como en diseño. Así que enADO.NET 2.0 se amplían las funcionalidades de las clases conoci-das, para dotarlas de más precisión en esos casos concretos. Elmismo camino con la mitad de código. No os confiéis pues, ya quelas clases que ya conocéis han mejorado. De todo se aprende.

APIs asíncronos y nuevas utilidades para ser más productivos en losproveedores .NET.

Lo que no iba fino, mejóralo El obtener un framework perfecto es una ardua tarea. Pero que nosea por esfuerzos. En ADO.NET 1.1 había pecadillos… que se hanrediseñado en ADO.NET 2.0. Hay casos como el de DataSet queproducían retardos asombrosos y un consumo masivo de recursos.La experiencia del uso con este pedazo de clase, han llevado a losingenieros de Microsoft ha rediseñarla desde cero para conseguirunos tiempos de respuesta impresionantes con el mínimo consumode recursos: hace lo mismo pero mejor que nunca. Veremos en elpresente texto cómo analizar esto. Conclusión: Lo que existía, semantiene en funcionalidad, pero mejora en diseño interno. El mis-mo código, de nuevo, es potenciado hasta los límites en 2.0 respectoa 1.1. Baste como ejemplo citar que una operación de agregación defilas indexadas en DataSet

1.1 tarda alrededor de 5 horas, lo que l mismo código en DataSet2.0 tarda no llega al minuto. Ahí queda eso.Ej

emplo

de

lectu

ra

Page 13: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 13

Nuevas herramientas Más contextos de análisis llevan al desarrollo de nuevas formas deabordarlos. Por lo tanto, en ADO.NET 2.0 tenía que haber mejoras.Nuevas clases y adaptación de las existentes para contemplar lasnuevas clases. Por ejemplo, se introducen los conceptos de cargadinámica de proveedores, posibilitando la independencia del siste-ma gestor. De estas novedades, los siguientes cuadros de esta ta-bla…

Nuevos tipos de datos Se incorporan los nuevos tipos Nullables capaces de almacenarvalores nulos incluso en tipos básicos de datos. Muy útiles cuandose trata de evaluar valores de retorno en consultas SQL orientadas aobjetos.

Factorías de proveedores y el APIindependiente del proveedor dedatos.

Empleando patrones de diseño y aprovechando tecnologías ya pre-sentes en el framework, se ofrece la posibilidad de acceder a cual-quier proveedor de datos de forma abstracta. Esto es, que podemosescribir código conectado con independencia del proveedor dedatos.

DataTable se independiza DataSet es un objeto versátil como pocos en el mundo de la in-formática. Pero el problema es que en muchos contextos se vuelvedemasiado pesado. Es por esto que ha decidido ampliar la familia:DataTable se convierte en otra pieza de responsabilidad, pudiendovivir “fuera del nido” con la misma potencia que su padre: la capa-cidad de serializarse. Lo que lo convierte en una “isla” de datos defácil portabilidad que reduce la carga de recursos y el ancho debanda en las comunicaciones. Esto claro, posibilita que el propioframework de ADO.NET abuse de este objeto cuando antes lo hacíade DataSet. Llevando a nuevas sobrecargas del API ya conocido.

Mejores proveedores de datos: SQLServer 2005

Acompañando al estreno de .NET 2.0 aparece en el escenario elnovísimo SQL Server 2005. No es una versión más de SQL Server.Es LA versión de SQL Server. Sólo con esto, nos podremos imagi-nar que un producto que ha estado en la máquina de la ingeniería deSW más de 5 años, nos ofrece en funcionalidad. Y la implicaciónque esto tiene en el proveedor de ADO.NET 2.0. Sólo un temaentero para hablar de esto.

Mejores proveedores de datos: OLEDB

OLE DB ha seguido siendo una pieza clave de las capas de datos enWindows. Lógico es, que si mejora la plataforma, Windows sigadetrás. OLE DB ofrece mejor soporte nativo a .NET y ofrece más ymejores mecanismos de acceso a los datos, aprovechando las inter-faces OLE DB al máximo. Mejor soporte, más funciones de Win-dows incorporadas. Por ejemplo, el pool de conexiones para todoOLE DB.

Rendimiento El mayor cuello de botella de DataSet se ha producido siempre a lahora de sincronizar los datos después de sesiones intensivas desco-nectadas. Ahora, en sus tripas, se ha rediseñado la replicación conmejores contextos, más control transaccional y un código Diffgramoptimizado. A la par que el modelo de clases es capaz de generar deforma automática el conjunto de sentencias SQL necesarias parapoder vivir de forma asíncrona con el sistema gestor.

Optimización Ante operaciones complejas y de movimientos masivos de datos,ADO.NET 1.1 tenía el problema de abordar la ejecución de coman-dos de forma síncrona. Lo que obligaba al desarrollador a crearhilos de ejecución y sincronizarlos para evitar retardos en la ejecu-ción de los sistemas de información (en especial la capa de UI). Enel nuevo modelo de funcionalidades de ADO.NET 2.0 todos losEj

emplo

de

lectu

ra

Page 14: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 14

métodos considerados “potencialmente complicados”, gozan de dossobrecargas: la síncrona y la asíncrona. De tal forma que el desarro-llador no es responsable del modelo de ejecución paralelo. Sólo deejecutar y esperar la señal (evento) oportuna.

Otra novedad grande: la capacidad de serializar DataSet empleandoun protocolo binario propietario en el caso de escribir sistemasbasados en remoting. Reducción de ancho de bando=optimizacióndel rendimiento.

Nuevo modelo de control de Tran-sacciones

Ahora contaremos –siempre que el proveedor nativo de las herra-mientas oportunas- con transacciones distribuidas y un mejor con-trol de las transacciones atómicas. Distribución y control fino debloqueos= nuevo espacio de nombres System.Transactions. Apro-vechando toda la potencia del dispensador de transacciones deCOM+, ahora tenemos control total de la transacción en nuestrosproductos.

Nuevas herramientas de DataBin-ding

La potencia que brinda DataBinding es la de reducir el código de lacapa UI que consume datos a la mínima expresión. Mejores contro-les, más contextos de uso, Databinding impecable.

La novedad: el nuevo control DataBindingNavigator. Formulariosconectados a código, sin prácticamente líneas de código y con lanavegación automatizada.

Lo mejor para el final La nueva arquitectura de modelo de capa de datos: La evolución delos DataSets tipados. Los nuevos DataAdapters permiten crear unaarquitectura de datos completa, sin necesidad de codificar. Indepen-diente de los proveedores, son capaces de encapsular cualquier tipode operación de acceso a una base de datos. Y lo más importante:con todas las herramientas de consultas, consultas parametrizables yoperaciones MDL1. ¡E integrado con los asistentes de Visual Stu-dio!

Y esto es sólo el principio. Si alguien pensaba que los cambios de ADO.NET 2.0 eran mínimos, que seagarre los machos, que tenemos muchas cosas que ver.

Beneficios de ADO.NETADO.NET 2.0 ofrece una buena cantidad de mejoras respecto a modelos anteriores de ADO yADO.NET. Los beneficios los podremos agrupar en las categorías:

· Mejor Interoperabilidad

Las aplicaciones basadas en ADO.NET recogen la ventaja de la flexibilidad y la masiva acep-tación del estándar XML para el intercambio de datos. Puesto que XML es el estándar de en-vión de información entre capas, cualquier componente capaz de Interpretar los datos XMLpuede acceder a la información de ADO.NET se encuentre donde se encuentre, y procesarla.Además, puesto que la información se envía en flujos de XML, no importa la implementaciónempleada para enviar o recoger la información –así como la plataforma empleada-. Simple-mente se exige a los componentes que reconozcan el formato XML empleado para el proceso,envío y recepción de un Dataset.

1 Lenguaje de manipulación de datos. Comandos SQL Insert, Delete y Update.Ejem

plo d

e lec

tura

Page 15: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 15

En ADO.NET ahora incluso es posible emplear el nuevo modelo de DataTable para serializarla información. Puesto que se almacena información más concreta, se pueden abordar muchosmás contextos más optimizados que en la versión anterior. En lugar de “cachear” todo un Da-taset, sólo necesitaremos “cachear” aquellas tablas que se requieren. Por lo tanto, un modelode datos más granular y por lo tanto más optimo.

· Mantenimiento

En el ciclo de vida de una aplicación los cambios poco sustanciales y modestos son permisi-bles. Pero cuando es necesario abordar un cambio estructural o arquitectónico del sistema, latarea se vuelve demasiado compleja y a veces inviable. Esto es una gran desventaja de los sis-temas actuales, pues muchas veces esto es una necesidad de actualización de los procesos dela propia empresa. Además, cuanto más se aumenta el proceso de la operativa de la empresa,las necesidades de proceso crecen hasta desbordar las máquinas. Es por ello que se separa laestructura de un programa en varias capas. Un de esas capas es la de datos, que es fundamentaldesarrollar correctamente. Gracias a los Datasets/DataTables, la tarea de portar y aumentar losprocesos de datos y de negocio será mas sencillo: el intercambio de información a través deXML, hace que sea más sencilla la tarea de estructurar en más capas la aplicación, lo que lahace mucho más modular y mantenible.

Además, en el nuevo modelo de clases Adaptadoras de .NET 2.0 y las herramientas de VS2005, es posible definir todo un modelo lógico de clases que encapsulan la complejidad de labase de datos. De esta forma, cualquier cambio en la BDD (capa de datos) no necesariamenteimplica cambiar código en la capa de servicio de datos (consumidor cliente de los datos). Estaherramienta ya estaba disponible en .NET 1.1 mediante los Datasets con tipo. Pero en estaversión se ha refactorizado para ofrecer mucha más funcionalidad que antes. Con esto, prácti-camente sin escribir código, se nos proporcionará una capa de servicio de datos con todas lasherramientas que se requieren, y además con la posibilidad de mantener y ampliar su esquemacon muchos más servicios, independientemente de cómo esté implementado en la BDD. Loque funciona, automatízalo.

· Programación

Los programadores pueden acceder a un API de programación estructurado, fuertemente tipi-ficado y que además se centra en la correcta forma de presentar las cosas. Centra en la estruc-tura del lenguaje lo que un programador necesita para diseñar los programas sin dar muchosrodeos. Un ejemplo de código sin tipificar:

If CosteTotal > DataSet1.Tables("Cliente")(10).Columns("CreditoDisponible")then

Como se puede observar, aparecen nombres de objetos genéricos del sistema que complican lalectura del código, a la par que los operadores complican también la visión de la secuencia deacceso a los datos. Podríamos interpretar lo que hace gracias a que aparecen los nombres pro-pios de los datos que necesitamos....Veamos un ejemplo, un poco más tipificado:

If CosteTotal> DataSet1.Cliente(10).CreditoDisponible then

El ejemplo es exactamente igual al anterior, pero en este caso, el código se centra más en losobjetos reales que en el objeto del lenguaje en sí: las palabras “Table” y “column” ya no apa-recen. En su lugar vemos que aparecen los nombres de los objetos empleados de la vida real,lo que hace el código más legible. Si a esto unimos que los entornos ya son capaces de ayu-darnos a escribir el código, todavía lo tenemos más sencillo, ya que podemos ver con nuestraspalabras el modelo de objetos de datos que necesitamos en cada momento. Incluso a nivel deejecución nos vemos respaldado por un sistema de control de tipos y errores que nos permi-tirán proporcionar una robustez “innata” que antes no se tenía sin pasar por el uso de funcio-nes externas.Ejem

plo d

e lec

tura

Page 16: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 16

En el nuevo API de ADO.NET 2.0, incluso podremos mapear columnas, encapsular llamadasa procedimientos externos, conectar con múltiples orígenes de datos, etc.

· Rendimiento

Puesto que trabajamos con objetos de datos desconectados, todo el proceso se acelera, ya queno tenemos que estar comunicándonos por Marshalling con el servidor. Además, gracias almodelo de XML la conversión de tipos no es necesaria a nivel de COM. Se reduce pues el an-cho de banda disponible, se independiza más el cliente del servidor y se descarga más a éste,que puede estar dedicado a otras tareas en lo que el cliente analiza sus datos.

Ampliando las herramientas disponibles y conociendo una limitación importante, enADO.NET 2.0 se han extendido las funcionalidades de Serialización. Me explico. EnADO.NET 1.1 el movimiento masivo de datos entre capas empleando DataSet puede producircuellos de botella debido a la redundancia de los datos XML y su XSD de validación. Existencontextos en el que esta redundancia plantea fuertes limitaciones:

a) Almacenaje en dispositivos temporales (memoria compartida, disco duro)

b) Sistemas de proceso RPC basados en remoting (No se requieren protocolos abiertoscompatibles al 100%, sino más bien las tecnologías de ejecución RPC)

Para esto, el modelo de serialización de DataSet se extiende para soportar el formato binario.Un formato que permite compactar los datos y reducir el uso del esquema XSD al mínimo im-prescindible. Se pierde en portabilidad pero se gana en optimización.

Otra de las herramientas de mejora de rendimiento está en la incorporación de nuevas funcio-nalidades asíncronas, por las cuales todas aquellas tareas susceptibles de ser cuellos de botella,se pasan a segundo plano añadiéndolas todo un conjunto de señales (delegados, eventos, etc.)para su completo control con el mínimo esfuerzo.

· Escalabilidad

Las aplicaciones Web tienen un número ilimitado de conexiones potenciales debido a la natura-leza de internet. Los servidores son capaces de atender muy bien decenas y decenas de conexio-nes. Pero cuando hablamos de miles y millones, los servidores ya no son capaces de realizar co-rrectamente su trabajo. Esto es debido a que por cada usuario se mantiene una memoria de pro-ceso y conexión, un conjunto de bloqueos de recursos como puedan ser tablas, índices... y unacomprobación de sus permisos. Lo que lleva su tiempo y recursos. ADO.NET favorece la esca-labilidad puesto que su modelo de conexión Off-Line evita que se mantengan los recursos reser-vados más tiempo del considerado necesario. Y esto permite que más usuarios por unidad detiempo puedan acceder a la aplicación sin problemas de tiempos. Además se pueden montar ser-vicios en Cluster de alta disponibilidad que serán balanceados automáticamente por el sistemasin afectar a las conexiones ADO. Lo cual garantiza la ampliación del servicio sin representar uncambio de arquitectura de diseño.

ADO.NET: Arquitectura de datos desconectadosADO.NET está basado en una arquitectura desconectada de los datos. En una aplicación de datos se hacomprobado que mantener los recursos reservado mucho tiempo implica reducir el número de usuariosconectados y aumenta el proceso del sistema al mantener una política de bloqueos y transacciones. Almismo tiempo, si la aplicación mantiene más de un objeto simultáneamente, se encuentra con el pro-blema de tener que estar continuamente conectando con el servidor para alimentar las relaciones exis-tentes entre ambas, subiendo y bajando información vía RPC.Ej

emplo

de

lectu

ra

Page 17: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 17

Con ADO.NET se consigue estar conectado al servidor sólo estrictamente necesario para realizar laoperación de carga de los datos en el dataSet. De esta manera se reducen los bloqueos y las conexio-nes a la mínima expresión. Se pueden soportar muchos más usuarios por unidad de tiempo y disminu-yen los tiempos de respuesta, a la par que se aceleran las ejecuciones de los programas.

Pero... ¿qué ocurre con aquellas aplicaciones que DEBEN estar conectadas a la base de datos por sudiseño y situación de proceso? Por ejemplo, una aplicación de alquiler de películas, o un sistema deventa de Stock... necesitan conocer en todo momento el estado de la base de datos. Y por ello requie-ren una conexión permanente con la BDD. Pues en ese caso, se continuará utilizando el modelo deobjetos de ADO.NET conectado. Pero en el API de ADO.NET 2.0 se cubre mucho mejor el hueco queexiste entre los dos modos de funcionamiento: el desconectado y el conectado. Gracias al nuevo mode-lo de Adaptadores y las funcionalidades de replicación, es posible mantener sistemas “semi-desconectados” que aprovechan lo mejor de los dos mundos, casi sin desarrollar código.

Los Datos se almacenan en DataSets… y también en DataTablesDe toda la vida, el recoger información de una base de datos ha ido destinado a realizar un proceso condicha información: mostrarla por pantalla, procesarla o enviarla a algún componente. Frecuentemente,la aplicación no necesita una única fila, sino un buen conjunto de ellas. Además, también frecuente-mente, ese conjunto de filas procede no de una tabla sino de una unión de múltiples tablas (join detablas). Una vez que estos datos son cargados, la aplicación los trata como un bloque compacto. En unmodelo desconectado, es inviable el tener que conectar con la base de datos cada vez que avanzamosun registro para recoger la información asociada a ese registro (condiciones del join). Para solucionar-lo, lo que se realiza es almacenar temporalmente toda la información necesaria donde sea necesario ytrabajar con ella. Esto es lo que representa un Dataset en el modelo ADO.NET.

Un DataSet es una caché de registros recuperados de una base de datos que actúa como un sistema dealmacenamiento virtual, y que contiene una o más tablas basadas en las tablas reales de la base dedatos. Y que, además, almacena las relaciones y reglas de integridad existentes entre ellas para garan-tizar la estabilidad e integridad de la información de la base de datos. Muy importante es recalcar, quelos Datasets son almacenes pasivos de datos, esto es, que no se ven alterados ante cambios subyacen-tes de la base de datos. Es necesario recargarlos (FillDataSet) siempre que queramos estar “al día” encuanto a datos se refiere.

Figura 1. Envío de Datasets entre componentes

Una de las mayores ventajas de esta implementación, es que una vez recogido el dataset, éste puedeser enviado –en forma de flujo XML- entre distintos componentes de la capa de negocio como si deuna variable más se tratase, ahorrando así comunicaciones a través de la base de datos.

Pero la clase DataSet es una clase que potencialmente puede consumir muchos recursos. En su mode-lo de clases –y como toda buena base de datos- es posible subdividir su complejidad en clases máspequeñas. Es por esto que al igual que una base de datos se compone de tablas, un Dataset se compon-ga de DataTables. Pero la novedad no está ahí, sino en proporcionar nuevas funcionalidades que per-Ej

emplo

de

lectu

ra

Page 18: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 18

miten evolucionar DataTable y colocarlo al mismo nivel funcional que DataSet. Esto es, que DataTa-ble se puede serializar y puede ser utilizado de forma autónoma, sin requerir el uso completo de laclase Dataset contenedora. Eso si, siguen siendo partes constitutivas, lo cual quiere decir que siguenconviviendo juntos como hasta ahora… pero con la salvedad de que ahora DataTable es mayor y escapaz de vivir por su cuenta cuando sea menester.

Los DataSets/DataTables son independientes de los oríge-nes de datosUna consecuencia lógica de este tipo de arquitecturas, es la de conseguir que los objetos desconecta-dos sean independientes de los orígenes de datos. Los drivers OLE-DB, los proveedores .NET, etc.transformarán la consulta SQL en un Cursor representado con una estructura XML, que es indepen-diente del motor de la base de datos. Es más, si encima encapsulamos toda la capa de datos en cómo-dos procedimientos almacenados, ni siquiera necesitaremos integrar el código SQL en la capa de ne-gocio, lo cual todavía independiza más el DataSet/DataTable de la base de datos (ya que el códigoSQL, actualmente no es tan estándar...).

Esto nos permitirá trabajar con múltiples orígenes de datos, de distintos fabricante e incluso no-base dedatos - como por ejemplo ficheros planos u hojas de cálculo -... lo que representa un importante puntode compatibilidad y flexibilidad.

Si a esto unimos que disponemos de un modelo consistente de objetos (xmlDOM) que es independien-te del origen de datos, las operaciones -y toda su potencia- de los Datasets/Datatables no se verán afec-tadas por dicho origen.

Los Datos persisten en forma de documento XMLLa persistencia es un concepto muy interesante en el mundo del desarrollo. Es un mecanismo por elcual un componente puede almacenar su estado (valores de variables, propiedades, datos...en un mo-mento concreto del tiempo) en un soporte de almacenamiento fijo. De manera, que cuando es necesa-rio, se puede recargar el componente tal y como quedó en una operación anterior.

En un sistema de trabajo Off-Line como el que plantea ADO.NET, la persistencia es un mecanismofundamental. Podemos cerrar la aplicación y mantener persistentes todos los DataSets necesarios, demanera que al reiniciarla, nos encontramos los DataSets tal y como los dejamos. Ahorrando el tiempoque hubiera sido necesario para recuperar de nuevo toda esa información del servidor. Optimizandotodavía más el rendimiento del sistema distribuido.

El formato que emplea ADO.NET para almacenar su estado es XML. Puesto que ya es un estándar dela industria, esta persistencia nos ofrece:

· La información podría estar accesible para cualquier componente del sistema que entiendaXML.

· Es un formato de texto plano, no binario. Que lo hace compatible con cualquier componentede cualquier plataforma y recuperable en cualquier caso

Ejem

plo d

e lec

tura

Page 19: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 19

Los Esquemas: “Metadatos” de los documentos XMLMuchas veces necesitamos conocer el cómo se estructura un Dataset para poder averiguar qué colum-nas tenemos disponibles, con qué tipo de datos, tamaño, etc. A esta información que define el cómo seestructura la información de le denomina Metadatos(Datos que definen datos).

En el caso de los documentos XML, el que determina la estructura que éstos tienen son los Esquemas.No son necesarios para la codificación del documento XML, pero refuerzan su estructura a la par queestablece una manera común de introducir nuevos datos respetando un juego de reglas básico, que todaaplicación debe respetar si quiere mantener intacta la integridad del documento original.

En ADO.NET la generación de los esquemas así como de los documentos XML asociados a una basede datos son automáticos y transparentes al usuario. No se necesitará acceder a ellos a bajo nivel, amenos que sea requisito del diseño. Dichos esquemas se actualizarán cuando se modifique la base dedatos o las consultas empleadas para acceder a los datos. Lo dicho, todo transparente al usuario. Yproporcionarán toda la información necesaria para leer la estructura del dataset (que corresponderá conla estructura física de la base de datos). Todo un invento.

Si la tabla de SQL Server, es del estilo:

Figura 2. Tabla de Usuario en SQL Server

El esquema generado por el DataSet, quedaría de la siguiente manera:

Figura 3. Esquema XML de la tabla UsuariosEjem

plo d

e lec

tura

Page 20: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 20

Aunque parezca un poco galimatías, se puede observar que en documento XML se pueden obser-var las características de la tabla sin necesidad de contar con el Enterprise Manager: Las estructuraselement que definen la tabla y los campos de la tabla, las estructuras key que definen claves primariasy las estructuras complexType que permiten agrupar tipos simples en estructuras de más alto nivel.

Componentes de ADO.NETVeamos una ilustración del modelo de componentes que plantea Microsoft en su arquitectura .NET(imagen obtenida de la MSDN © de Microsoft):

Figura 4. Modelo de Componentes de ADO.NET

Como parte de los componentes presentados en el gráfico de la plataforma de datos de ADO.NET,tendremos:

Componente Descripción

Dataset Modelo jerárquico de representación de unabase de datos con arquitectura desconectada.

DataTable Representa la estructura de una tabla: colec-ción de columnas y filas.

Dataset command Conjunto de procedimientos ADO.NET deejecución de comandos SQL.Ej

emplo

de

lectu

ra

Page 21: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 21

Tabla 1

Como se puede observar, los datos son recogidos del servidor por los componentes DataSetCommandmediante la ejecución de comandos SQL (procedimientos almacenados, vistas, consultas...) en elcomponente de negocio por los objetos DataSets. Empleando la interfaz XML, estos componentesentregan la información al nivel de interfaz de usuario, que a través de entornos WEB, formulariosestándar de Windows o bien herramientas especializadas pueden ya procesar y analizar la información.

Y a modo de ejemplo, en la capa de interfaz de usuario:

Componente Descripción

WebForms2 Interfaz de usuario basada en componentes DHTML visualiza-bles en un navegador.

WinForms3 Interfaz de usuario basada en componentes GUI del entorno deWindows, a través de programas ejecutables.

BizzTalk4 Conjunto de herramientas cliente- servidor que permiten automa-tizar los procesos de negocio.

Tabla 2

En los siguientes temas, se procederá a la documentación de las distintas clases .Net dedicadas a lastareas de recuperación de los datos y que están recogidas en las librerías:

Nombre de la clase Descripción

System.Data Espacio de nombres que integra la gran mayoría de clases que habilitan el accesoa los datos de la arquitectura .NET

System.Data.Common Contiene las clases compartidas para los “.NET Providers”5 (proveedores .NET).Proporcionan la colección de clases necesarias para acceder a una fuente de datos(como por ejemplo una Base de Datos).

System.Data.SqlClient Espacio de nombres que permite el acceso a proveedores SQL Server en su ver-sión 7.0 y superior. Este espacio de nombres ha sido ampliado para soportar lasnuevas características de SQL Server 2005.

System.Data.Sql Espacio de nombres con multitud de herramientas para interactuar con el nuevomotor de SQL Server 2005: enumeración de servidores, gestión del servidor,implementación de objetos de la BDD, etc. Sólo para SQL Server 2005.

System.Data.OleDB Espacio de nombres que permite acceder a proveedores .NET que trabajan direc-tamente contra controladores basados en los ActiveX de Microsoft

System.Data.Odbc Espacio de nombres que contiene las clases que actúan de pasarela con el modelode drivers ODBC de Windows. Emplean InterOp para acceder a los drivers nati-vos ODBC, pero proporcionan un marco de compatibilidad hacia atrás muy im-portante para muchos fabricantes de SW.

System.Data.Oracle Espacio de nombres, desarrollado por Microsoft, que posibilita el acceso a recur-

2 WebForms y Winforms se analizan en el texto de EIDOS dedicado al frameWork de desarrollo de Visual Stu-dio .NET

3 ver (1)

4 Para más información acerca de BizzTalk Server, vea la página de Microsoft http://www.microsoft.com/biztalk

5 ver el punto siguiente “los proveedores gestionados de datos”.Ejem

plo d

e lec

tura

Page 22: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 22

sos de sistemas gestores de Oracle. Dependen del cliente nativo de Oracle insta-lado en la máquina. Es recomendable que accedáis a la web del fabricante paraacceder a versiones más actualizadas y desarrolladas por el propio fabricante.

System.Data.Internal Integra el conjunto de clases internas de las que se componen los proveedores dedatos.

System.Data.SqlTypes Proporciona la encapsulación en clases de todos los tipos de datos nativos deSQL Server y sus funciones de manejo de errores, ajuste y conversión de tipos,etc.

Tabla 3

Arquitectura orientada a conexiónLa otra aproximación posible a la resolución de contextos de datos es la de vivir conectados a losmismos. Una aplicación de estar conectada con el sistema gestor para acceder en “tiempo real” a losdatos que almacena. En ADO.NET 2.0 este modelo no ha cambiado mucho respecto a la versión ante-rior. Es que el que menos ha cambiado, si bien si incorpora mejoras en la funcionalidad que eran nece-sarias. Repasemos algunos conceptos e introduzcamos las novedades…

Los “proveedores gestionados” de datos. Los “.Net Providers”Los “proveedores gestionados” –Managed Providers o .NET Providers- de datos hacen referencia alos mecanismos por los cuales un programa puede acceder a los recursos de un servidor de bases dedatos. Son el conjunto de componentes que interactúan como mediadores para independizar el pro-grama de la base de datos. En términos ya conocidos, son el equivalente a la arquitectura OLE-DB deMicrosoft. Un conjunto de componentes que encapsulan el acceso, manejo de cursores y comunica-ciones a un servidor de datos. En el caso de ADO.NET los proveedores gestionados están encapsula-dos en un conjunto de clases que, precisamente, hacen transparente al programador el acceso a losrecursos de los drivers de acceso a un servidor de datos. Son el modelo de clases del API de progra-mación de un origen de datos.

De ahí que en la tabla anterior nos encontremos con clases específicas de algunos fabricantes como esel case de System.Data.SqlClient, que encapsula toda la potencia y flexibilidad de la API de SQL Ser-ver. De esta manera el acceso a los datos es más directo y no se requiere de multitud de componentesintermedios para realizar una acción, ni perder funciones específicas por compatibilidad con otrasplataformas.

En la plataforma .NET se ofrecen con el SDK, los proveedores gestionados:

· SQL Managed Provider. Ofrece el conjunto de clases necesarias para comunicarse con loscomandos de SQL Server en su versión 7.0 ó superior. Especial hincapié en que este espaciode nombres ha sido evolucionado para soportar las nuevas tecnologías de SQL Server 2005,que no son pocas. Lo que se conoce se mantiene, pero investigar las novedades que son ex-tremadamente potentes.

· OleDB Managed Provider. Ofrece el conjunto de clases necesarias para acceder fuentes dedatos accesible a través de drivers OLEDB/ODBC. En las mejoras de ADO.NET 2.0 el haberampliado el soporte que el CLR da a estos tipos de proveedores, como por ejemplo la integra-ción mejorada de la seguridad, el pool de conexiones, etc.

· ODBC Managed provider. Conexiones con el modelo de drivers de la pasarela ODBC nativade Windows. No se garantiza en todos los casos el mismo soporte por parte del CLR, pero seEjem

plo d

e lec

tura

Page 23: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 23

ha extendido la funcionalidad para soportar más y mejores características de los más potentesy recientes.

· ORACLE Managed Provider. Portado de la versión ADO.NET 1.1. Extendido para garanti-zar la compatibilidad con el cliente de Oracle en su versión 9. Si necesitáis soporte para ver-siones superiores, será bueno ir a la web de la propia Oracle o emplear sus homólogosODBC/OLEDB.

La arquitectura de los .NET ProviderToda clase que aspire a .NET Provider, debe cumplir que en su espacio de nombres implemente lasclases derivadas de:

· Connection. Que será la clase encargada de encapsular toda la funcionalidad de conexión alas fuentes de datos.

· Command. Que será la que encapsula el envío de comandos SQL al servidor.

· DataReader. Que contiene todo el subsistema de lectura de los cursores resultados de unaQuery

· DataAdapter. Que es el componente encargado de adaptar el conjunto de operaciones reali-zadas desde un origen genérico (por ejemplo, un dataSet) hacia un destino (un servidor de ba-ses de datos relacionales concreto, por ejemplo SQL Server) y viceversa.

Figura 5. Modelo de clases de ADO.NET

Como ejemplo, el espacio de nombres System.Data,.SqlClient implementa las clases:

· SqlConnection

· SqlCommand

· SqlDataReader

· SqlDataAdapter

Ejem

plo d

e lec

tura

Page 24: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 24

Además, los .NET Providers tienen la capacidad de enviar/recibir y almacenar persistentemente demanera off-line todo el flujo de información en formato XML. Suelen implementar los métodos Re-adXML y WriteXML para poder implementar esta funcionalidad.

Actualmente están en fase final los proveedores gestionados de SQL Server (SQL Managed Providers)y los de para el acceso a todo el soporte de datos fabricado sobre las especificaciones de OLE-DB,Microsoft proporciona el conjunto de clases de ADO.NET que tiene compatibilidad con los proveedo-res de datos OLE-DB (ADO Managed Providers):

Nombre del proveedor OLEDB Descripción del proveedor

SQLOLEDB Proveedor SQL Server OLEDB

MSDAORA Proveedor ORACLE OLEDB

JOLT JET OLEDB Provider (proveedor de bases de datos JET)

MSDASQL/SQLServer ODBC Acceso vía Direct-ODBC a sistemas SQL Server (conexionesODBC a través de drivers OLEDB)

MSDASQL/Jet ODBC Acceso vía Direct-ODBC a sistemas JET (conexiones ODBC através de drivers OLEDB)

Tabla 4

En la actualidad el soporte de terceros a la plataforma .NET ha crecido hasta prácticamente ofrecerproveedores para todo sistema gestor que se puede encontrar en el mercado: DB2, MySQL, Informix,etc. Para más información, visitad las web de los respectivos fabricantes.

Bien, después de haber introducido los conceptos básicos de la plataforma .NET orientada a los datosde la nueva arquitectura de Microsoft, pasamos ya a describir con todo detalle la nueva propuesta deMicrosoft para el acceso a los datos.

Una nueva aproximación: Factorías de conexionesEn ADO.NET 2.0 se ha evolucionado el modelo de los proveedores de tal forma que no sólo contemoscon conexiones con proveedores concretos conocidos de antemano, sino que además podamos entiempo de ejecución elegir el proveedor que necesitamos. Esto facilita la generación de arquitecturasde SW o productos “DataProvider agnostics”… es decir, independientes del proveedor.

No es que no fuera posible en versiones anteriores, pero las herramientas que se proporcionaban noiban encaminadas a estos menesteres. Casi se sugería que era responsabilidad del programador el crearun modelo de servicio para hacer el código más abstracto, no haciendo fácil la cara dinámica de clasescomo si era factible hacer en los modelos de los antiguos OLEDB a través de la cadena de conexión.

El caso, es que todo apuntaba a poder implementar un modelo independiente del proveedor, pero alfinal la complejidad de análisis y su puesta en producción apostaba a por modelos más sencillos, en losque era el propio desarrollador el que se montaba la capa de servicios de datos y la reemplazaba en elcaso de cambiar de sistema gestor.

Pero en la versión 2.0 de ADO.NET se ha escuchado a todos los desarrolladores que demandaban estafuncionalidad. Y se ha implementado de una forma muy elegante, siendo una opción más en el SDKque no estorba, pero que se puede utilizar para mejorar el código o abordar estos contextos, sin modi-ficar todo lo ya conocido. A través de los principios de abstracción y la carga dinámica de clases, po-dremos generar código independiente del sistema gestor. Pero ya lo veremos en su momento.Ej

emplo

de

lectu

ra

Page 25: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 25

Un nuevo participante: SQL Server 2005Para acabar con esta somera introducción a lo que trataremos en este texto, no podía dejar de lado alnuevo participante en las tecnologías corporativas: SQL Server 2005. Un nuevo producto de Microsoftque no ha sido sólo un lavado de cara del ya soberano SQL Server 2000. Rediseñado desde cero, se hapuesto al día con las nuevas tecnologías y ofrece ciento de novedades que harán nuestros aplicativoscorporativos mucho más productivos que nunca.

No es plan dedicar este texto a SQL Server 2005, pues ya hay otros autores que están con ello, pero nopuedo evitar hablar del tema, ya que va de la mano de las mayores mejores de las clases de ADO.NET.

En SQL Server 2005 podemos decir que existen tres grandes bloques que afectan a ADO.NET:

a) Los nuevos API, frameworks y servicios de SQL Server 2005. Como, por ejemplo, Notifi-cation Services, Service Broker, etc. Que obviamente ofrecen multitud de herramientas parasimplificar ciertos contextos corporativos a la mínima expresión.

b) Las nuevas características del CORE de SQL Server 2005. Que hacen que el servidorofrezca mejores herramientas, y un lenguaje TSQL más potente y con más funcionalidad queel anterior. A la par que .NET se “embute” en el propio CORE, dando al desarrollador la opor-tunidad de desarrollar objetos de datos empleando esta tecnología: procedimientos almacena-dos, funciones… incluso nuevos tipos de datos.

c) Las nuevas características del servidor de administración. Lo cual llevará a los desarrolla-dores a interactuar de un modo más concreto con todo el motor de la base de datos, automati-zando virtualmente cualquier tarea del sistema gestor. A la par que hay más y mejores herra-mientas de tolerancia a fallos, alta disponibilidad, etc., que permitirá el desarrollo de sistemasmás robustos que nunca, con la mínima interacción por parte del desarrollador.

Figura 6. SQL Server Enterprise Manager y los interfaces de programación de una BDDEjem

plo d

e lec

tura

Page 26: Acceso a Datos Con ADO .NET 3.5 (Ejemplo)

P á g i n a | 26

En el presente texto haremos mención del apartado (b). Los demás, los dejaremos para el autor deSQL Server que tiene también muchas cosas que contar.

Nuevas herramientas de diseño de capas de datosUna de las mayores novedades de ADO.NET 2.0 está en el nuevo soporte que da para la construcciónde capas de datos. Entendiendo por capa de datos la abstracción lógica que montamos para independi-zar una capa lógica de aplicación de capas de más bajo nivel. Para esto, ADO.NET ofrece dos nuevosframeworks de encapsulación de la capa de datos:

a) Mejores controles vinculados a datos. Nuevos controles, evoluciones de los anteriores… elcaso es que hay un 20% de mejoras en las tecnologías de MS de DataBinding. Muchas máspropiedades que antes, que mejoran la productividad a niveles impresionantes. Baste decir quemontar un formulario maestro/detalle nos lleva escasos 5 minutos, que cargar una combo apartir de una colección es “una línea de código”, etc. Y que el nuevo control DataBindingNa-vigator nos ofrece todas las herramientas de navegación y manipulación de datos sin picarprácticamente código.

b) Una arquitectura de acceso a datos basada en los esquemas de datos. Totalmente integra-do con VS 2005, la posibilidad de generar una capa de acceso a datos totalmente encapsuladaen clases, basada en la descripción del modelo de datos a partir de esquemas XSD. A partir dedicho esquema XSD, se genera el código necesario para dar al desarrollador todas las herra-mientas que demande para navegar y manipular los datos. Y poder cambiarlo en cualquiermomento, simplemente accediendo al esquema y añadiendo o quitando funcionalidad. Y, co-mo no, integrado con toda la tecnología de DataBinding. Lo veremos, una maravilla. Que de-jemos claro a muchos gustará a otros no. Pero aquí lo dejamos caer.

Los ejemplos del textoPara que no tengáis que picaros todos los fuentes a mano, podréis decargar todos los proyectos reali-zados en el texto en la siguiente URL:

http://www.elcampusdigital.com/FtpTextos/AdoNet2/FuentesADONET2.zip

En todos los capítulos, debajo del código fuente tendréis especificada la carpeta del proyecto del quese está hablando en cada momento.

Bien, pues después de este pedazo de presentación… creo que es momento de entrar de lleno en elnuevo ADO.NET 2.0. Manos a la obra.

Ejem

plo d

e lec

tura