linq - contenido lenguaje integrado de consultas

LENGUAJE INTEGRADO DE CONSULTAS LINQ 2008

Investigadores: Tngl. Andrs Len O. - Ing. Jorge Ochoa Pgina 1

1. INTRODUCCION

1.1 Qu es LINQ?

En la actualidad las empresas que anhelan tener xito en el mercado deben implementar

Sistemas Informticos que les permitan intercambiar informacin con el mundo externo.

De ah comenzaron a surgir ideas para que las aplicaciones puedan comunicarse entres s.

Empezaron a aparecer los compiladores que tenan un lenguaje intermedio como .NET

que dispona del MSIL, JAVA tambin tena sus propios proyectos, etc. Y finalmente se

desarrollaron estndares para el envo y recepcin de los datos que necesitaban los

programas.

Sin embargo estos estndares tambin requieren tener una forma de conexin para

consultar y modificar los datos que en ellos se encuentran, lo que ocasionaba que los

desarrolladores tengan que aprender diferentes tipos de conexiones, diferentes

sentencias, e incluso trabajar con diferentes tipos de variables. Adicionalmente cuando se

tena que interactuar con fuentes de datos de dismiles tipos; el excesivo uso de variables

y conexiones poda ocasionar que las aplicaciones se hagan lentas y pesadas.

Con el avance de la programacin orientada a objetos los desarrolladores estn muy

familiarizados con el manejo de objetos, clases, etc. Pero las formas ms utilizadas para

almacenar la informacin son bases de datos relacionales y archivos XML, que

precisamente NO SON ORIENTADAS A OBJETOS. Adems tenamos una forma de conexin



a los datos que se encontraban en las BD y otra manera diferente para acceder a las

fuentes o archivos XML.

ARQUITECTURA LINQ

Languaje Integrated Query o lenguaje integrado de consultas. Es el nuevo proyecto de

Microsoft que brinda consultas semejantes a las nativas de SQL. Define operadores de

consulta estndar permitiendo a los lenguajes habilitados con LINQ filtrar y crear

proyecciones de varios tipos de colecciones usando la misma sintaxis. Tales colecciones

pueden incluir arreglos, bases de datos relacionales de SQL Server, archivos XML y bases

de datos de terceros. Inicialmente LINQ ha sido implementado en el framework 3.0 y

brinda su potencial a los lenguajes de C# y Visual Basic 9.



LINQ a SQL es una extensin de ORM (Mapeador de Objetos Relacionales) que nos

permite modelar bases de datos relacionales con Visual Studio .NET 2008, permitiendo

consultar, agregar, modificar y eliminar registros de las bases de datos y tratarlas como si

fuesen clases del .NET.

Los programadores pueden utilizar LINQ con cualquier fuente de datos inclusive

consultando informacin que se encuentre en un determinado tipo de fuente, modificarla

en memoria y guardarla en otra fuente de datos.

EJEMPLO: Para hacer las declaraciones de los impuestos fiscales se podra escribir

sentencias LINQ que saquen informacin de las bases de datos relacionales y por medio

del mismo Lenguaje Integrado de Consultas generar los archivos XML que debern ser

enviados a las autoridades encargadas de recaudar estos valores.

Como ya lo hemos mencionado antes LINQ, no es solo conexiones a bases de datos

relacionales y archivos XML, este proyecto permite al programador conectarse a cualquier

origen de datos que cumpla con una sola condicin: EL ORIGEN DE DATOS DEBE SER

COMPATIBLE CON LA INTERFAZ IENUMERABLE

Esto debido a que al escribir la sentencia LINQ no significa que los datos ya estn en

memoria, sino que estos son trados al momento de ejecutar las instrucciones en un bucle

foreach y por eso que es indispensable el uso de esta interfaz.



EJERCICIO 1 El siguiente ejemplo, presenta la lista de nmeros que sean menores al rango

que defina el usuario.

private void btnPresentar_Click(object sender, EventArgs e) {

int[] vector = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

//CONSTRUIMOS LA CONSULTA

var Consulta = from numero in vector

where numero < tbRango.Value

select numero;

string cadena="Los numeros menores a "+tbRango.Value+" son: ";

foreach (int valor in Consulta)

{

cadena = cadena + valor.ToString() + " ";

}

MessageBox.Show(cadena.Trim(), "Resultado");

}

Nota: El hecho de crear la consulta no significa que ya dispongamos de los datos, sino es al

momento de ejecutar la misma en donde se puede obtenerlos y este proceso se realiza

precisamente en el bucle ForEach.

La tecnologa LINQ brinda tantas ventajas al desarrollador como es la caracterstica de

Intellisence que le evita problemas de sintaxis al momento de trabajar con la informacin.

Antes de que aparezca este lenguaje todas las sentencias SQL que se escriban en las

aplicaciones se lo haca a travs de una variable de tipo string. Ejemplo:

string InstruccionSQL=Select * fro clientes



Como podemos observar en la sentencia SQL anterior el desarrollador ha escrito de forma

incorrecta la palabra reservada from, al ser una cadena esto no ser reconocido como

un error, mientras que con las bondades de este lenguaje que pone al servicio del

programador la caracterstica Intellisence se detectara inmedianamente.

1.2 HISTORIA

Despus de dos dcadas, la industria ha alcanzado un punto estable en la evolucin de las

tecnologas de programacin orientada a objetos. Hoy en da los programadores estn

familiarizados con conceptos como las clases, objetos y mtodos. Analizando la

generacin de tecnologas actual y siguiente, se hace evidente que el siguiente gran reto

para la tecnologa de la programacin es reducir la complejidad del acceso e integrar la

informacin que no se define de manera nativa utilizando la tecnologa orientada a

objetos.

En vez de aadir caractersticas especficas para el tratamiento de datos relacionales o

XML a nuestros lenguajes de programacin y motor de ejecucin, con el proyecto LINQ

hemos seguido un enfoque ms general, y estamos aadiendo a .NET Framework

facilidades de consulta de propsito general aplicables a todas las fuentes de informacin,

y no solo a los datos relacionales o XML. Esta facilidad se llama Consultas integradas en

los lenguajes.



Utilizamos el trmino consultas integradas en los lenguajes para indicar que las consultas

son una caracterstica constituida en el framework que utiliza el lenguaje de programacin

principal del desarrollador (por ejemplo C# 3.0, Visual Basic 9). Las consultas embebidas

en los lenguajes permiten que las expresiones de consulta se beneficien de los metadatos

ricos, verificacin de sintaxis en tiempo de compilacin, tipado esttico y ayuda

IntelliSense que antes estaban disponibles solo para el cdigo imperativo. Las consultas

integradas en el framework que utilizan los lenguajes tambin hacen posible aplicar una

nica facilidad declarativa de propsito general a toda la informacin en memoria, y no

solo a la informacin proveniente de fuentes externas.

Las consultas integradas en el framework 3.0 para los lenguajes de Visual Studio .NET

2008 definen un conjunto de operadores de consulta estndar de propsito general que

hacen posible que las operaciones de recorrido, filtro y proyeccin sean expresadas de

una manera directa pero declarativa en cualquier lenguaje de programacin. Los

operadores de consulta estndar permiten aplicar las consultas a cualquier fuente de

informacin basada en IEnumerable. LINQ permite que terceros fabricantes aumenten

el conjunto de operadores de consulta estndar, aadiendo los operadores de dominio

especfico que sean apropiados para el dominio o la tecnologa de destino. Ms

importante an es que terceros fabricantes tambin pueden reemplazar los operadores

de consulta estndar con sus propias implementaciones que ofrezcan servicios adicionales

como la evaluacin remota, traduccin de consultas, optimizacin, etc. Al adherirse a los



convenios del patrn LINQ, tales implementaciones gozarn de la misma integracin en

los lenguajes y soporte de herramientas que los operadores de consulta estndar.

La extensibilidad de la arquitectura de consultas es aprovechada por el propio proyecto

LINQ para ofrecer implementaciones que operan sobre datos XML y SQL. Los operadores

de consulta sobre XML (XLinq) utilizan una facilidad de XML en memoria interna eficiente

y fcil de usar para ofrecer funcionalidad XPath/XQuery dentro del lenguaje de

programacin husped. Los operadores de consulta sobre datos relacionales (DLinq) se

apoyan en la integracin de definiciones de esquemas basadas en SQL en el sistema de

tipos del CLR. Esta integracin ofrece un fuerte control de tipos sobre los datos

relacionales, a la vez que mantiene la potencia expresiva del modelo relacional y el

rendimiento de la evaluacin de las consultas directamente en el almacn de datos

subyacente.

En un principio LINQ ha sido desarrollado especficamente para los lenguajes de C# 3.0 y

Visual Basic .NET 9, pero tambin se puede adicionar esta funcionalidad aunque no de

manera completa a estos dos lenguajes en la versin de Visual Studio 2005 haciendo una

actualizacin del framework. Tambin se han manifestado fabricantes de otras lneas

sobre el inicio de la implementacin de las consultas embebidas en los lenguajes de su

autora.



1.3 FUNCIONALIDAD DE LINQ

La funcionalidad que nos brinda LINQ radica en la posibilidad de conectarse con diferentes

fuentes de informacin utilizando la misma sintaxis para consultar, agregar, modificar y

eliminar los datos que se encuentren en ellas. Esto permite que los programadores que

aprendan este lenguaje no necesiten conocer diferentes tecnologas para hacer que sus

aplicaciones puedan intercambiar o utilizar informacin que se encuentra almacenada en

dismiles formatos. Al analizar detenidamente esta ventaja nos damos cuenta que el

desarrollador puede dedicar mayor tiempo a concentrarse en lo que respecta a las

polticas del negocio, tambin podr distribuir la forma de registrar los datos que utilizan y

comparten sus aplicaciones en diferentes fuentes mejorando el rendimiento del cdigo

que escriba.

Por ejemplo un sistema contable de una empresa necesita informacin de proveedores,

clientes, cuentas contables, productos, etc; que por lo general se encuentran en una base

de datos relacional y todas las transacciones que la empresa realice durante el periodo

contable se almacena en la misma base de datos relacional.

Pero si la empresa requiere compartir informacin con otras instituciones que utilizan los

mismos datos pero diferentes aplicaciones e inclusive diferentes bases de datos entonces

lo debe hacer a travs de algn estndar como XML. LINQ, hace que todo este proceso

que antes era muy laborioso para los desarrolladores se simplifique considerablemente ya



que con una misma sintaxis se conecta a su base de datos, obtiene la informacin que

necesita, crea los documentos XML, registra el contenido y lo puede enviar.

La tecnologa LINQ puede ser utilizada tanto para ambientes de oficina como para

desarrollar aplicaciones Web, es decir que el programador no solo que podr hacer uso de

los procedimientos almacenados, sino que tambin lo puede combinar con los beneficios

que nos brinda los servicios web e incluso una arquitectura SOA que este bien

implementada. Aclarando que SOA no son Servicios Web, por el contrario los Servicios

Web son tan solo una parte de la Arquitectura SOA.

1.4 CONCEPTOS GENERALES

1.4.1 OPERADORES BSICOS CON LINQ

Nosotros podemos construir instrucciones LINQ de la misma forma que se hace con SQL,

haciendo agrupaciones, ordenando, indicando que campos deseamos presentar, tambin

podemos utilizar los operadores AND y OR, con la nica diferencia que:

AND Se representa con &&

OR Se representa con ||

Las consultas combinadas en LINQ se realizan a travs de las claves externas que se

representa en el modelo como propiedades que tienen una coleccin de elementos, pero



tambin aunque no muy a menudo se puede utilizar el operador JOIN siempre y cuando se

est trabajando con colecciones de objetos, que a diferencia de SQL se lo hace con tablas.

Es tan extenso las clusulas SELECT, GROUP, ORDER, etc. Que para poder explotar todo el

potencial que estas nos ofrecen deberamos realizar un estudio a fondo de cada una de

ellas pudiendo ser solo esta clusula tema de una monografa completa.

1.4.2 VARIABLES CON TIPO IMPLICITO

Esta es una nueva caracterstica que nos ofrece C# 2008, una variable con tipo implcito se

lo declara anteponiendo la palabra var, lo que significa que el compilador ser el

encargado de identificar el tipo de variable, Como podemos ver en el EJERCICIO #1 las

consultas LINQ se declaran de esta manera sin embargo esto no significa que var este

orientado nicamente a LINQ sino mejor es una funcionalidad del lenguaje que nosotros la

podremos utilizar cuando creamos necesario. EJEMPLO:

var Valor=5; var Bandera=false; var Nombre=Mariana;

1.4.3 FUNCIONES ANONIMAS

1.4.3.1 Mtodos Annimos

Qu es un delegado?

Los mtodos annimos aparecen con la versin 2.0 del Framework, la intencin es

simplificar el proceso de manejadores de eventos, pero esto implica tener un

conocimiento bsico sobre el funcionamiento de los delegados, es por esto que este tema

hemos iniciado realizando la pregunta.



Los mtodos annimos buscan definir el mtodo al momento de declarar el delegado, de

esta forma podemos ahorrar lneas de cdigo ya que evitamos tener que crear funciones

para resolver tareas simples. Sin embargo la lectura del cdigo tambin se complica un

poco.

Los mtodos annimos aparecieron desde C# 2005 con el Framework 2.0 y estaban

pensados para facilitar la definicin de manejadores de eventos cuando las tareas a

realizar son simples.

button1.Click += delegate{ MessageBox.Show("Hola"); }; Y si requiere utilizar parmetros solo cambiara por lo siguiente: button1.Click += delegate(object sender, EventArgs e){ MessageBox.Show(e.ToString()); };

Netdeveloper Jose Manuel Alarcn.

En el ejemplo se ha creado un mtodo annimo y lo que se ha evitado es la creacin del mtodo tradicional del botn para que presente el mensaje Hola: Private void button1_Click(object sender,System.EventArgs e) {

MessageBox.Show(Hola); }

1.4.3.2 Expresiones LAMBDA

Aunque el ejemplo que hemos expuesto cuando definimos los mtodos annimos es

bastante sencillo, en la prctica necesitaremos crear instrucciones con una dificultad

mayor a la que pusimos en nuestro ejercicio lo que obviamente repercutir en la

complejidad de los mtodos annimos.



Las expresiones lambda son propias de C# 3 y nos permiten hacer lo mismo que los

mtodos annimos pero de una forma ms sencilla. Una de las caractersticas de las

expresiones lambda es el signo lambda que se representa con =>.

Esta forma de programar abre la posibilidad de que nuestros programas llamen a otros

programas, podemos utilizar a lambda como entidades de cdigo o de datos y son de

mucha utilidad al momento de escribir instrucciones LINQ.

1.4.4 Interfaz IEnumerable

La interfaz IEnumerable se inicia desde el Framework 2.0 y hereda de la Interfaz

IEnumerable, Esta interfaz tiene como objetivo proveer de un mecanismo de iteracin

sobre los elementos de una secuencia generalmente buscando facilitar la utilizacin de un

bucle foreach.

En LINQ, la interfaz IEnumerable tiene una particularidad especial ya que cualquier

tipo de datos que la implemente puede servir directamente como fuente para expresiones

de consultas, en especial los arrays y las colecciones genricas.

La estructura de esta Interfaz es similar al cdigo que se expone a continuacin:



// System.Collections.Generic public interface IEnumerable : IEnumerable{IEnumerator GetEnumerator();}

// System.Collections

public interface IEnumerable{IEnumerator GetEnumerator();}

// System.Collections.Generic

public interface IEnumerator : IDisposable, IEnumerator

{

T Current { get; }

}

// System.Collections

public interface IEnumerator

{

object Current { get; }

void Reset();

bool MoveNext();

}

Nuevamente, la interfaz se apoya en su contrapartida no genrica. En conjunto, IEnumerator debe implementar los siguientes miembros:

La propiedad Current, que devuelve el elemento actual de la secuencia (a dos

niveles).

El mtodo Reset(), que restablece la enumeracin a su valor inicial.

El mtodo MoveNext(), que desplaza el enumerador al siguiente elemento de la

secuencia. Devuelve false cuando se llega al final de la secuencia.

El mtodo Dispose(), que libera cualesquiera recursos no administrados asociados

al enumerador.

La clase que implemente IEnumerator deber encargarse de mantener el estado

necesario para garantizar que los mtodos de la interfaz funcionen correctamente.

Por qu esta separacin en dos niveles, en la que bsicamente IEnumerable es de un

nivel ms alto, mientras que IEnumerator se encarga del trabajo sucio? Por qu no

dejar que las colecciones implementen directamente IEnumerator? La respuesta tiene

que ver con la necesidad de permitir la ejecucin de iteraciones anidadas sobre una



misma secuencia. Si la secuencia implementara directamente la interfaz enumeradora,

solo se dispondra de un estado de iteracin en cada momento y sera imposible

implementar bucles anidados sobre una misma secuencia, como por ejemplo los que se

encuentran en la implementacin tpica de la ordenacin mediante el algoritmo de la

burbuja. En vez de eso, las secuencias implementan IEnumerable, cuyo mtodo

GetEnumerator() debe producir un nuevo objeto de enumeracin cada vez que es

llamado.

Por qu IEnumerable?

Toda consulta LINQ que escribamos contiene el cdigo que se va a ejecutar para consultar

o modificar los datos que tenemos en las diferentes fuentes. Pero la consulta solo se

ejecutar el momento en que se ejecute el bucle foreach.

1.4.5 XML READER Y XMLWRITTER

Son clases que implementa .Net para realizar la lectura y escritura de archivos XML, como

sus nombres lo indican XMLReader se encargar de los procesos de lectura mientras que

XMLWritter realizar la escritura.

XMLReader permite leer archivos XML sin realizar la carga en cach y evitando la lectura

de los nodos no deseados. Es una clase abstracta que se encuentra en el namespace

System.Xml.



Estas clases ofrecen un alto potencial para trabajar con informacin contenida en

formatos xml, por lo que un programador que conozca el funcionamiento XMLReader,

XMLWritter y LINQ, si combina todas estas herramientas estar en capacidad de escribir

cdigo potente y gil para realizar consultas, modificar documentos y a travs de este

formato intercambiar informacin con otras aplicaciones.

1.4.6 XSD (Scheme Language)

El lenguaje de esquema nos permite definir la estructura y las restricciones que tienen los

archivos XML, fue desarrollado por WC3, este lenguaje permite tener un alto nivel de

abstraccin que nos da una mejor percepcin del documento XML.

XSD, no tiene una definicin comn para sus siglas pero respecto al significado de su

funcionalidad todos concuerdan que es un lenguaje que nos da una mejor visin de la

estructura de los documentos XML con lo que vamos a trabajar.

1.4.7 XSLT (Extensible SteelShetLanguage Language Transform)

Tambin desarrollado por WC3. Es un estndar que permite transformar los documentos

XML en otros incluso a formatos que nos sean xml, para esto se basa en reglas de

plantillas que se enlazan al documento que va a ser transformado.

No solamente es utilizado en aplicaciones Windows sino tambin est orientado a la web

ya que permite separar el contenido de la presentacin aumentando la productividad.



1.4.8 Mtodos Extendidos

Es otra de las nuevas funcionalidades que nos brinda el Visual Studio 2008, consiste en la

posibilidad de agregar nuestros propios mtodos a las clases del .NET o cualquier clase

que nosotros queramos, encontrndole uno de los mayores beneficios en la facilidad de

hacer validaciones. Se visualiza en el wizard con su nombre el signo de mtodo y una

pequea flecha que significa extendido.

EJEMPLO: Cuando solicitamos al usuario que ingrese la cdula la recibimos como una

cadena. Si nosotros utilizamos mucho el proceso de validacin de cdula entonces al

implementar este mtodo como una extensin de la clase string cada vez que declaremos

una variable de este tipo aparecer nuestro mtodo como uno ms de la clase.



2. CONEXIONES CON LINQ

2.1 FUENTES A LAS QUE SE PUEDE CONECTAR

Los orgenes de datos representan los datos con los que ya se sabe vamos a trabajar en la

aplicacin, se muestran en la ventana orgenes de datos y se pueden crear a partir de

bases de datos de datos, archivos locales o incluso de objetos.

Visual Studio proporciona herramientas en tiempo de diseo para crear y editar los

orgenes de datos que va a utilizar en su aplicacin, en los proyectos de Visual Studio los

orgenes de datos se representan como conjuntos de datos u otros tipos de objeto,

dependiendo de los objetos que devuelva el almacn de datos subyacente.

Los orgenes de datos para trabajar con LINQ son:

- LINQ a XML.- Nos permite conectar con orgenes de datos XML.

- LINQ a SQL.- Permite la conexin con bases de datos SQL Server, es como si este

motor tuviera una funcionalidad del Lenguaje Integrado de consultas dedicada

exclusivamente para l.

- LINQ a Entidades.- Permite que la aplicacin se conecte con bases de datos que

nos sean SQL Server.

- LINQ a DataSet.- tambin conocido como LINQ a objetos, que admite realizar las

mismas operaciones que normalmente se hacen con las bases de datos con

objetos DataSet y DataTable.



Nota: Debido a lo extenso que es la tecnologa LINQ, en esta investigacin haremos una

introduccin a las dos primeras formas de conexin. Explicando cmo LINQ las define y

trabaja con cada una de ellas y en los siguientes captulos se harn ejemplos de consultas

(SELECT), tambin haremos operaciones de insertar, editar y eliminar datos (INSERT,

UPDATE, DELETE y finalizaremos indicando como ejecutar procedimientos almacenados

desde LINQ.

2.1.1 LINQ A XML

2.1.1.1 INTRODUCCION

En la actualidad todas las empresas han comenzando a construir aplicaciones que estn

orientadas a la web y no solamente a los tradicionales ambientes de oficina; siendo XML el

formato que ha quedado definido como el estndar para realizar esta tarea.

LINQ a XML no es otra cosa que proporcionar toda la potencialidad del Lenguaje

Integrado de Consultas aplicado a la informacin que se encuentra contenida en este

formato, permitindonos leer y modificar estos archivos de forma parecida a como lo

hacamos en versiones anteriores de .Net a travs de XMLReader y XMLWritter pero con

una notable mejora en el consumo de memoria y la cantidad de cdigo que debemos

escribir para obtener los mismos resultados, adicionando la ventaja que con esta nueva

tecnologa podemos conectarnos y trabajar con otras fuentes de datos que a diferencia de



las clases que se utilizaban en versiones anteriores para trabajar con XML son nica y

exclusivamente para este formato.

2.1.1.2 Estructura Jerrquica de LINQ a XML

2.1.1.3 Ventajas de utilizar LINQ a XML:

Visin simplificada de los archivos XML.- Ya no tenemos que acceder a los nodos de los

arboles XML a travs de un documento, En LINQ se puede tratar tanto al documento

como a los nodos que lo conforman como un XElement.

Proporciona una identificacin a los nodos de los archivos XML.- Podemos dar un nombre

a cada elemento de nuestro rbol XML a travs de la propiedad XName, esta utilidad ser

de gran ayuda al momento de realizar copias, reemplazos o al renombrar los Nodos.

Creacin de estructuras XML.- El Ejercicio 1 expone la gran facilidad con la que se puede

crear estructuras XML a travs del Lenguaje Integrado de Consultas.



Memoria.- Mejor uso de los recursos de memoria, lo que ayudar a mejorar el

rendimiento de nuestras aplicaciones.

Acceso a datos.- Permite leer y modificar los nodos de los archivos XML con sentencias

muy similares a SQL y tomando en cuenta que LINQ tambin implementa conectividad con

bases de datos los desarrolladores pueden consultar las dos fuentes con una misma

sintaxis.

Tratamiento de Tipos de Variable.- LINQ a XML permite tratar el contenido de los

elementos y atributos respetando sus tipos con tan solo hacer un cast.

Elementos principales.- Los elementos bsicos para trabajar con formatos XML a nuestro

criterio son XElement y XAttribute. Aunque otros desarrolladores tambin incorporan a

XName, nosotros hemos preferido no hacerlo. Como ya hemos explicado antes XName es

una gran innovacin pero respaldados en los ejercicios que se han desarrollado en esta

investigacin creemos que no se lo debe tratar como un elemento bsico de LINQ.

EJERCICIO 1

Crear un archivo XML, que contenga la informacin bsica de una persona. Para poder

probar el ejercicio deber crear un formulario con dos botones el uno para la forma



tradicional y el segundo utilizando el lenguaje Integrado de Consultas, adems deber

agregar los namespaces System.Xml y System.Xml.LINQ (using) :

1.- Forma Tradicional XmlDocument DocumentoXML = new XmlDocument();

XmlElement nodPersona = DocumentoXML.CreateElement("Persona");

DocumentoXML.AppendChild(nodPersona);

XmlElement nodContacto = DocumentoXML.CreateElement("Contacto1");

nodPersona.AppendChild(nodContacto);

XmlElement nodCedula = DocumentoXML.CreateElement("Cdula");

nodCedula.InnerText = "0128928212";

nodContacto.AppendChild(nodCedula);

XmlElement nodNombre = DocumentoXML.CreateElement("Nombre");

nodNombre.InnerText = "Juan Carlos Prez Maldonado";

nodContacto.AppendChild(nodNombre);

XmlElement nodDireccion = DocumentoXML.CreateElement("Direccin");

nodDireccion.InnerText = "Av. De las Amricas y Batn";

nodContacto.AppendChild(nodDireccion);

XmlElement nodTelefonos = DocumentoXML.CreateElement("Telfonos");

Contacto.AppendChild(nodTelefonos);

XmlElement nodTelCasa = DocumentoXML.CreateElement("Convencional1");

nodTelCasa.SetAttribute("Hogar", "2890654");

nodTelefonos.AppendChild(nodTelCasa);

XmlElement nodTelTrabajo = DocumentoXML.CreateElement("Convencional2");

nodTelTrabajo.SetAttribute("Oficina", "2847241");

nodTelTrabajo.SetAttribute("Desde", "09H00 AM");

nodTelTrabajo.SetAttribute("Hasta", "19h00 PM");

nodTelefonos.AppendChild(nodTelTrabajo);

XmlElement nodTelCelular = DocumentoXML.CreateElement("Celular");

nodTelCelular.SetAttribute("Celular", "098213125");

nodTelefonos.AppendChild(nodTelCelular);

DocumentoXML.Save("d:\\SinLINQ.xml");

2.- Utilizando LINQ XElement Persona =

new XElement("Persona",

new XElement("Contacto1",

new XElement("Cdula", "0128928212"),

new XElement("Nombre", "Juan Carlos Prez Maldonado"),

new XElement("Direccin", "Av. De las Amricas y Batn"),

new XElement("Telfonos",

new XElement("Convencional1",

new XAttribute("Hogar","2890654")),

new XElement("Convencional2",

new XAttribute("Oficina","2847241"),

new XAttribute("Desde","09H00AM"),

new XAttribute("Hasta","19H00pM")),

new XElement("Celular",

new XAttribute("Celular","098213125"))

)

),

);

Persona.Save("d:\\ConLINQ.xml");

Cdigo: Este ejercicio tiene como finalidad introducir al lector a la funcionalidad que implementa LINQ a XML, para esto hemos creado dos veces el mismo archivo, la diferencia en la cantidad y la complejidad del cdigo resalta a la vista. Esto se profundizar cuando estudiemos la clase XElement y XAttribute que son dos de los pilares de la funcionalidad XML.



En el Ejercicio 1 podemos darnos cuenta de la inmensa ventaja de utilizar LINQ, si

ejecutamos los ds codigos podremos comprobar que ambos crean un archivo XML

exactamente igual, pero la cantidad de cdigo que utilizamos es considerable.

Es muy importante recalcar que LINQ tambin incorpora Intellisence, lo que significa que

el mismo compilador nos permitir detectar errores de sintaxis en la construccin de

consultas.

2.1.1.4 Diferencias entre LINQ y XML

La diferencia entre LINQ a XML y la programacin habitual de XML no est unicamente en

la cantidad de lneas de cdigo que son necesarias escribir para poder crear rboles,

documentos, atributos, leer archivos XML o modificarlos. Est claro que esta es una

caracterstica muy importante pero tambin hay otras mas que sern de mucha utilidad

estudiarlas.

No es indispensable un documento XML.- Si revisamos el Ejercicio #2 en la programacion

comn es indispensable primero crear o disponer de un documento Xml para poder

continuar con la costruccin de rboles XML, en cambio cuando hicimos uso de las

bondades que nos brinda la nueva herramienta de Microsoft pudimos hacer lo mismo

pero en ningn momento tuvimos que crear o cargar un documento contenedor

(Documento XML).



Compatibilidad con espacios en blanco.- Los espacios en blanco siempre han significado un

problema al momento de desarrollar cdigo para leer, cargar o editar archivos XML, con

LINQ a XML podemos tratar los espacios atravs de nodos texto conocidos como xText.

Compatibilidad con anotaciones.- Nos proporciona informacin de un elemento, si est

enlazado con alguna interfaz de usuario, informacin de esquemas o cualquier otra

informacin especfica de una aplicacin.

Control simplificado de nombres y espacios de nombres.- Evita tener que manejar espacios

de nombres o prefijos de espacios de nombres, es decir si el desarrollador desea los podr

hacer uso, caso contrario al momento de la serializacin se definir los prefijos.

As mismo para cambiar el nombre de un nodo XML, se deba crear un nodo con diferente

nombre y copiar todo el contenido del nodo original. En cambio LINQ soluciona este

problema apoyndose en la propiedad xName de los nodos.

Diferencias entre LINQ a XML y XML Reader.- XML Reader nos permite realizar lecturas

de documentos XML, pero ser el programador quien deba analizar y decidir que va a

utilizar.

A lo que queremos hacer referencia es que en muchas ocasiones no es suficiente solo leer

los orgenes de datos, es ms, tal vez ni siquiera haya un nico origen de datos entonces



los que nos toca es tomar los datos de las diferentes fuentes luego darles el tratamiento

necesario y generar un resultado. En este caso ser de mucha utilidad el Lenguaje

Integrado de Consultas, o podra tambin ser una combinacin entre XMLReader y las

bondades que nos ofrece LINQ.

2.1.1.5 Clases XElement, XAttribute y XDocument

La clase XElement es la clase base con la trabaja el Lenguaje Integrado de Consultas.

Mediante esta clase se puede realizar varias operaciones con los elementos o nodos de los

archivos XML, as tambin se dispone de la clase XAttribute que tiene la misma funcin

que la clase XElement pero en este caso con los atributos.

Los elementos difieren de los atributos en el aspecto que los ltimos no son nodos, ms

bien podramos decir que estos son parte de los nodos y que estn compuestos por dos

valores, uno que representa el nombre del atributo y el segundo que indica el contenido

del atributo.

Por otra parte la clase XDocument si bien forma parte de LINQ, lo mejor es saber

analizarlo de manera correcta, ya que en muchas ocasiones resulta ms facil manejar

archivos unicamente con elementos y atributos.



Cuando utilizamos la clase XDocument debemos tomar en cuenta que un documento solo

puede tener un elemento secundario, siendo este el nodo riz. No cambia mucho o quiz

nada, ya que todo documento XML requiere que el nodo principal sea nico.

As mismo hay otros elementos que puede tener un documento XML, como son

XDeclaration, XProcessingInstruction, XComment, XDocumentType, etc. La clase

XDocument se deriva de Container por lo que su funcion es similar a la de un contenedor.

El aprendizaje de estas tres clases es muy sencillo ya que la mayora de mtodos que

implementan cada una de ellas son muy similares entre s. Ejemplo:

XElement elemento = new XElement("MiElemento",

new XAttribute("MiAtributo", "12"));

Cdigo: Este es uno de los paso fundamentales para poder crear estructuras XML, en este ejemplo hemos creado un nodo XElement y le asignado un solo atributo, al leer el cdigo podemos darnos cuenta que instanciamos un objeto XElement, el primer parmetro es el nombre y el segundo es vector que puede tener uno o varios atributos o incluso subnodos. Lo nico que debemos tomar en cuenta es anteponer la palabra new a cada elemento o atributo que se crea.

En el ejemplo podemos ver que tanto la clase XElement como XAttribute son similares,

XElement recibe de parmetros el nombre del elemento en este caso MiElemento y como

segundo parmetro los atributos de cada elemento. En cambio XAttribute recibe el

nombre del atributo y en segundo lugar el valor o contenido del atributo.

Para el caso de los Documentos XDocument funciona de manera muy similar a las dos

clases anteriores, pero esta recibe parametros como: XComent, XProcessingInstruction,

XDeclarative, XElement, etc. Segn la instancia que se utilice.



2.1.1.6 Cargar un archivo XML

Podemos cargar archivos XML a travs de su path, con el mtodo XElement.Load(), este

mtodo tiene instancias adicionales que nos permite dar opciones de carga como es

mantener los espacios en blanco. La sintaxis de este mtodo es la siguiente:

XElement MiArchivo = XElement.Load("d:\\ConLINQ.xml");

XDocument MiArchivo = XDocument.Load("d:\\ConLINQ.xml");

Cdigo: La primera lnea carga el documento XML en un objeto XElement y la segunda carga el mismo documento pero en un objeto XDocument.

El mtodo Load() permite cargar archivos XML en un XElement o en un XDocument, pero

la diferencia radica; Cuando lo hacemos con un XElement el nodo primario del documento

pasa a ser el documento, mientras que cuando lo hacemos a travs de XDocument se crea

un nodo para el documento y el nodo raz queda como nodo secundario. Sin dejar este de

ser el nodo principal.

Cuando deseamos realizar la carga de un documento XML con algunas restricciones como

por ejemplo preservar los espacios en blanco, podemos enviar el parmetro LoadOptions

indicando como se debe realizar la carga. En el ejemplo siguiente vamos a cargar el

documento ConLINQ.xml preservando los espacios en blanco. Igual que el ejemplo

anterior es la misma sintaxis tanto para XElement como para XDocument.

XDocument MiArchivo = XDocument.Load("d:\\ConLINQ.xml",LoadOptions.PreserveWhitespace);

Cdigo: El segundo parmetro del metodo Load() indica que debe preservar los espacios en blanco



EJERCICIO 2

En este ejercicio vamos a cargar el archivo XML ConLINQ.xml que creamos al principio de

este tema y despes vamos a presentar el nombre del contacto.

XElement Contacto = XElement.Load("d:\\ConLINQ.xml");

IEnumerable NodosHijo = from persona

in Contacto.Elements()

select persona;

foreach (XElement persona in NodosHijo)

MessageBox.Show("Nombre: " + persona.NextNode.ToString());

Cdigo: La instruccin de consulta carga todos los subnodos del nodo Contactos (NodoRaiz) y luego a travs del bucle foreach los va presentando de uno en uno, anteponiendo la palabra nombre

Nota: Recomendamos ampliar el archivo XML por los menos a tres contactos para entender mejor el cdigo.

Si queremos obtener el valor de un elemento XML, entonces solo debemos cambiar la

presentacion del resultado por:

MessageBox.Show("Nombre: " + persona.Value.ToString());

2.1.2 LINQ a SQL

LINQ a SQL, es otra funcionalidad que nos brinda el Lenguaje Integrado de Consultas.

Como su nombre lo indica nos permite conectar con datos que se encuentren

almacenados en un motor de SQL Server.

Basado en ORM LINQ, permite realizar un mapeo de la base de datos con la que se desea

trabajar cargando dentro de este mapa tanto las tablas como los procedimientos

almacenados que vamos a necesitar. A partir de esto se puede comenzar a escribir

instrucciones de lectura y de escritura en las entidades que fueron cargadas en nuestra

clase.



Una vez que hemos explicado cual es la funcionalidad de LINQ a SQL comenzaremos a

realizar algunos ejemplos que no permitirn entender mejor como se puede implementar

esta beneficio del nuevo lenguaje de consultas.

Lo primero que debemos hacer es agregar un nuevo elemento de la misma forma que si

estuvieramos agregando un formulario o una clase pero en el cuadro de dilogo que se

presenta para que seleccionemos el elemento que vamos a adicionar a nuestro proyecto

debemos escoger la opcion LINQ a SQL clase que tiene una extension .dbml como se ve

en la siguiente figura:



Ahora debemos crear una conexin a la base de datos con la que deseamos trabajar para

poder arrastrar las tablas y procedimientos almacenados que vayamos a manipular en

nuestra aplicacin.

2.1.2.1 Qu es mejor utilizar LINQ o Procedimientos Almacenados?

Muchas veces los desarrolladores nos preguntamos que hace ms eficiente nuestro

cdigo, los procedimientos almacenados, utilizar consultas LINQ o combinar las dos

formas de acceder a los datos.

Como se podr observar cuando hagamos el mapeo de nuestra base de datos. LINQ no fue

creado para reemplazar a los Procedimientos Almacenados sino mas bien para

complementar su funcionalidad. Desde LINQ el desarrollador puede llamar y ejecutar

todos los PA que necesite su aplicacin.

Lo que si es muy importante tomar en cuenta es la manera en que se va a combinar estas

formas de acceso a datos. Ya que si hacemos excesivo uso de LINQ podra ser que

terminemos desperdiciando recursos del equipo y por lo tanto nuestros programas se

ralenticen. Por el contrario si decidimos obviarlo por completo tambin podemos perder

mucho tiempo implementando cdigo que se simplificara mucho con el Lenguaje

Integrado de Consultas. Esta decisin la deber tomar el desarrollador despus de analizar

el entorno en el que va a funcionar los programas que construya.



2.2 Cmo funciona LINQ?

Siempre que comencemos a utilizar una herramienta o tecnologa es importante saber

cmo funciona? Y ms aun si es nueva. Para entender mejor cmo?, y en qu? manera

beneficiar esta a nuestra aplicacin.

LINQ, toma las sentencias que escribimos en nuestros programas las interpreta y

convierte a una consulta SQL (En lo que respecta a LINQ a SQL) y lo ejecuta contra la base

de datos.

Cuando hablamos de rendimiento inmediatamente pensamos tiempo de respuesta al

cliente, consumo de memoria y eso est muy bien pues de un anlisis correcto de estos

agentes tendremos aplicaciones ms livianas y eficientes. Como LINQ se construy sobre

el lenguaje C# 3.0 obviamente tendr un mejor rendimiento que en Visual Basic 9.0;

obviamente la diferencia est marcada en el orden de milsimas de segundo pero que en

aplicaciones crticas podran significar una gran diferencia.

Tambin si ejecutamos un programa que contenga cdigo LINQ paso a paso, veremos que

despus de creada la consulta esta es una instruccin SQL, por lo que se convierte en un

proceso similar a escribir sentencias SQL dentro del cdigo de la aplicacin. Y los

Procedimientos Almacenados?. Si personalmente creemos que aunque utilicemos LINQ

deberamos conectarnos a la base de datos con PA que estn cargados en el contexto y

dejar las consultas para los objetos DataSet y archivos XML.



En conclusin podramos decir que LINQ funciona como un intrprete de las transacciones

que nosotros escribimos en el cdigo de nuestro programa convirtindolas a T-SQL,

XQuery, etc. Segn cul sea la fuente de datos a la que se est conectando.

2.3 Qu es ORM?

Mapeo de objetos Relacionales (Object Relational Model)

Es importante aclarar que LINQ no es un ORM, sino mejor se apoya en los ORM para

implementar sus funcionalidades conocidas como LINQ a SQL y LINQ a Entidades que

tambin debemos indicar son diferentes. La primera es orientada especficamente para

bases de datos que se encuentran almacenadas en un motor de SQL Server mientras que

la segunda hace la misma funcin que la anterior pero con bases de datos que no se

encuentran en SQL Server.

Cuando mapeamos la base de datos podemos acceder a todas las tablas y procedimientos

almacenados que se hayan incluido en el mapa como si fueran clases del software que se

est construyendo. As tambin estas clases podrn ser instanciadas y por lo tanto

tambin tendrn propiedades y mtodos ajustados a cada una de ellas.



2.4 MAPEO DE LA BASE DE DATOS

Con la llegada de LINQ, tenemos finalmente entre otras cosas el tan ansiado ORM creado

por Microsoft, el cual nos va a permitir no solo convertir transparentemente entidades de

base de datos en objetos .NET, sino que nos da la posibilidad de todo tipo de querys

contra el modelo relacional sin tener nunca que utilizar sentencias SQL, ya que las mismas

se generan tras bastidores.

El ORM al que nos referimos se conoce especficamente como LINQ a SQL. Esta es solo

una de las variantes de LINQ, puesto que el mismo puede utilizarse con otros orgenes de

datos, como por ejemplo XML y objetos. En s, LINQ brinda el poder de hacer todo tipo

de querys en el lenguaje de nuestra preferencia (Visual Studio .Net 2008), contra cualquier

origen de datos, transformar (opcionalmente) los datos a la forma que uno desee y luego

manipular fcilmente los resultados.

El Mapeo de la Base de Datos, es un procedimiento que consiste en cargar todas las

tablas, vistas, procedimientos almacenados que tenemos en la base de datos relacional y

subirlas a nuestra clase LINQ a SQL para poderlos utilizar en nuestros programas a travs

de las consultas embebidas en los lenguajes de programacin.



En el grfico anterior podemos observar como hemos creado la conexin a nuestra base

de datos atravs del explorador de servidores (parte izquierda del grafico), en el centro se

encuentran las tablas que hemos agregado a nuestra clase LINQ a SQL, en esta misma

zona podemos colocar las vistas en caso de haberlas y en la parte derecha colocamos los

procedimientos almacenados tal como se muestra en el grfico superior.

Guardamos los cambios realizados en nuestra aplicacin. Para terminar debemos hacer

una instancia de nuestro ORM que tenemos creado. Esto se realiza de la siguiente forma:

BDLINQDataContext MiEsquema = new BDLINQDataContext();



Absolutamente todas las entidades de la base de datos que deseamos utilizar con

consultas LINQ debern estar cargadas en el esquema de Base de datos. Podemos seguir

agregando ms entidades despus de que hayamos creado el esquema con tan solo

arrastrarlas y soltarlas dentro del contexto.

Es importante aclarar que para conectarse con otros motores de base de datos a travs

del Lenguaje Integrado de Consultas se debe realizar a travs de LINQ a Entidades.

La siguiente instruccin permite cargar todos los clientes de nuestra base de datos y

presentarlos en una grilla.

public void BuscarCliente()

{

var Consulta=from cliente in MiEsquema.Cliente select cliente;

grilla.DataSource = Consulta;

}

Cdigo: Asignamos directamente el resultado de la consulta como DataSource de la grilla.



3. ACCESO A LOS ARCHIVOS QUE CONTIENEN LA INFORMACION

3.1 CLASULA SELECT CON LINQ

3.1.1 SENTENCIA SELECT CON ORIGENES DE DATOS XML

3.1.1.1 Recuperar el Valor Superificial de un Elemento

Cuando hacemos el ejercicio 3 y pedimos que nos muestre el valor del elemento XML, nos

podremos dar cuenta que nos presenta toda la informacin de los nodos hijos de cada

nodo contacto eso se conoce con el nombre de valor profundo. El valor superficial hace

referencia al valor que tiene un nodo especfico independiente del contenido que tengan

sus nodos hijos.

Ejercicio 3

Este ejemplo ha sido tomado de MSDN, lo que debemos hacer es crear el archivo xml en la

unidad D:, el cdigo es el siguiente:

=Customer.CustomerId.Heading

=Customer.Name.Heading

=Customer.CustomerId

=Customer.Name

Guardamos el archivo con el nombre EjemploMsdn1.xml y a continuacin creamos un

formulario con un botn. En el click del botn digitamos el siguiente cdigo:



XElement root = XElement.Load("d:\\EjemploMsdn1.xml");

IEnumerable query = from el in root.Descendants()

where el.ValorPresentar().StartsWith("C")

select el;

foreach (var q in query)

{

MessageBox.Show(q.Name.ToString().PadRight(8)+

q.Attribute("Name").ToString().PadRight(20)+

q.ValorPresentar());

}

Cdigo: Creamos una sentencia LINQ en donde cargue todos los nodos descendientes del documento que llamamos en donde el valor del mtodo ValorPresentar() que se construir a continuacin empiece con la letra C.

Despus de la llave que cierra la clase del formulario creamos una clase esttica con el

siguiente cdigo:

public static class MiExtension

{

public static string ValorPresentar(this XElement xe)

{

return xe

.Nodes()

.OfType()

.Aggregate(new StringBuilder(),

(k, j) => k.Append(j),

k => k.ToString());

}

}

Ejercicio tomado de la ayuda de MSDN.

Cdigo: El cdigo anterior extrae los nodos del elemento que estamos procesando que sean de tipo texto a travs del mtodo OfType(). Y estructura la cadena resultado a travs de mtodo Agregate que recibe tres parmetros:

- El primero es un string builder en donde construiremo el valor resultante de todos los nodos hijos que nos devuelva la sentencia.

- El segundo es una expresion lambda que concatena cada valor extraido a partir del mtodo Append() a la cadena que creamos en el paso anterior.

- El tercero es una cadena que necesita el mtodo agregate para presentar el resultado, la expresion lambda hace la asignacion

3.1.1.2 Buscar Descendientes con un Nombre Especfico

El siguiente ejercicio nos muestra una forma sencilla de buscar descendientes con un

nombre especfico, este mtodo tiene un funcionamiento similar al Find() o FindRows()

que nos evitan las iteraciones cuando queremos encontrar elementos determinados en

los DataViews.



EJERCICIO 4 XElement archivo = XElement.Load("D:\\ConLINQ.xml");

IEnumerable texto =from elemento in archivo.Descendants("Nombre")

select (string)elemento;

string Resultado = texto.Aggregate(new StringBuilder(),

(ArmarCadena,ValorNodo ) => ArmarCadena.Append(ValorNodo+"; "),

CadenaFinal => CadenaFinal.ToString().Trim());

MessageBox.Show(Resultado, "Elemento encontrado");

Cdigo: Cargamos nuestro documento XML, luego escribimos la consulta LINQ, indicando que nos devolver los nodos hijos a travs del mtodo Descendants() y pasando como parmetro el nombre del nodo padre. En el select hacemos un cast a string del elemento que nos devuelve la consulta. Agregate.- al valor que nos devolvi la instruccin le ejecutamos el mtodo Agregate() que recibe tres parmteros:

- El primero es un string builder en donde construiremos el valor resultante de todos los nodos hijos que nos devuelva la sentencia.

- El segundo es una expresion lambda que concatena cada valor extrado a partir del mtodo Append() a la cadena que creamos en el paso anterior.

- El tercero es una cadena que utiliza el mtodo Agregate() para presentar el resultado, la expresin lambda hace la asignacion.

Finalmente se presenta el resultado al usuario a travs de un cuadro de dilogo.

3.1.1.3 Como Buscar un Elemento a Partir de un Elemento Secundario o Atributo

El siguiente ejemplo esta tomado de MSDN y nos muestra como realizar la bsqueda de

un elemento dentro de un rbol a partir de un atributo. El rbol XML que debemos tener

para la busqueda es el siguiente:

EJERCICIO 5

Convert number to string Examp1.EXE 1 One Find succeeding characters Examp2.EXE abc def Convert multiple numbers to strings Examp2.EXE /Verbose 123 One Two Three



Find correlated key Examp3.EXE a1 b1 Count characters FinalExamp.EXE This is a test 14 Another Test Examp2.EXE Test Input 10

En nuestro botn del formulario escribimos el siguiente cdigo:

XElement root = XElement.Load("D:\\EJEMPLO1.xml");

IEnumerable tests =

from el in root.Elements("Test")

where (string)el.Element("CommandLine") == "Examp2.EXE"

select el;

foreach (XElement el in tests)

MessageBox.Show((string)el.Attribute("TestId"));

Cdigo: Cargamos nuestro documento XML, Hacemos una consulta que filtre solo los nodos que tengan el atributo CommandLine=Examp2.EXE (ver la estructura del archivo XML creado para entender mejor el atributo CommandLine). Presentamos los resultados de la consulta atravs del bucle foreach.

3.1.2 SENTENCIA SELECT CON ORGENES DE DATOS SQL SERVER

Existen tres formas bsicas de realizar consultas con LINQ a SQL:

- Mediante la sintaxis de consulta

- Mediante la sintaxis de mtodo

- Mediante una combinacin de las dos anteriores.

Lo recomendado es utilizar en lo posible la primera forma y dejar la segunda y tercera

forma para los casos que sean mismo necesario utilizarlas.



Comenzaremos haciendo unos ejercicios que nos permitan cargar informacin de nuestra

base de datos a travs de la clusula Select, de la misma forma que hicimos con los

archivos XML, realizaremos varios ejemplos que realicen consultas de diferentes formas y

al final de cada ejemplo se har una pequea explicacin del cdigo fuente.

Comenzaremos creando un formulario como el que se indica en la figura:

Ahora vamos a realizar la instancia de nuestro contexto de la siguiente forma:




3.1.2.1 Consulta Simple

Para empezar haremos una consulta sencilla que nos presente todos los registros que

tenemos en la entidad cliente.

Ejercicio 6

public IQueryable ListarCliente(TextBox texto) {

var Consulta = from cliente in MiEsquema.Cliente

select cliente;

foreach (var elemento in Consulta)

{

texto.Text = elemento.NomCli;

}

return Consulta;

}

Cdigo: La consulta obtiene todos los registros de la entidad de clientes, en el bucle foreach asignamos el nombre de cada elemento al texto que pasamos como parmetro, al ejecutar el programa quedar visualizando el ltimo registro en el texto, tambin se devuelve la consulta para asignar como DataSource de la grilla.

Ejercicio 7 var Consulta = from cliente in MiEsquema.Cliente

where cliente.NomCli.StartsWith("D") ||

cliente.NomCli.StartsWith("J")

select cliente;

foreach (var elemento in Consulta)

{

texto.Text = elemento.NomCli;

}

return Consulta;

Cdigo: Se diferencia del ejercicio anterior porque la consulta implementa una condicin where para que visualice los registros en los que el nombre del cliente empiece con las letras C o J.

3.1.2.2 Ordenar Resultados de Consultas

Toda la informacin que presenten nuestras aplicaciones deber estar ordenada para

simplificar al usuario su anlisis. Esta operacin se hace posible a travs del operador

OrderBy. En los siguientes ejercicios indicaremos el funcionamiento de esta clusula

ordenando los resultados por nombre en forma ascendente y luego descendente.



Ejercicio 8 public IQueryable LitaOrdenadaASC()

{


orderby cliente.NomCli ascending

select cliente;

return Consulta;

}

public IQueryable LitaOrdenadaDSC()

{


orderby cliente.NomCli descending

select cliente;

return Consulta;

}

Cdigo: Tenemos 2 mtodos el primero presenta el listado de clientes que tenemos ordenado en forma ascendente de acuerdo al nombre, y el segundo presenta ordenado de forma descendente, lo nico que cambia es la palabra clave ascending o descending, en caso de que no se indique la forma de ordenamiento el compilador por defecto asumir que es ascendente.

3.1.2.3 Operadores: Sumar, Promedio y Contar

Continuamente es necesario realizar clculos a travs de consultas para evitar tener que

implementarlas despus en el cdigo del programa a travs de barridos. En los siguientes

ejemplos haremos ejercicios que nos darn como resultado el nmero de registros de la

tabla productos, el promedio del precio que tienen los produtos y la suma de los precios

de todos los productos.

Ejercicio 9 public void ContarRegistros()

{

string Informe = "Se ha contado los registros que tienen las entidades Clientes y

Productos. \n Los resultados fueron: \n" +

"\t\tCliente: " + MiEsquema.Cliente.Count().ToString() + " registros\n" +

"\t\tProductos: " + MiEsquema.Producto.Count().ToString() + " registros";

MessageBox.Show(Informe,"Informe:",MessageBoxButtons.OK,MessageBoxIcon.Information);

}

Cdigo: El cdigo es muy facil de comprender, consiste en crear una cadena y concatenar el texto que se va a presentar para indicar al usuario el resultado del proceso y la parte LINQ es solo la instancia del nuestro contexto con el nombre de la entidad y llamamos al mtodo Count() para que nos devuelva el nmero de registros.



Para facilitar el entendimiento del cdigo vamos a crear los siguientes dos mtodos de la

entidad producto en nuestra clase cliente, para obtener el costo promedio de los precios

que tienen nuestra mercadera.

EJERCICIO 10 System.Nullable Promedio = (from prom in MiEsquema.Producto

select prom.PrePrd).Average();

MessageBox.Show("El costo promedio de los productos es: " +

Promedio.ToString(),"Calcular Promedio");

Cdigo: Construimos la consulta LINQ entre parentesis y despus de la palabra clave select seleccionamos la

propiedad precio (prom.PrePrd) despues cerramos el parentesis y llamamos al mtodo Average() que calcula el promedio y devuelve un valor decimal. Finalmente presentamos el resultado en un cuadro de dilogo.

Ejercicio 11

public void SumaPrd()

{

System.Nullable Suma = (from prom in MiEsquema.Producto

select prom.PrePrd).Sum();

MessageBox.Show("La suma de los precios de los productos es: " + Suma.ToString(),

"Calcular Suma");

}

Cdigo: Es el mismo proceso que el clculo del promedio, unicamente cambiamos la llamada al mtodo Average() por el mtodo Sum().

3.1.2.4 Operador Agrupar (Group by)

Es frecuente la necesidad de presentar los resultados agrupados por alguno de sus

campos, en el siguiente ejercicio haremos grupos de acuerdo al estado de los productos y

contaremos cuantos registros tiene cada uno de ellos.

Ejercicio 12 public void AgruparPrd()

{

var Agrupar=from prod in MiEsquema.Producto

group prod by prod.EstPrd into g

orderby g.Key ascending

select new{Estado=g.Key,Cantidad = g.Count()};

string cadena = "";



foreach (var grupo in Agrupar)

{

if (grupo.Estado==true)

{

cadena =cadena+ "Existen " + grupo.Cantidad + " registros de productos activos \n";

}

else

{

cadena = cadena+"Existen " + grupo.Cantidad + " registros de productos

descontinuados \n";

}

}

MessageBox.Show(cadena,"Informe:");

}

Cdigo: La consulta de este ejercicio agrupa, ordena y seleciona los campos que vamos a presentar en el resultado.

1- Indicamos la variable de iteracion (prod) y el origen de datos (MiEsquema.Productos) 2- Escribimos la palabra clave group seguido de la variable de iteracion que le informa al compilador

que se va a agrupar, despus digitamos la palabra reservada by seguido de los campos por los que vamos a agrupar. En el caso de ser ms de un campo se debera hacer (new {campo1, campo2, campo3}.

3- A esto concatenamos la palabra into con un nombre de grupo (g). 4- Ordenamos los resultados. 5- Para terminar indicamos que campos deseamos visualizar atravs de la sentencia select, con la

diferencia que ahora en lugar de la variable de iteracion ponemos el nombre del grupo. Todos los campos que se seleccionen debern estar agrupados o ser parte de una funcion de agrupacin.

Los resultados se presentan atravs del bucle foreach en donde preguntamos si el estado es true el grupo esta activo caso contrario est descontinuado. Se forma la cadena y lo presentamos en la cuadro de dilogo.

El cdigo del formulario para llamar a los mtodos que hemos creado en nuestra clase

cliente estara de la siguiente forma:

private void btnSeleccionar_Click(object sender, EventArgs e)

{

dtgResultado.DataSource = objCliente.ListarCliente(txtTexto);

}

private void btnOrdenar_Click(object sender, EventArgs e)

{

dtgResultado.DataSource=objCliente.LitaOrdenadaASC();

//dtgResultado.DataSource = objCliente.LitaOrdenadaDSC();

}

private void btnContar_Click(object sender, EventArgs e)

{

objCliente.ContarRegistros();

}

private void btnPromedio_Click(object sender, EventArgs e)

{

objCliente.PromedioPrd();

}

private void btnSumar_Click(object sender, EventArgs e)

{

objCliente.SumaPrd();

}



private void btnAgrupar_Click(object sender, EventArgs e)

{

objCliente.AgruparPrd();

}

Cdigo: Solo son llamadas a los mtodos que hemos creado en la clase cliente. En el botn ordenar podemos ver una lnea en comentario, esto para que se ejecute el orden ascendente, luego comentamos el llamado al orden ascedente y ejecutamos el llamado descendente.

3.2 INSERTAR, MODIFICAR Y ELIMINAR CON LINQ

3.2.1 Insertar, Modificar y Eliminar nodos de un archivo XML.

Hasta aqu hemos hecho pequeos ejemplos sobre el funcionamiento de la clusula Select

que nos permite consultar y cargar los datos de archivos XML, pero como hemos

mencionado en la introduccin las consultas embebidas en los lenguajes de programacin

tambin nos sirven para editar el contenido de los archivos con este formato.

Consecuentemente nos faltara hacer el ejercicio que haga un AGE (Actualizar, Guardar y

Eliminar) a los datos de estos orgenes XML utilizando el potencial de LINQ a XML para

esto crearemos un pequeo formulario como se muestra en la siguiente figura:

EJERCICIO 13



En el evento click del botn de crear archivo escribiremos el siguiente cdigo a travs del

cual creamos nuestra estructua XML con la que desarrollaremos todo nuestro ejemplo:

try

{

XNamespace EN = "Espacio de Nombre";

XDocument MiDocumento =

new XDocument(

new XComment("Archivo XML que va a ser modificado"),

new XElement("Listado",

new XElement("Registro",

new XElement("Codigo", 1),

new XElement("Nombre", "Francisco Jos Ochoa Castillo"),

new XElement("Telefono", "2800600")

),

new XElement("Registro",

new XElement("Codigo", 2),

new XElement("Nombre", "Martha Florinda Iiguez Santilln"),

new XElement("Telefono", "2800601")

)

)

);

MiDocumento.Save("d:\\EjemploAGE.xml");

MostarArchivo("Archivo creado:");

}

catch

{ MessageBox.Show("No se ha podido crear el archivo. Por favor vuelva a

intentar", "Crear archivo", MessageBoxButtons.OK, MessageBoxIcon.Error); }

Cdigo: Creamos el archivo XML para poder realizar las operaciones de agregar, modificar y eliminar. Podemos observar que en la primera linea hemos utilizado la clase XNameSpace, esta clase permite asignar un espacio de nombre al archivo XML que estamos creando. Tambin podemos notar que despus de hacer la instancia del documento utilizamos la clase XComment que agrega un comentario al documento XML.

El siguiente paso consiste en crear una enumeracin y luego dos mtodos el primero que

ser el encargado de agregar, modificar, y eliminar nuestro documento xml:

public enum opciones { Agregar, Modificar, Eliminar };

private void LINQAGEXML(opciones Accion)

{

try

{

DocXML = XDocument.Load("d:\\EjemploAGE.xml");

switch (Accion)

{

case opciones.Agregar:

XElement NuevoRegistro = new XElement("Registro",

new XElement("Codigo", txtCodigo.Text),

new XElement("Nombre", txtNombre.Text),

new XElement("Telefono", txtTelefono.Text));

DocXML.Element("Listado").Add(NuevoRegistro);

DocXML.Save("d:\\EjemploAGE.xml");

break;

case opciones.Modificar:

var CargarNodo = from NodoAnterior in DocXML.Descendants("Registro")

where NodoAnterior.Element("Codigo").Value == txtCodigo.Text.Trim()

select NodoAnterior;



CargarNodo.ElementAt(0).ReplaceAll(

new XElement("Codigo", txtCodigo.Text),

new XElement("Nombre", txtNombre.Text),

new XElement("Telefono", txtTelefono.Text));


break;

case opciones.Eliminar:

var EliminarNodo = from NodoEliminar in DocXML.Descendants("Registro")

where NodoEliminar.Element("Codigo").Value == txtCodigo.Text

select NodoEliminar;

EliminarNodo.Remove();


break;

}

MostarArchivo("Transaccion compleatada. El nuevo archivo es:");

}

catch

{

MostarArchivo("No se pudo completar la transaccion. El archivo actualmente se

encuentra de la siguiente forma:");

}

}

Cdigo: Instanciamos y cargamos nuestro archivo con el mtodo Load(). Creamos un switch() que clasificr las opciones de AGREGAR, MODIFICAR o ELIMINAR.

- Agregar.- Creamos la estructura que se va a adicionar en nuestro caso a travs de la clase XElement instanciada con el nombre de Nuevo Registro. Terminada de crear la nueva estructura la implementamos a travs del mtodo Add() y finalmente guardamos el documento con el mtodo Save().

- Modificar.- A travs de una consulta LINQ, colocamos en la variable CargarNodo el elemento XElement que va a ser modificado, despus con el mtodo ReplaceAll(), reemplazamos los nuevos valores del nodo y guardamos el documento con el mtodo Save().

- Eliminar.- As mismo con una consulta LINQ cargamos el nodo que va a ser eliminado. En nuestro caso se llama EliminarNodo. El proceso de eliminar se realiza a travs del mtodo Remove(), y de igual forma que en guardar y actualizar guardamos el documento con el mtodo Save().

private void MostarArchivo(string Texto)

{

MessageBox.Show(Texto+"\n" + DocXML.ToString(), "Transaccion LINQ");

}

Finalmente solo nos falta hacer la llamada en los botones de Nuevo, Agregar y Eliminar

private void btnAgregar_Click(object sender, EventArgs e)

{

LINQAGEXML(opciones.Agregar);

}

private void btnModificar_Click(object sender, EventArgs e)

{

LINQAGEXML(opciones.Modificar);

}

private void btnEliminar_Click(object sender, EventArgs e)

{

LINQAGEXML(opciones.Eliminar);

}



3.2.2 INSERTAR, EDITAR Y ELIMINAR REGISTROS CON LINQ A SQL

Para esto necesitaremos crear un formulario similar al que se presenta en la figura:

Tenemos cuatro cajas de texto en las que podemos ingresar el cdigo, nombre, direccin y

telfono del cliente; tres botones de edicin: guardar, modificar y eliminar. Adems

disponemos de una grilla en la parte inferior que nos permita visualizar el resultado de las

transacciones que vayamos realizando.

En los ejercicios de consulta agregamos una clase cliente a nuestro proyecto, en esa

misma clase seguiremos aumentando el cdigo referente a la creacin, actualizacin y

eliminacin de registros que hagamos con la entidad clientes.



Ejercicio 14

public void Guardar(string Codigo, string Nombre, string Direccion, string Telefono)

{

Cliente objCliente = new Cliente();

objCliente.CodCli = short.Parse(Codigo);

objCliente.NomCli = Nombre;

objCliente.DirCli = Direccion;

objCliente.TelCli = Telefono;

MiEsquema.Cliente.InsertOnSubmit(objCliente);

MiEsquema.SubmitChanges();

}

Cdigo: Instanciamos la clase cliente, luego asignamos a las propiedades los valores de los parmetros que recibe el mtodo. Finalmente atravs de la instancia (MiEsquema) de nuestro ORM seleccionamos la entidad que va a ser cambiada (Cliente) y llamamos al metodo InsertOnSubmit, le pasamos de parmetro nuestro objeto cliente (objCliente) y el mtodo SubmitChanges() lo utilizaremos en las tres transacciones para confirmar los cambios en la base de datos. public void Modificar(string Codigo, string Nombre, string Direccion, string Telefono)

{

var objActualiza = (from cliente in MiEsquema.Cliente

where cliente.CodCli == short.Parse(Codigo)

select cliente).First();

objActualiza.NomCli = Nombre;

objActualiza.DirCli = Direccion;

objActualiza.TelCli = Telefono;


}

Cdigo: Hacemos una consulta LINQ que nos devuelva un registro de la entidad cliente. Para poder acceder a las propiedades del objeto que cargamos notese que al final de la instruccin hemos utilizado el mtodo First(); que indica que el resultado es solo un registro. A continuacin asignamos los nuevos valores y enviamos a guardar atravs del mtodo SubmitChanges().

public void Eliminar(string Codigo)

{

var objElimina = (from cliente in MiEsquema.Cliente

where cliente.CodCli == short.Parse(Codigo)

select cliente).First();

MiEsquema.Cliente.DeleteOnSubmit(objElimina);


}

Cdigo: Igual que al momento de actualizar cargamos el registro que vamos a eliminar. Y ejecutamos la accin a travs del mtodo DeleteOnSubmit pasando como parmetro objElimina. Y el mtodo SubmitChanges() confirma los cambios en la BD.

Y el cdigo del formulario qued de esta forma:

private void btnGuardar_Click(object sender, EventArgs e)

{

objCliente.Guardar(txtCodigo.Text, txtNombre.Text, txtDireccion.Text, txtTelefono.Text);

Cargar();

}


{

objCliente.Modificar(txtCodigo.Text,txtNombre.Text, txtDireccion.Text, txtTelefono.Text);

Cargar();

}




{

objCliente.Eliminar(txtCodigo.Text);

Cargar();

}

#region CargarDatosCliente

private void Cargar()

{

dtgListado.DataSource=objCliente.ListadoCliente();

}

#endregion

Cdigo: En cada uno de los botones hacemos el llamado a los mtodos de la clase cliente y pasamos de parmetros los valores de las cajas de texto. El mtodo cargar nos presentar los cambios que se van realizando en la base de datos.

3.3 LLAMAR A PROCEDIMIENTOS ALMACENADOS CON LINQ

La mejor forma de entender como funcionan los procedimientos almacenados con LINQ,

es haciendo un ejemplo que ejecute estas sentencias SQL que tenemos guardadas en

nuestras bases de datos. Para el ejemplo que haremos a continuacin vamos a utilizar el

mismo formulario del ejercicio anterior y solamente incrementaremos tres mtodos ms a

la clase clsClientes

Antes de comenzar a escribir cdigo para utlizar procedimientos almacenados con LINQ,

debemos asegurarnos de que estos esten agregados en nuestro contexto. En caso de que

no hayamos agregado se lo puede hacer con tan solo arrastrar los PA a nuestro mapa

como se indic en el apartado MAPEO DE LA BASE DE DATOS.

Como LINQ, trata todas las entidades de la base de datos como clases del .NET o de

cualquier lenguaje orientado a objetos que implemente el Framework 3.0 que abarca a

LINQ, tambin deberemos realizar la instancia del contexto.




En nuestro ejemplo hemos implementado el cdigo que ejecuta los procedimientos

almacenados en la clase cliente que creamos en el ejercicio anterior y en el formulario

solo realizamos el llamado a los mtodos de nuestra clase. Esto con la finalidad de tener

una sola clase a la que iremos agregando ms metodos conforme avancemos en el estudio

de este tema.

Ejercicio 15

public void GuardarPA(string Codigo,string Nombre,string Direccion,string Telefono)

{

MiEsquema.CliGuarda(short.Parse(Codigo), Nombre, Direccion, Telefono);

}

public void ModificarPA(string Codigo, string Nombre, string Direccion, string Telefono)

{

MiEsquema.CliActualiza(short.Parse(Codigo), Nombre, Direccion, Telefono);

}

public void EliminarPA(string Codigo)

{

MiEsquema.CliElimina(short.Parse(Codigo));

}

Cdigo: Para ejecutar procedimientos almacenados desde LINQ utilizamos la instancia de nuestro contexto (MiEsquema), luego seleccionamos el procedimiento almacenado que se va a ejecutar (CliGuarda, CliActualiza o CliElimina) y finalmente enviamos los parmetros ().

Para ejecutar los procedimientos almacenados desde LINQ, debemos utilizar la instancia

del contexto en nuestro caso lo llamamos MiEsquema, luego al poner (.) nos presenta los

objetos de nuestro ORM y nosotros deberemos seleccionar el nombre del PA que vamos a

ejecutar enviando entre parntesis los parmetros que este necesite.

El cdigo de formulario est as:

private void frmCliente_Load(object sender, EventArgs e)

{

Cargar();

}

#region AGE Procedimiento Almacenados

private void btnGuardar_Click(object sender, EventArgs e)

{

objCliente.GuardarPA(txtCodigo.Text, txtNombre.Text, txtDireccion.Text, txtTelefono.Text);



Cargar();

}


{

objCliente.ModificarPA(txtCodigo.Text,txtNombre.Text,txtDireccion.Text, txtTelefono.Text);

Cargar();

}


{

objCliente.EliminarPA(txtCodigo.Text);

Cargar();

}

#endregion

#region CargarDatosCliente

private void Cargar()

{

dtgListado.DataSource=objCliente.ListadoCliente();

}

#endregion

Cdigo: En el formulario se hace el mismo procedimiento que cuando hicimos las transacciones con sentencias LINQ, solamente cambiando el nombre de los mtodos de la clase.

3.4 EJEMPLO Aplicacin Demo

Hemos desarrollado ejemplos de consultas con la instruccin Select y tambin hemos

realizado operaciones de insertar, modificar y eliminar informacin tanto de fuentes XML

como bases de datos relacionales. Por lo que hemos credo conveniente terminar el

proceso de investigacin construyendo una aplicacin demo, que imite el funcionamiento

de una factura de venta y cree un archivo XML con el contenido de la transaccin que

realizamos.



Iniciemos creando un proyecto windows y agregando un formulario similar al que se

muestra en la figura anterior que nos permitir realizar:

1.- Bsquedas de clientes a travs del botn que se encuentra a lado del cdigo.

2.- Agregar productos a nuestra factura con el botn Productos.

3.- Crear clientes.

4.- Y en el men tenemos las opciones para crear y guardar las facturas. Cuando

guardemos la transaccin el programa nos preguntar la ruta en donde se crear nuestro

archivo XML.

Una vez que hemos explicado como va a funcionar el programa es hora de comenzar a

escribir el cdigo. Vamos a agregar una clase factura (clsFactura) a nuestro proyecto que

acabamos de crear y escribiremos el siguiente cdigo:


DataTable dtDetalle;

public clsFactura() { }

Cdigo: Libreras utilizadas ,instancia del contexto, declaracin el DataTable que ser el detalle de la factura y creacin del constructor por defecto de la clase factura.

Ahora si podemos comenzar a implementar los mtodos de esta clase: GenerarDetalle

public DataTable GenerarDetalle()

{

dtDetalle = new DataTable();

dtDetalle.Columns.Add("Codigo");

dtDetalle.Columns.Add("Descripcion");

dtDetalle.Columns.Add("Cantidad");

dtDetalle.Columns.Add("Precio");

dtDetalle.Columns.Add("Total");

dtDetalle.Columns["Precio"].DataType = System.Type.GetType("System.Double");

dtDetalle.Columns["Cantidad"].DataType = System.Type.GetType("System.Double");

dtDetalle.Columns["Total"].DataType = System.Type.GetType("System.Double");

dtDetalle.Columns["Precio"].DefaultValue = 0;

dtDetalle.Columns["Cantidad"].DefaultValue = 0;



dtDetalle.Columns["Total"].Expression=

"("+dtDetalle.Columns["Cantidad"]+")*("+dtDetalle.Columns["Precio"]+")";

return dtDetalle;

}

Cdigo: Genera el DataTable de la factura, instancia y agrega las columnas que va a tener, en el segundo bloque definimos el tipo de dato que van a tener las columnas: precio, cantidad, total. El tercer bloque asigna el valor por defecto de precio y cantidad. Terminamos asignando una expresin de clculo al DataTable con el propsito que se calcule automticamente cada lnea de la factura.

Mensaje private void Mensaje(string mensaje, string titulo)

{

MessageBox.Show(mensaje, titulo, MessageBoxButtons.OK, MessageBoxIcon.Warning);

}

Cdigo: Este mtodo ser el encargado de presentar los mensajes de informacin de la clase factura

Nmero de Factura public int pNumeroFactura

{

get

{

try

{

return (from numero in MiEsquema.FacturaCabecera

select numero.NumFac).Max() + 1;

}

catch {throw;}

}

}

Cdigo: Propiedad que devuelve el nmero de factura, La instruccin LINQ busca en la cabecera de factura el mximo valor que tenga el campo NumFac y le suma 1. Actualizar Detalle public void ActualizarDetalle() { if (dtDetalle != null) { dtDetalle.AcceptChanges(); } }

Cdigo: Actualiza todos los cambios que se hayan hecho en el DataTable dtDetalle. Es como realizar una confirmacin y aceptacin a las modificaciones realizadas en este. Deshacer Cambios public void DeshacerCambiosDetalle(){dtDetalle.RejectChanges();}

Cdigo: Deshace todos los cambios que se hayan realizado en el DataTable dtDetalle. Siempre y cuando no se haya hecho antes un AcceptChanges. Validar private bool Validar(string CodCliente,string Nombre,string Direccion,string Fecha)

{

try

{

if (CodCliente.Trim() == "")

{

Mensaje("No ha ingresado un cdigo de cliente vlido", "Datos del cliente");



return false;

}

else if (Nombre.Trim() == "")

{

Mensaje("No ha ingresado el nombre del c

linq - contenido lenguaje integrado de consultas

Documents