acceso a datos con ado .net 4.0 (ejemplo)

29
Acceso a datos con ADO .NET 4.0 José Luis Hevia y Ángel Rayo Ejemplo de texto

Upload: giovanni-chaviano-balmaseda

Post on 02-Aug-2015

209 views

Category:

Documents


1 download

TRANSCRIPT

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

Acceso a datos con

ADO .NET 4.0

José Luis Hevia y Ángel Rayo

Ejem

plo

de te

xto

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

La colección. Saber hacer de los profesionales TIC se corresponde con textos escritos por el plantel de profesores de la prestigiosa compañía tecnológica Alhambra Eidos. Esta firma, especializada en la formación de personal técnico en las tecnologías de la información y de las comu-nicaciones, lleva formando en España desde hace veinte años a multi-tud de profesionales en dicho entorno. Muchas de las obras contenidas en la serie son los textos que Alhambra Eidos emplea en su reconoci-do Máster Alhambra Eidos en desarrollo de software, un curso que la mencionada compañía ha decidido impartir usando el libro electrónico como base. Así, sus alumnos, en lugar de recibir las más de 3.000 pági-nas en papel que hasta el curso 2008-2009 recibía, ahora se les entrega un reader en propiedad que contiene esa misma información pero en formato de libro electrónico.

Ejem

plo

de te

xto

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

Sipnosis

Esta obra sirve como referencia para todo programador que trabaje en la plata-forma .NET y necesite acceso a datos desde sus aplicaciones.

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

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

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

Ejem

plo

de te

xto

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

Jose Luis Hevia es ingeniero informático y lleva mas de 12 años dedicado a la con-sultoría, la formación y el desarrollo, es-pecializado como arquitecto de software en tecnologías como .NET framework, Java y COM y el ecosistema de productos que las conforman. Ha escrito multitud de libros relacionados con estas tecnologías y su aplicación práctica en las arquitectu-ras empresariales. Colabora en revistas

especializadas del sector y mantiene su propio blog en:

www.heviatec.net.

Ángel Rayo es formador de Alhambra-Eidos desde 2004. Ha sido el autor y coautor de varios libros entre los que destaca el titulado "Administración y Desa-rrollo con WSS 3.0 y MOSS 2007" centrado en Mi-crosoft SharePoint así como otros relacionados con la plataforma .NET. Además, ha escrito artículos para dotnetmanía sobre el ciclo de vida de desarrollo de software con Visual Studio Team System, MSF y CMMI. Ha participado en ponencias sobre SharePoint 2007, Visual Studio Team System y Symbian. Posee las certificaciones MCPD en .NET 4.0, MCITP en SQL

Server 2008 y MCTS en SharePoint 2010 principalmente. Está certificado como formador oficial de Microsoft, EXIN y Nokia+Symbian, siendo en esta última certificación uno de los dos únicos profesionales autorizados en España. Dentro de la gestión de procesos posee las certificaciones en ITIL (v2 y v3), ISO 20000 y MOF v4.0.

Ejem

plo

de te

xto

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

Luarna Acceso a datos con ADO.NET 4.0 © José Luis Hevia y Ángel Rayo – Alhambra-Eidos © De esta edición: 2010, Luarna Ediciones, S.L.

www.luarna.com

Madrid, diciembre de 2010

ISBN: 978-84-15013-01-3

Versión 1.0 (15-12-2010)

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

. Ejem

plo

de te

xto

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

Acceso a datos con ADO. NET 4.0

José Luis Hevia y Ángel Rayo

Ejem

plo

de te

xto

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

5

Indice

1.ADO.NET .................................................................................................................................................... 12

INTRODUCCIÓN .............................................................................................................................................. 12

ADO.NET 1.1 VERSUS ADO.NET 4.0. MADUREZ DE UNA ARQUITECTURA. ................................................................. 12

BENEFICIOS DE ADO.NET ................................................................................................................................ 15

ADO.NET: ARQUITECTURA DE DATOS DESCONECTADOS .......................................................................................... 17 Los Datos se almacenan en DataSets… y también en DataTables ............................................................ 17

Los DataSets/DataTables son independientes de los orígenes de datos ............................................................... 18 Los Datos persisten en forma de documento XML .............................................................................................. 18

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

ARQUITECTURA ORIENTADA A CONEXIÓN .............................................................................................................. 22 Los “proveedores gestionados” de datos. Los “.Net Providers” ............................................................... 22 La arquitectura de los .NET Provider ...................................................................................................... 23 Una nueva aproximación: Factorías de conexiones ................................................................................. 25

UN NUEVO PARTICIPANTE: SQL SERVER 2008....................................................................................................... 25

NUEVAS HERRAMIENTAS DE DISEÑO DE CAPAS DE DATOS .......................................................................................... 26

LOS EJEMPLOS DEL TEXTO ................................................................................................................................. 26

2.LA EXPERIENCIA ADQUIRIDA DE ADO.NET .................................................................................................. 28

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

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

ADO.NET Y XML .......................................................................................................................................... 39

LAS CLASES DE ADO.NET ................................................................................................................................ 40 NameSpaces .......................................................................................................................................... 40 Clases Desconectadas de datos .............................................................................................................. 40 Clases específicas de un proveedor de datos (Conectadas a Datos) ......................................................... 41

3.CONEXIONES A DATOS ............................................................................................................................... 42

LAS CONEXIONES A DATOS ................................................................................................................................ 42

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

DEFINIENDO CONEXIONES ................................................................................................................................. 47 Cadenas de conexión ............................................................................................................................. 47 El buen hacer con los lenguajes… ........................................................................................................... 51 Algunos usos importantes de los objetos de conexión… .......................................................................... 51 Ejem

plo

de te

xto

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

6

Ejemplos de cadenas de conexiones ....................................................................................................... 52 Un ejemplo completo de conexión… ....................................................................................................... 53 Seguridad en el acceso a los datos ......................................................................................................... 55

PROCESO DE EVENTOS DE CONEXIÓN ................................................................................................................... 57 Captura del evento StateChange ............................................................................................................ 57 Detección de mensajes de Error / Información ....................................................................................... 62

InfoMessage ...................................................................................................................................................... 62 Manejadores de excepciones estructurados ........................................................................................... 67 El balanceo de conexiones ..................................................................................................................... 70 Lo que había hasta ahora… .................................................................................................................... 70 El Pool de conexiones. ADO.NET Forever! ............................................................................................... 72 Los parámetros de control del Pool de conexiones en la cadena de conexión .......................................... 73 Utilizar el Analizador de SQL Server... ..................................................................................................... 75 Otra demo, con el analizador de SQL 2008 ............................................................................................. 77

ENUMERACIÓN DE SERVIDORES SQL SERVER ......................................................................................................... 78

GENERACIÓN DE CADENAS DE CONEXIÓN .............................................................................................................. 80

4.OPERACIONES CONECTADAS A DATOS ....................................................................................................... 83

OPERACIONES CONECTADAS A DATOS .................................................................................................................. 83

EJECUTAR COMANDOS: XXXCOMMAND ............................................................................................................... 83 La creación de un objeto XxxCommand .................................................................................................. 84 Las diferentes maneras de hacer las cosas. Tipos de comandos. ............................................................. 85 Ejecución de comandos y obtención de respuestas ................................................................................. 87

ExecuteReader y los lectores de datos (DataReader)........................................................................................... 87 Múltiples resultados ...................................................................................................................................... 92 MARS (Multiple Active Result Set) ................................................................................................................. 94

ExecuteScalar. Recuperación de valores “simples” .............................................................................................. 97 DML de actualización, DCL y DDL........................................................................................................................ 98

LOS PARÁMETROS EN SQL .............................................................................................................................. 100 Asignación de parámetros ................................................................................................................... 101 Tipos de parámetros: Entrada, Salida, Valor de retorno... ..................................................................... 104 No sólo de procedimientos vive el hombre... ......................................................................................... 107

OPERACIONES ASÍNCRONAS ............................................................................................................................ 108 El API asíncrono de ADO.NET 4.0 .......................................................................................................... 109 El algoritmo asíncrono ......................................................................................................................... 110

NUEVOS COMANDOS DE SQLCLIENT .................................................................................................................. 115 SqlBulkCopy ......................................................................................................................................... 116 SqlDependency .................................................................................................................................... 118

CONSIDERACIONES FINALES ............................................................................................................................. 122

5.API INDEPENDIENTE DEL FABRICANTE ...................................................................................................... 123

INTRODUCCIÓN ............................................................................................................................................ 123

LAS FACTORÍAS DE CLASES ............................................................................................................................... 124

FACTORÍAS DE CLASES DE ADO.NET ................................................................................................................. 124 El proceso de conexión ......................................................................................................................... 125

Enumeración de los proveedores instalados ..................................................................................................... 125 Especificar el proveedor en tiempo de ejecución .............................................................................................. 127 Conexiones Parametrizadas ............................................................................................................................. 128 Ejem

plo

de te

xto

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

7

Operaciones conectadas independientes del proveedor ........................................................................ 131

6.OPERACIONES DESCONECTADAS DE LOS DATOS ...................................................................................... 135

OPERACIONES DESCONECTADAS ....................................................................................................................... 135 Evolución en ADO.NET 4.0.................................................................................................................... 136

ARQUITECTURA DE DATASET ........................................................................................................................... 137

INDEPENDENCIA DEL ORIGEN ........................................................................................................................... 138

CONSTRUYENDO DATASET .............................................................................................................................. 139 Creando la “base de datos”: DataSet, DataTable y DataColumn ........................................................... 140 Expresiones en las columnas: Campos Calculados ................................................................................ 144 Constraints y las propiedades de las columnas ..................................................................................... 145

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

Relaciones entre tablas: DataRelation .................................................................................................. 148

EL PROCESO DE LOS DATOS ............................................................................................................................. 151 Consultas de tablas .............................................................................................................................. 151 Consultas a vistas ................................................................................................................................ 153 Inserciones, modificaciones y borrados ................................................................................................ 156

Insertar nuevos datos ...................................................................................................................................... 156 Modificar datos ............................................................................................................................................... 157 Borrar Datos .................................................................................................................................................... 158

Los eventos de las tablas...................................................................................................................... 159 El control de versiones ......................................................................................................................... 160

XML. PERSISTENCIA ESTÁNDAR EN ADO.NET..................................................................................................... 162 DataSet ............................................................................................................................................... 164 DataTable ........................................................................................................................................... 168 Lecturas de datos “conectadas” a DataTable ....................................................................................... 172

FINALIZANDO ESTE TEMA… ............................................................................................................................. 173

7.DATASET Y LAS FUENTES DE DATOS ......................................................................................................... 174

UNA FILOSOFÍA INDEPENDIENTE DEL FABRICANTE .................................................................................................. 174 ANSI SQL’92. Primera solución a un problema... ................................................................................... 174 ODBC, OLEDB, Conexiones, RPC............................................................................................................ 175 Ver la luz... con XML. ........................................................................................................................... 175

CARGA DESDE UN .NET DATA PROVIDER............................................................................................................ 177 Carga de un DataSet a partir de consultas no XML. .............................................................................. 179 Carga de datos a partir de consultas XML ............................................................................................ 182 Actualización de datos. Sincronización. ................................................................................................ 186

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

DbCommandbuilder ............................................................................................................................. 193 Actualizaciones en BATCH en ADO.NET 4.0 ....................................................................................................... 195 Un ejemplo que lo resume… ............................................................................................................................ 195

CARGA DE DATOS DESDE XML ......................................................................................................................... 199 Visual Studio .NET y XML ..................................................................................................................... 203 Ejem

plo

de te

xto

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

8

De esquema a XML .......................................................................................................................................... 203 De XML a esquema .......................................................................................................................................... 207

CARGA DESDE FLUJOS DE DATOS -STREAMS- ........................................................................................................ 209

DATASET Y ORÍGENES HETEROGÉNEOS ............................................................................................................... 212

8.TRANSACCIONES CON ADO.NET ............................................................................................................... 215

LAS OPERACIONES PROTEGIDAS: TRANSACCIONES ................................................................................................. 215

LAS TRANSACCIONES AL DETALLE ...................................................................................................................... 216 La clase XxxTransaction ....................................................................................................................... 218 Los niveles de aislamiento .................................................................................................................... 219 Transacciones desde el lenguaje SQL .................................................................................................... 223 Subniveles transaccionales (sólo para SQL Server!) ............................................................................... 224 Procedimientos Almacenados .............................................................................................................. 225 Normas ACID ....................................................................................................................................... 226

EL NUEVO API TRANSACCIONAL DE ADO.NET 4.0 ............................................................................................... 227 Novedades del API System.Transactions ............................................................................................... 227 Para utilizar el nuevo API, se requiere un ensamblado… ....................................................................... 228 Transacciones explícitas....................................................................................................................... 229 Transacciones implícitas ...................................................................................................................... 232 Transacciones distribuidas ................................................................................................................... 233 EnterpriseServices................................................................................................................................ 233

9.DATASET Y LOS SERVICIOS WEB ............................................................................................................... 235

DE “UNA ARQUITECTURA DISTRIBUIDA” A “LA ARQUITECTURA DISTRIBUIDA” ............................................................... 235

LOS SERVICIOS WEB....................................................................................................................................... 237

DATOS EN SERVICIOS WEB .............................................................................................................................. 238 Consumo de un Servicio Web Estándar. ................................................................................................ 238

Creación del servicio web................................................................................................................................. 239 Creación del cliente web .................................................................................................................................. 243

CONSUMO DE SERVICIOS WEB NO ESTÁNDAR ....................................................................................................... 245

LA EVOLUCIÓN DE LA BESTIA: SQL SERVER WEB SERVICES ...................................................................................... 246

10.VISUAL STUDIO Y LOS SERVICIOS DE DATOS (I)....................................................................................... 251

UN IDE COMPLETAMENTE RENOVADO ............................................................................................................... 251

DISEÑANDO LA CAPA DE DATOS: DATA DESIGNER ................................................................................................. 253 Orígenes de datos. Comenzando con planificación… ............................................................................. 255 Data Source Explorer ........................................................................................................................... 256 El Diseñador de datos (Data Designer) ................................................................................................. 260 TableAdapter Configuration Wizard ..................................................................................................... 262

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

OTRAS HERRAMIENTAS DEL ENTORNO ................................................................................................................ 271

11.VISUAL STUDIO 2010 Y LOS SERVICIOS DE DATOS (II): WINFORMS ......................................................... 273

VÍNCULO A DATOS DESDE WINFORMS ............................................................................................................... 273

PREPARAR EL ENTORNO DE LA DEMO ................................................................................................................. 274

VINCULAR CONTROLES A DATOS… SIN ESFUERZO. FORMULARIOS SENCILLOS. ............................................................... 275 Modificar el diseño del formulario........................................................................................................ 276 Ejem

plo

de te

xto

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

9

FORMULARIOS MAESTRO-DETALLE ................................................................................................................... 277

VINCULACIÓN AVANZADA DE DATOS EN WINDOWS ............................................................................................... 281 Parámetros en consultas de datos ....................................................................................................... 282 Personalización avanzada de DataGridView: Imágenes. ....................................................................... 284 Personalización avanzada DataGridView: columnas multi-evaluadas ................................................... 286 Vincular origen de tipo Objeto a proyectos Windows ............................................................................ 288

CONSIDERACIONES FINALES ............................................................................................................................. 292

12.VISUAL STUDIO 2010 Y LOS SERVICIOS DE DATOS (III): ASP.NET ............................................................. 293

VÍNCULO A DATOS DESDE ASP.NET .................................................................................................................. 293

EL ENTORNO DE ASP.NET.............................................................................................................................. 294

FORMULARIOS SENCILLOS ENLAZADOS A DATOS .................................................................................................... 295

FORMULARIOS BASADOS EN PARÁMETROS .......................................................................................................... 296

FORMULARIO MAESTRO-DETALLE ..................................................................................................................... 297

OTROS CONTROLES DE DATOS, CON MÁS OPCIONES ............................................................................................... 300

UN CASO PARTICULAR… ................................................................................................................................. 301

Y PARA TERMINAR... ..................................................................................................................................... 302

13.FUNDAMENTOS DE LINQ ........................................................................................................................ 304

CONSULTAS EN LINQ .................................................................................................................................... 304 Operaciones básicas de consulta en LINQ ............................................................................................. 308

Obtención de un origen de datos ..................................................................................................................... 308 Filtrado de datos.............................................................................................................................................. 308 Ordenación de los resultados ........................................................................................................................... 309 Agrupación ...................................................................................................................................................... 310 Unión .............................................................................................................................................................. 311 Selección de datos ........................................................................................................................................... 311

OPERADORES DE CONSULTA ESTÁNDAR .............................................................................................................. 312 Modo de ejecución de los operadores de consulta estándar ................................................................. 314

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

PROFUNDIZACIÓN EN LOS OPERADORES DE CONSULTA ........................................................................................... 315 Operaciones de proyección .................................................................................................................. 317 Operaciones de filtrado ....................................................................................................................... 322 Operaciones de ordenación.................................................................................................................. 323 Operaciones de agrupación ................................................................................................................. 325 Operaciones de manejo de conjuntos (Set) ........................................................................................... 327 Operaciones cuantificadoras ................................................................................................................ 329 Operaciones de particionado de datos ................................................................................................. 331 Operaciones de combinación ............................................................................................................... 332 Operaciones de generación .................................................................................................................. 334 Operaciones de igualdad ..................................................................................................................... 335 Operaciones de elementos ................................................................................................................... 336 Operaciones de conversión de tipos de datos ....................................................................................... 338 Operaciones de concatenación............................................................................................................. 340

14.LINQ TO XML .......................................................................................................................................... 343

DIFERENCIAS ENTRE TECNOLOGÍAS XML ............................................................................................................ 343 Ejem

plo

de te

xto

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

10

LINQ to XML vs DOM ........................................................................................................................... 343 LINQ to XML vs XmlReader................................................................................................................... 346 LINQ to XML vs XSLT ............................................................................................................................ 346 LINQ to XML vs MSXML........................................................................................................................ 346 LINQ to XML vs XmlLite ........................................................................................................................ 347

CLASES DE LINQ TO XML .............................................................................................................................. 347 La clase XDocument ............................................................................................................................. 348 Ejemplos de uso de los métodos y propiedades de la clase XDocument ................................................ 350 La clase XElement ................................................................................................................................ 352 La clase XAttribute ............................................................................................................................... 355

CONSULTAS DE ÁRBOLES XML CON LINQ TO XML ............................................................................................... 357 Búsqueda de elementos ....................................................................................................................... 357

SEGURIDAD EN LINQ TO XML......................................................................................................................... 358

HERRAMIENTAS ASOCIADAS CON LINQ TO XML .................................................................................................. 358

15.LINQ TO DATASET ................................................................................................................................... 361

VISIÓN GENERAL DE LINQ TO DATASET ............................................................................................................. 361

CLASES DE LINQ TO DATASET ......................................................................................................................... 362 DataTableExtensions y DataRowExtensions ......................................................................................... 362 EnumerableRowCollectionExtensions ................................................................................................... 363 EnumerableRowCollection<TRow> ....................................................................................................... 364 OrderedEnumerableRowCollection....................................................................................................... 365 TypedTableBase<T> ............................................................................................................................. 365

CONSULTAS CONTRA DATASET......................................................................................................................... 365 Consultas contra un DataSet no tipado ................................................................................................ 366 Consulta contra un DataSet tipado ...................................................................................................... 367 Uso del método CopyToDataTable ....................................................................................................... 367 Modificación del valor de un campo de una tabla ................................................................................. 368

16.LINQ TO SQL ........................................................................................................................................... 369

CREACIÓN DE LA ESTRUCTURA DE DATOS ............................................................................................................ 370 Creación de las entidades .................................................................................................................... 370 Creación de las columnas de las entidades ........................................................................................... 375 Creación de asociaciones ..................................................................................................................... 376

Clase AssociationAttribute ............................................................................................................................... 379 Clase EntitySet ................................................................................................................................................. 380

Creación de la estructura de datos con Visual Studio 2008 ................................................................... 381 Clase DataContext ............................................................................................................................... 383

USO DEL ORIGEN DE DATOS LINQ EN NUESTRAS APLICACIONES ................................................................................ 393

17.ADO.NET ENTITY FRAMEWORK .............................................................................................................. 398

ENTITY DATA MODEL .................................................................................................................................... 399 Clase ObjectContext............................................................................................................................. 407

SERVICIOS DE OBJETOS .................................................................................................................................. 410

LINQ TO ENTITIES ........................................................................................................................................ 410

LENGUAJE ENTITY SQL .................................................................................................................................. 413

18.LA EXPERIENCIA ADQUIRIDA DE ADO.NET .............................................................................................. 416

CLAVES AJENAS EN EL MODELO CONCEPTUAL ...................................................................................................... 416

NUEVOS MÉTODOS PARA EL DESARROLLO DE APLICACIONES N-CAPAS ........................................................................ 417 Ejem

plo

de te

xto

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

11

SOPORTE ENTITYDATASOURCE PARA EL CONTROL QUERYEXTENDER .......................................................................... 417

EJECUCIÓN DIRECTA DE COMANDOS ALMACENADOS .............................................................................................. 418 ExecuteStoreCommand ........................................................................................................................ 418 ExecuteStoreQuery .............................................................................................................................. 419 Translate ............................................................................................................................................. 421

OBJETOS QUE IGNORAN LA PERSISTENCIA............................................................................................................ 421

CARGA PEREZOSA (LAZY) DE OBJETOS RELACIONADOS ............................................................................................ 423

FUNCIONES EN LAS CONSULTAS LINQ A ENTIDADES .............................................................................................. 423 EntityFunctions .................................................................................................................................... 424

Funciones personalizadas de base de datos ...................................................................................................... 424 Funciones personalizadas del modelo .............................................................................................................. 425

SqlFunctions ........................................................................................................................................ 426

MEJORAS EN ORDERBY EN LINQ A ENTIDADES .................................................................................................... 427

GENERACIÓN DE CÓDIGO PERSONALIZADO DE LA CAPA DE OBJETOS ........................................................................... 427

SOPORTE MODEL-FIRST ................................................................................................................................. 427

SOPORTE DE TIPOS COMPLEJOS ........................................................................................................................ 428

19.ADO.NET DATA SERVICES ....................................................................................................................... 431

VISIÓN GENERAL .......................................................................................................................................... 431

IMPLEMENTACIÓN DE NUESTRA BASE DE DATOS.................................................................................................... 431 Paso 1: Creación del modelo entity framework ..................................................................................... 431 PASO 2: creación del servicio de datos.................................................................................................. 433 PASO 3: Acceso a los datos mediante REST ........................................................................................... 435 PASO 4: Acceso a los datos mediante clases .NET ................................................................................. 437

20.INTRODUCCIÓN AL DESARROLLO CON SQL SERVER 2005: SQLCLRS ........................................................ 439

LA EVOLUCIÓN DE LA BESTIA ............................................................................................................................ 439

PROCEDIMIENTOS ALMACENADOS ESTANDAR ...................................................................................................... 440

PROCEDIMIENTO ALMACENADO SENCILLO ........................................................................................................... 440

PROCEDIMIENTOS CON PARÁMETROS ................................................................................................................ 443

CONSULTAS DML ........................................................................................................................................ 444

SQLCONTEXT .............................................................................................................................................. 445

PROCEDIMIENTO DE CURSORES DINÁMICOS ......................................................................................................... 445

21.EL DISEÑO DE NUESTRA BDD ACME........................................................................................................ 448

EL DISEÑO DE ACME .................................................................................................................................... 448

22.INSTALAR ADVENTUREWORKS ............................................................................................................... 451

AJUSTAR SQL SERVER 2005 ........................................................................................................................... 451

AJUSTAR LAS HABILIDADES DE SQL SERVER 2005 ................................................................................................. 452

Ejem

plo

de te

xto

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

12

1. ADO.NET

Introducción

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

Durante estos 10 años de vida, la maquinaria de Microsoft no ha dejado de trabajar y pensar. .NET no se 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 4.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 desarrollo del mundo: el flamante Visual Studio 2010.

De todas estas novedades, os iréis empapando a lo largo de toda la serie de textos que se os ofrecerá en nuestra editorial. Por la parte que me toca, me centraré en uno de los temas que a todos nos apasionan 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 4.0 para abordar esas tareas.

En el presente texto, hablaremos del modelo de clases de ADO.NET 4.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, ya existen libros -incluso de este autor- que hablan de ADO.NET 1.1. Entonces… para qué hablar otra vez 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 4.0. Madurez de una arquitectura. ADO.NET 1.1 ya significó un cambio importante respecto al modelo planteado por las tecnologías pre.net (ADO, OLE DB, COM). ADO.NET 4.0 ofrece numerosos cambios, unos como mejoras de la arquitecturas anteriores de ADO.NET 1.1 y ADO.NET 2.0, y otros como cambios radicales: LINQ, Entity Framework y ADO.NET Data Services. Y en todo proceso de madurez siempre aparecen nue-vas formas de hacer las mismas cosas además de mejorar aquellas existentes. Se asientan las que ya funcionaban, se revisan las que podían mejorarse y se definen nuevas estrategias para abordar más y más complejos contextos -Esta sería la mejor definición del modelo de ADO.NET-.

Si comparamos ambas arquitecturas, podremos sacar las siguientes conclusiones:

Ejem

plo

de te

xto

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

13

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 y más seguro. Las mismas clases de ADO.NET 1.1 serán más efectivas en 4.0

Lo que funciona, amplíalo El modelo de clases de ADO.NET 1.1 ya cubría un extenso conjunto de posi-bles contextos. Pero a veces en casos concretos no era tan preciso tanto en funcionalidad como en diseño. Así que en ADO.NET 4.0 se amplían las fun-cionalidades de las clases conocidas, para dotarlas de más precisión en esos casos concretos. El mismo camino con la mitad de código. No os confiéis pues, ya que las clases que ya conocéis han mejorado. De todo se aprende.

APIs asíncronos y nuevas utilidades para ser más productivos en los provee-dores .NET.

Lo que no iba fino, mejóralo El obtener un framework perfecto es una ardua tarea. Pero que no sea por esfuerzos. En ADO.NET 1.1 había pecadillos… que se han rediseñado en ADO.NET 4.0. Hay casos como el de DataSet que producían retardos asom-brosos y un consumo masivo de recursos. La experiencia del uso con este pedazo de clase, han llevado a los ingenieros de Microsoft ha rediseñarla desde cero para conseguir unos tiempos de respuesta impresionantes con el mínimo consumo de recursos: hace lo mismo pero mejor que nunca. Veremos en el presente texto cómo analizar esto. Conclusión: Lo que existía, se man-tiene en funcionalidad, pero mejora en diseño interno. El mismo código, de nuevo, es potenciado hasta los límites en 4.0 respecto a 1.1. Baste como ejem-plo citar que una operación de agregación de filas indexadas en DataSet

1.1 tarda alrededor de 5 horas, lo que el mismo código en DataSet 4.0 tarda no llega al minuto. Ahí queda eso.

Nuevas herramientas Más contextos de análisis llevan al desarrollo de nuevas formas de abordarlos. Por lo tanto, en ADO.NET 4.0 tenía que haber mejoras. Nuevas clases y adap-tación de las existentes para contemplar las nuevas clases. Por ejemplo, se introducen los conceptos de carga dinámica de proveedores, posibilitando la independencia del sistema gestor. De estas novedades, los siguientes cuadros de esta tabla…

Nuevos tipos de datos Se incorporan los nuevos tipos Nullables capaces de almacenar valores nulos incluso en tipos básicos de datos. Muy útiles cuando se trata de evaluar valo-res de retorno en consultas SQL orientadas a objetos.

Factorías de proveedores y el API independiente del proveedor de datos.

Empleando patrones de diseño y aprovechando tecnologías ya presentes en el framework, se ofrece la posibilidad de acceder a cualquier proveedor de datos de forma abstracta. Esto es, que podemos escribir código conectado con inde-pendencia del proveedor de datos.

DataTable se independiza DataSet es un objeto versátil como pocos en el mundo de la informática. Pero el problema es que en muchos contextos se vuelve demasiado pesado. Es por esto que ha decidido ampliar la familia: DataTable se convierte en otra pieza de responsabilidad, pudiendo vivir “fuera del nido” con la misma potencia que su padre: la capacidad de serializarse. Lo que lo convierte en una “isla” de datos de fácil portabilidad que reduce la carga de recursos y el ancho de banda en las comunicaciones. Esto claro, posibilita que el propio framework de ADO.NET abuse de este objeto cuando antes lo hacía de DataSet. Llevando a nuevas sobrecargas del API ya conocido.

Mejores proveedores de datos: SQL Server 2008

Acompañando al estreno de .NET 4.0 aparece en el escenario el noví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 imaginar que un producto que ha Ej

empl

o de

text

o

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

14

estado en la máquina de la ingeniería de SW más de 5 años, nos ofrece en funcionalidad. Y la implicación que esto tiene en el proveedor de ADO.NET 4.0. Sólo un tema entero para hablar de esto.

Mejores proveedores de datos: OLE DB

OLE DB ha seguido siendo una pieza clave de las capas de datos en Windows. Lógico es, que si mejora la plataforma, Windows siga detrás. OLE DB ofrece mejor soporte nativo a .NET y ofrece más y mejores mecanismos de acceso a los datos, aprovechando las interfaces OLE DB al máximo. Mejor soporte, más funciones de Windows incorporadas. Por ejemplo, el pool de conexiones para todo OLE DB.

Rendimiento El mayor cuello de botella de DataSet se ha producido siempre a la hora de sincronizar los datos después de sesiones intensivas desconectadas. Ahora, en sus tripas, se ha rediseñado la replicación con mejores contextos, más control transaccional y un código Diffgram optimizado. A la par que el modelo de clases es capaz de generar de forma automática el conjunto de sentencias SQL necesarias para poder 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 comandos de forma síncrona. Lo que obligaba al desarrollador a crear hilos de ejecución y sincronizarlos para evitar retardos en la ejecución de los sistemas de información (en espe-cial la capa de UI). En el nuevo modelo de funcionalidades de ADO.NET 2.0 todos los métodos considerados “potencialmente complicados”, gozan de dos sobrecargas: la síncrona y la asíncrona. De tal forma que el desarrollador no es responsable del modelo de ejecución paralelo. Sólo de ejecutar y esperar la señal (evento) oportuna. Otra novedad grande: la capacidad de serializar DataSet empleando un proto-colo binario propietario en el caso de escribir sistemas basados en remoting. Reducción de ancho de bando=optimización del rendimiento.

Nuevo modelo de control de Transacciones

Ahora contaremos -siempre que el proveedor nativo de las herramientas opor-tunas- con transacciones distribuidas y un mejor control de las transacciones atómicas. Distribución y control fino de bloqueos= nuevo espacio de nombres System.Transactions. Aprovechando toda la potencia del dispensador de transacciones de COM+, ahora tenemos control total de la transacción en nuestros productos.

Nuevas herramientas de DataBinding

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

La novedad: el nuevo control DataBindingNavigator. Formularios conectados a código, sin prácticamente líneas de código y con la navegación automatiza-da.

Lo mejor para el final La nueva arquitectura de modelo de capa de datos: La evolución de los Data-Sets tipados. Los nuevos DataAdapters permiten crear una arquitectura de datos completa, sin necesidad de codificar. Independiente de los proveedores, son capaces de encapsular cualquier tipo de operación de acceso a una base de datos. Y lo más importante: con todas las herramientas de consultas, consultas parametrizables y operaciones MDL1. ¡E integrado con los asistentes de Vi-sual Studio!

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

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

empl

o de

text

o

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

15

Beneficios de ADO.NET ADO.NET 4.0 ofrece una buena cantidad de mejoras respecto a modelos anteriores de ADO y ADO.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 XML puede 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ón empleada 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.

En ADO.NET ahora incluso es posible emplear el nuevo modelo de DataTable para serializar la información. Puesto que se almacena información más concreta, se pueden abordar muchos má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 modelo de 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, la tarea 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 de la 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 la estructura de un programa en varias capas. Un de esas capas es la de datos, que es fundamental desarrollar correctamente. Gracias a los Datasets/DataTables, la tarea de portar y aumentar los procesos de datos y de negocio será más sencillo: el intercambio de información a través de XML, hace que sea más sencilla la tarea de estructurar en más capas la aplicación, lo que la hace mucho más modular y mantenible.

Además, en el nuevo modelo de clases Adaptadoras de .NET 4.0 y las herramientas de VS 2010, es posible definir todo un modelo lógico de clases que encapsulan la complejidad de la base de datos. De esta forma, cualquier cambio en la BDD (capa de datos) no necesariamente implica cambiar código en la capa de servicio de datos (consumidor cliente de los datos). Esta herramienta ya estaba disponible en .NET 1.1 mediante los Datasets con tipo. Pero en esta versió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 las herramientas que se requieren, y además con la posibilidad de mantener y ampliar su esquema con muchos más servicios, independientemente de cómo esté implementado en la BDD. Lo que 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 muchos rodeos. Un ejemplo de código sin tipificar: Ejem

plo

de te

xto

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

16

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

Como se puede observar, aparecen nombres de objetos genéricos del sistema que complican la lectura del código, a la par que los operadores complican también la visión de la secuencia de acceso 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 los objetos 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 nuestras palabras el modelo de objetos de datos que necesitamos en cada momento. Incluso a nivel de ejecució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.

En el nuevo API de ADO.NET 4.0, incluso podremos mapear columnas, encapsular llamadas a 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 que no tenemos que estar comunicándonos por Marshalling con el servidor. Además, gracias al modelo 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, en ADO.NET 4.0 se han extendido las funcionalidades de Serialización. Me explico. En ADO.NET 1.1 el movimiento masivo de datos entre capas empleando DataSet puede producir cuellos de botella debido a la redundancia de los datos XML y su XSD de validación. Existen contextos 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 abiertos compatibles 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 natu-raleza de internet. Los servidores son capaces de atender muy bien decenas y decenas de co-nexiones. Pero cuando hablamos de miles y millones, los servidores ya no son capaces de rea-lizar correctamente su trabajo. Esto es debido a que por cada usuario se mantiene una memoria Ejem

plo

de te

xto

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

17

de proceso y conexión, un conjunto de bloqueos de recursos como puedan ser tablas, índices... y una comprobación de sus permisos. Lo que lleva su tiempo y recursos. ADO.NET favorece la escalabilidad puesto que su modelo de conexión Off-Line evita que se mantengan los recur-sos reservados más tiempo del considerado necesario. Y esto permite que más usuarios por unidad de tiempo puedan acceder a la aplicación sin problemas de tiempos. Además se pueden montar servicios en Cluster de alta disponibilidad que serán balanceados automáticamente por el sistema sin afectar a las conexiones ADO. Lo cual garantiza la ampliación del servicio sin representar un cambio de arquitectura de diseño.

ADO.NET: Arquitectura de datos desconectados ADO.NET está basado en una arquitectura desconectada de los datos. En una aplicación de datos se ha comprobado que mantener los recursos reservado mucho tiempo implica reducir el número de usuarios conectados y aumenta el proceso del sistema al mantener una política de bloqueos y transacciones. Al mismo 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.

Con ADO.NET se consigue estar conectado al servidor sólo estrictamente necesario para realizar la operació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 su diseño y situación de proceso? Por ejemplo, una aplicación de alquiler de películas, o un sistema de venta 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 de objetos de ADO.NET conectado. Pero en el API de ADO.NET 4.0 se cubre mucho mejor el hueco que existe 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 DataTables

De toda la vida, el recoger información de una base de datos ha ido destinado a realizar un proceso con dicha 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 de tablas). Una vez que estos datos son cargados, la aplicación los trata como un bloque compacto. En un modelo desconectado, es inviable el tener que conectar con la base de datos cada vez que avanzamos un 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 y trabajar 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 de almacenamiento virtual, y que contiene una o más tablas basadas en las tablas reales de la base de datos. 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, que los 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” en cuanto a datos se refiere. Ej

empl

o de

text

o

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

18

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 puede ser enviado -en forma de flujo XML- entre distintos componentes de la capa de negocio como si de una 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ás pequeñ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-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 la clase Dataset contenedora. Eso si, siguen siendo partes constitutivas, lo cual quiere decir que siguen conviviendo juntos como hasta ahora… pero con la salvedad de que ahora DataTable es mayor y es capaz de vivir por su cuenta cuando sea menester.

Los DataSets/DataTables son independientes de los orígenes de datos

Una 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ódigo SQL, actualmente no es tan estándar...).

Esto nos permitirá trabajar con múltiples orígenes de datos, de distintos fabricante e incluso no -base de datos -como por ejemplo ficheros planos u hojas de cálculo-... lo que representa un importante pun-to de 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 XML

La persistencia es un concepto muy interesante en el mundo del desarrollo. Es un mecanismo por el cual 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 mecanismo fundamental. Podemos cerrar la aplicación y mantener persistentes todos los DataSets necesarios, de manera que al reiniciarla, nos encontramos los DataSets tal y como los dejamos. Ahorrando el tiempo Ej

empl

o de

text

o

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

19

que hubiera sido necesario para recuperar de nuevo toda esa información del servidor. Optimizando todaví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 de la industria, esta persistencia nos ofrece:

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

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

Los Esquemas: “Metadatos” de los documentos XML

Muchas 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 se estructura 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 que establece una manera común de introducir nuevos datos respetando un juego de reglas básico, que toda aplicació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 base de datos son automáticos y transparentes al usuario. No se necesitará acceder a ellos a bajo nivel, a menos que sea requisito del diseño. Dichos esquemas se actualizarán cuando se modifique la base de datos o las consultas empleadas para acceder a los datos. Lo dicho, todo transparente al usuario. Y proporcionarán toda la información necesaria para leer la estructura del dataset (que corresponderá con la 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:

Ejem

plo

de te

xto

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

20

Figura 3. Esquema XML de la tabla Usuarios

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

Componentes de ADO.NET

Veamos 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 una Ejem

plo

de te

xto

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

21

base 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 de ejecución de comandos SQL.

Tabla 1

Como se puede observar, los datos son recogidos del servidor por los componentes DataSetCommand mediante la ejecución de comandos SQL (procedimientos almacenados, vistas, consultas...) en el componente de negocio por los objetos DataSets. Empleando la interfaz XML, estos componentes entregan la información al nivel de interfaz de usuario, que a través de entornos WEB, formularios está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 visualizables en un navegador.

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

BizTalk4 Conjunto de herramientas cliente- servidor que permiten automatizar los procesos de negocio.

Tabla 2

En los siguientes temas, se procederá a la documentación de las distintas clases .Net dedicadas a las tareas 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 ma-yoría de clases que habilitan el acceso a los datos de la arquitectura .NET

System.Data-.Common

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

Sys-tem.Data.SqlClient

Espacio de nombres que permite el acceso a proveedores SQL Server en su versión 7.0 y superior. Este espacio de nombres ha sido ampliado para soportar las nuevas característi-cas de SQL Server 2005.

2 WebForms y Winforms se analizan en el texto de EIDOS dedicado al frameWork de desarrollo de Visual Studio .NET 3 ver (1) 4 Para más información acerca de BizTalk Server, vea la página de Microsoft http://www.microsoft.com/biztalk 5 ver el punto siguiente “los proveedores gestionados de datos”. Ej

empl

o de

text

o

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

22

Nombre de la clase

Descripción

System.Data.Sql Espacio de nombres con multitud de herra-mientas para interactuar con el nuevo motor de SQL Server 2005: enumeración de servido-res, 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 directamente 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 modelo de dri-vers ODBC de Windows. Emplean InterOp para acceder a los drivers nativos ODBC, pero proporcionan un marco de compatibilidad hacia atrás muy importante para muchos fa-bricantes de SW.

System.Data.-Oracle

Espacio de nombres, desarrollado por Micro-soft, que posibilita el acceso a recursos de sistemas gestores de Oracle. Dependen del cliente nativo de Oracle instalado en la máquina. Es recomendable que accedáis a la web del fabricante para acceder 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 de datos.

System.Data-.SqlTypes

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

Tabla 3

Arquitectura orientada a conexión La otra aproximación posible a la resolución de contextos de datos es la de vivir conectados a los mismos. Una aplicación de estar conectada con el sistema gestor para acceder en “tiempo real” a los datos 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 a los mecanismos por los cuales un programa puede acceder a los recursos de un servidor de bases de datos. 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 de Microsoft. Un conjunto de componentes que encapsulan el acceso, manejo de cursores y comunica-Ej

empl

o de

text

o

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

23

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 los recursos 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 es el 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 componentes intermedios para realizar una acción, ni perder funciones específicas por compatibilidad con otras plataformas.

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

SQL Managed Provider. Ofrece el conjunto de clases necesarias para comunicarse con los comandos de SQL Server en su versión 7.0 ó superior. Especial hincapié en que este espacio de nombres ha sido evolucionado para soportar las nuevas tecnologías de SQL Server 2008, 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 de datos accesible a través de drivers OLEDB/ODBC. En las mejoras de ADO.NET 4.0 el haber ampliado 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 nativa de Windows. No se garantiza en todos los casos el mismo soporte por parte del CLR, pero se ha extendido la funcionalidad para soportar más y mejores características de los más potentes y 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ólogos ODBC/OLEDB.

La arquitectura de los .NET Provider

Toda clase que aspire a .NET Provider, debe cumplir que en su espacio de nombres implemente las clases derivadas de:

Connection. Que será la clase encargada de encapsular toda la funcionalidad de conexión a las 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 una Query

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.

Ejem

plo

de te

xto

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

24

Figura 5. Modelo de clases de ADO.NET

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

SqlConnection

SqlCommand

SqlDataReader

SqlDataAdapter

Además, los .NET Providers tienen la capacidad de enviar/recibir y almacenar persistentemente de manera 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 provee-dor 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 (conexiones ODBC a través de drivers OLEDB)

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

Tabla 4

En la actualidad el soporte de terceros a la plataforma .NET ha crecido hasta prácticamente ofrecer proveedores 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. Ej

empl

o de

text

o

Page 27: Acceso a Datos Con ADO .NET 4.0 (Ejemplo)

25

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

Una nueva aproximación: Factorías de conexiones

En ADO.NET 2.0 se ha evolucionado el modelo de los proveedores de tal forma que no sólo contemos con conexiones con proveedores concretos conocidos de antemano, sino que además podamos en tiempo de ejecución elegir el proveedor que necesitamos. Esto facilita la generación de arquitecturas de 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 no iban encaminadas a estos menesteres. Casi se sugería que era responsabilidad del programador el crear un modelo de servicio para hacer el código más abstracto, no haciendo fácil la cara dinámica de clases como 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 al final la complejidad de análisis y su puesta en producción apostaba a por modelos más sencillos, en los que era el propio desarrollador el que se montaba la capa de servicios de datos y la reemplazaba en el caso de cambiar de sistema gestor.

Pero en la versión 2.0 de ADO.NET se ha escuchado a todos los desarrolladores que demandaban esta funcionalidad. Y se ha implementado de una forma muy elegante, siendo una opción más en el SDK que 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.

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

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

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

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

b) Las nuevas características del CORE de SQL Server 2008. Que hacen que el servidor ofrezca mejores herramientas, y un lenguaje TSQL más potente y con más funcionalidad que el 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 de-sarrolladores a interactuar de un modo más concreto con todo el motor de la base de datos, au-tomatizando virtualmente cualquier tarea del sistema gestor. A la par que hay más y mejores Ejem

plo

de te

xto

Page 28: Acceso a Datos Con ADO .NET 4.0 (Ejemplo)

26

herramientas de tolerancia a fallos, alta disponibilidad, etc., que permitirá el desarrollo de sis-temas má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 BDD

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

Nuevas herramientas de diseño de capas de datos Una de las mayores novedades ya incluidas en ADO.NET 2.0 y mantenida y mejorada en ADO.NET 4.0, está en el nuevo soporte que da para la construcción de capas de datos. Entendiendo por capa de datos la abstracción lógica que montamos para independizar una capa lógica de aplicación de capas de más bajo nivel. Para esto, ADO.NET ofrece dos nuevos frameworks de encapsulación de la capa de datos:

a) Mejores controles vinculados a datos. Nuevos controles, evoluciones de los anteriores… el caso es que hay un 20% de mejoras en las tecnologías de MS de DataBinding. Muchas más propiedades que antes, que mejoran la productividad a niveles impresionantes. Baste decir que montar un formulario maestro/detalle nos lleva escasos 5 minutos, que cargar una combo a partir 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 picar prácticamente código.

b) Una arquitectura de acceso a datos basada en los esquemas de datos. Totalmente integra-do con VS 2010, la posibilidad de generar una capa de acceso a datos totalmente encapsulada en clases, basada en la descripción del modelo de datos a partir de esquemas XSD. A partir de dicho 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 cualquier momento, 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 texto En todos los capítulos, debajo del código fuente tendréis especificada la carpeta del proyecto del que se está hablando en cada momento. Ej

empl

o de

text

o

Page 29: Acceso a Datos Con ADO .NET 4.0 (Ejemplo)

27

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

empl

o de

text

o