Sistemas Informáticos que les permitan intercambiar información con el mundo externo.

Transcripción

1 1. INTRODUCCION 1.1 Qué es LINQ? En la actualidad las empresas que anhelan tener éxito en el mercado deben implementar Sistemas Informáticos que les permitan intercambiar información con el mundo externo. De ahí comenzaron a surgir ideas para que las aplicaciones puedan comunicarse entres sí. Empezaron a aparecer los compiladores que tenían un lenguaje intermedio como.net que disponía del MSIL, JAVA también tenía sus propios proyectos, etc. Y finalmente se desarrollaron estándares para el envío y recepción de los datos que necesitaban los programas. Sin embargo estos estándares también requieren tener una forma de conexión 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 tenía que interactuar con fuentes de datos de disímiles tipos; el excesivo uso de variables y conexiones podía ocasionar que las aplicaciones se hagan lentas y pesadas. Con el avance de la programación orientada a objetos los desarrolladores están muy familiarizados con el manejo de objetos, clases, etc. Pero las formas más utilizadas para almacenar la información son bases de datos relacionales y archivos XML, que precisamente NO SON ORIENTADAS A OBJETOS. Además teníamos una forma de conexión Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 1

2 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 estándar 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. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 2

3 LINQ a SQL es una extensión 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 información 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 podría escribir sentencias LINQ que saquen información de las bases de datos relacionales y por medio del mismo Lenguaje Integrado de Consultas generar los archivos XML que deberán 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 condición: 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 estén en memoria, sino que estos son traídos al momento de ejecutar las instrucciones en un bucle foreach y por eso que es indispensable el uso de esta interfaz. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 3

4 EJERCICIO 1 El siguiente ejemplo, presenta la lista de números 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 tecnología LINQ brinda tantas ventajas al desarrollador como es la característica de Intellisence que le evita problemas de sintaxis al momento de trabajar con la información. Antes de que aparezca este lenguaje todas las sentencias SQL que se escribían en las aplicaciones se lo hacía a través de una variable de tipo string. Ejemplo: string InstruccionSQL= Select * fro clientes Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 4

5 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 característica Intellisence se detectaría inmedianamente. 1.2 HISTORIA Después de dos décadas, la industria ha alcanzado un punto estable en la evolución de las tecnologías de programación orientada a objetos. Hoy en día los programadores están familiarizados con conceptos como las clases, objetos y métodos. Analizando la generación de tecnologías actual y siguiente, se hace evidente que el siguiente gran reto para la tecnología de la programación es reducir la complejidad del acceso e integrar la información que no se define de manera nativa utilizando la tecnología orientada a objetos. En vez de añadir características específicas para el tratamiento de datos relacionales o XML a nuestros lenguajes de programación y motor de ejecución, con el proyecto LINQ hemos seguido un enfoque más general, y estamos añadiendo a.net Framework facilidades de consulta de propósito general aplicables a todas las fuentes de información, y no solo a los datos relacionales o XML. Esta facilidad se llama Consultas integradas en los lenguajes. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 5

6 Utilizamos el término consultas integradas en los lenguajes para indicar que las consultas son una característica constituida en el framework que utiliza el lenguaje de programación 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, verificación de sintaxis en tiempo de compilación, tipado estático y ayuda IntelliSense que antes estaban disponibles solo para el código imperativo. Las consultas integradas en el framework que utilizan los lenguajes también hacen posible aplicar una única facilidad declarativa de propósito general a toda la información en memoria, y no solo a la información 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 estándar de propósito general que hacen posible que las operaciones de recorrido, filtro y proyección sean expresadas de una manera directa pero declarativa en cualquier lenguaje de programación. Los operadores de consulta estándar permiten aplicar las consultas a cualquier fuente de información basada en IEnumerable<T>. LINQ permite que terceros fabricantes aumenten el conjunto de operadores de consulta estándar, añadiendo los operadores de dominio específico que sean apropiados para el dominio o la tecnología de destino. Más importante aún es que terceros fabricantes también pueden reemplazar los operadores de consulta estándar con sus propias implementaciones que ofrezcan servicios adicionales como la evaluación remota, traducción de consultas, optimización, etc. Al adherirse a los Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 6

7 convenios del patrón LINQ, tales implementaciones gozarán de la misma integración en los lenguajes y soporte de herramientas que los operadores de consulta estándar. 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 fácil de usar para ofrecer funcionalidad XPath/XQuery dentro del lenguaje de programación huésped. Los operadores de consulta sobre datos relacionales (DLinq) se apoyan en la integración de definiciones de esquemas basadas en SQL en el sistema de tipos del CLR. Esta integración 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 evaluación de las consultas directamente en el almacén de datos subyacente. En un principio LINQ ha sido desarrollado específicamente para los lenguajes de C# 3.0 y Visual Basic.NET 9, pero también se puede adicionar esta funcionalidad aunque no de manera completa a estos dos lenguajes en la versión de Visual Studio 2005 haciendo una actualización del framework. También se han manifestado fabricantes de otras líneas sobre el inicio de la implementación de las consultas embebidas en los lenguajes de su autoría. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 7

8 1.3 FUNCIONALIDAD DE LINQ La funcionalidad que nos brinda LINQ radica en la posibilidad de conectarse con diferentes fuentes de información 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 tecnologías para hacer que sus aplicaciones puedan intercambiar o utilizar información que se encuentra almacenada en disímiles formatos. Al analizar detenidamente esta ventaja nos damos cuenta que el desarrollador puede dedicar mayor tiempo a concentrarse en lo que respecta a las políticas del negocio, también podrá distribuir la forma de registrar los datos que utilizan y comparten sus aplicaciones en diferentes fuentes mejorando el rendimiento del código que escriba. Por ejemplo un sistema contable de una empresa necesita información 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 información con otras instituciones que utilizan los mismos datos pero diferentes aplicaciones e inclusive diferentes bases de datos entonces lo debe hacer a través de algún estándar como XML. LINQ, hace que todo este proceso que antes era muy laborioso para los desarrolladores se simplifique considerablemente ya Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 8

9 que con una misma sintaxis se conecta a su base de datos, obtiene la información que necesita, crea los documentos XML, registra el contenido y lo puede enviar. La tecnología 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 también 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 OPERADORES BÁSICOS CON LINQ Nosotros podemos construir instrucciones LINQ de la misma forma que se hace con SQL, haciendo agrupaciones, ordenando, indicando que campos deseamos presentar, también 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 través de las claves externas que se representa en el modelo como propiedades que tienen una colección de elementos, pero Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 9

10 también 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 cláusulas SELECT, GROUP, ORDER, etc. Que para poder explotar todo el potencial que estas nos ofrecen deberíamos realizar un estudio a fondo de cada una de ellas pudiendo ser solo esta cláusula tema de una monografía completa VARIABLES CON TIPO IMPLICITO Esta es una nueva característica que nos ofrece C# 2008, una variable con tipo implícito 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 ; FUNCIONES ANONIMAS Métodos Anónimos Qué es un delegado? Los métodos anónimos aparecen con la versión 2.0 del Framework, la intención es simplificar el proceso de manejadores de eventos, pero esto implica tener un conocimiento básico sobre el funcionamiento de los delegados, es por esto que este tema hemos iniciado realizando la pregunta. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 10

11 Los métodos anónimos buscan definir el método al momento de declarar el delegado, de esta forma podemos ahorrar líneas de código ya que evitamos tener que crear funciones para resolver tareas simples. Sin embargo la lectura del código también se complica un poco. Los métodos anónimos aparecieron desde C# 2005 con el Framework 2.0 y estaban pensados para facilitar la definición de manejadores de eventos cuando las tareas a realizar son simples. button1.click += delegate MessageBox.Show("Hola"); ; Y si requiere utilizar parámetros solo cambiaría por lo siguiente: button1.click += delegate(object sender, EventArgs e) MessageBox.Show(e.ToString()); ; Netdeveloper Jose Manuel Alarcón. En el ejemplo se ha creado un método anónimo y lo que se ha evitado es la creación del método tradicional del botón para que presente el mensaje Hola : Private void button1_click(object sender,system.eventargs e) MessageBox.Show( Hola ); Expresiones LAMBDA Aunque el ejemplo que hemos expuesto cuando definimos los métodos anónimos es bastante sencillo, en la práctica necesitaremos crear instrucciones con una dificultad mayor a la que pusimos en nuestro ejercicio lo que obviamente repercutirá en la complejidad de los métodos anónimos. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 11

12 Las expresiones lambda son propias de C# 3 y nos permiten hacer lo mismo que los métodos anónimos pero de una forma más sencilla. Una de las características 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 código o de datos y son de mucha utilidad al momento de escribir instrucciones LINQ Interfaz IEnumerable <T> La interfaz IEnumerable <T> se inicia desde el Framework 2.0 y hereda de la Interfaz IEnumerable, Esta interfaz tiene como objetivo proveer de un mecanismo de iteración sobre los elementos de una secuencia generalmente buscando facilitar la utilización de un bucle foreach. En LINQ, la interfaz IEnumerable<T> 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 genéricas. La estructura de esta Interfaz es similar al código que se expone a continuación: Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 12

13 // System.Collections.Generic public interface IEnumerable<T> : IEnumerableIEnumerator<T> GetEnumerator(); // System.Collections public interface IEnumerableIEnumerator GetEnumerator(); // System.Collections.Generic public interface IEnumerator<T> : 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 genérica. En conjunto, IEnumerator<T> debe implementar los siguientes miembros: La propiedad Current, que devuelve el elemento actual de la secuencia (a dos niveles). El método Reset(), que restablece la enumeración a su valor inicial. El método MoveNext(), que desplaza el enumerador al siguiente elemento de la secuencia. Devuelve false cuando se llega al final de la secuencia. El método Dispose(), que libera cualesquiera recursos no administrados asociados al enumerador. La clase que implemente IEnumerator<T> deberá encargarse de mantener el estado necesario para garantizar que los métodos de la interfaz funcionen correctamente. Por qué esta separación en dos niveles, en la que básicamente IEnumerable<T> es de un nivel más alto, mientras que IEnumerator<T> se encarga del trabajo sucio? Por qué no dejar que las colecciones implementen directamente IEnumerator<T>? La respuesta tiene que ver con la necesidad de permitir la ejecución de iteraciones anidadas sobre una Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 13

14 misma secuencia. Si la secuencia implementara directamente la interfaz enumeradora, solo se dispondría de un estado de iteración en cada momento y sería imposible implementar bucles anidados sobre una misma secuencia, como por ejemplo los que se encuentran en la implementación típica de la ordenación mediante el algoritmo de la burbuja. En vez de eso, las secuencias implementan IEnumerable<T>, cuyo método GetEnumerator() debe producir un nuevo objeto de enumeración cada vez que es llamado. Por qué IEnumerable? Toda consulta LINQ que escribamos contiene el código 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 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. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 14

15 Estas clases ofrecen un alto potencial para trabajar con información 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 código potente y ágil para realizar consultas, modificar documentos y a través de este formato intercambiar información con otras aplicaciones 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 abstracción que nos da una mejor percepción del documento XML. XSD, no tiene una definición común para sus siglas pero respecto al significado de su funcionalidad todos concuerdan que es un lenguaje que nos da una mejor visión de la estructura de los documentos XML con lo que vamos a trabajar XSLT (Extensible SteelShetLanguage Language Transform) También desarrollado por WC3. Es un estándar 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 también está orientado a la web ya que permite separar el contenido de la presentación aumentando la productividad. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 15

16 1.4.8 Métodos Extendidos Es otra de las nuevas funcionalidades que nos brinda el Visual Studio 2008, consiste en la posibilidad de agregar nuestros propios métodos a las clases del.net o cualquier clase que nosotros queramos, encontrándole uno de los mayores beneficios en la facilidad de hacer validaciones. Se visualiza en el wizard con su nombre el signo de método y una pequeña flecha que significa extendido. EJEMPLO: Cuando solicitamos al usuario que ingrese la cédula la recibimos como una cadena. Si nosotros utilizamos mucho el proceso de validación de cédula entonces al implementar este método como una extensión de la clase string cada vez que declaremos una variable de este tipo aparecerá nuestro método como uno más de la clase. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 16

17 2. CONEXIONES CON LINQ 2.1 FUENTES A LAS QUE SE PUEDE CONECTAR Los orígenes de datos representan los datos con los que ya se sabe vamos a trabajar en la aplicación, se muestran en la ventana orígenes 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 diseño para crear y editar los orígenes de datos que va a utilizar en su aplicación, en los proyectos de Visual Studio los orígenes de datos se representan como conjuntos de datos u otros tipos de objeto, dependiendo de los objetos que devuelva el almacén de datos subyacente. Los orígenes de datos para trabajar con LINQ son: - LINQ a XML.- Nos permite conectar con orígenes de datos XML. - LINQ a SQL.- Permite la conexión 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 aplicación se conecte con bases de datos que nos sean SQL Server. - LINQ a DataSet.- también 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. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 17

18 Nota: Debido a lo extenso que es la tecnología LINQ, en esta investigación haremos una introducción a las dos primeras formas de conexión. Explicando cómo LINQ las define y trabaja con cada una de ellas y en los siguientes capítulos se harán ejemplos de consultas (SELECT), también haremos operaciones de insertar, editar y eliminar datos (INSERT, UPDATE, DELETE y finalizaremos indicando como ejecutar procedimientos almacenados desde LINQ LINQ A XML INTRODUCCION En la actualidad todas las empresas han comenzando a construir aplicaciones que estén orientadas a la web y no solamente a los tradicionales ambientes de oficina; siendo XML el formato que ha quedado definido como el estándar para realizar esta tarea. LINQ a XML no es otra cosa que proporcionar toda la potencialidad del Lenguaje Integrado de Consultas aplicado a la información que se encuentra contenida en este formato, permitiéndonos leer y modificar estos archivos de forma parecida a como lo hacíamos en versiones anteriores de.net a través de XMLReader y XMLWritter pero con una notable mejora en el consumo de memoria y la cantidad de código que debemos escribir para obtener los mismos resultados, adicionando la ventaja que con esta nueva tecnología podemos conectarnos y trabajar con otras fuentes de datos que a diferencia de Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 18

19 las clases que se utilizaban en versiones anteriores para trabajar con XML son única y exclusivamente para este formato Estructura Jerárquica de LINQ a XML Ventajas de utilizar LINQ a XML : Visión simplificada de los archivos XML.- Ya no tenemos que acceder a los nodos de los arboles XML a través de un documento, En LINQ se puede tratar tanto al documento como a los nodos que lo conforman como un XElement. Proporciona una identificación a los nodos de los archivos XML.- Podemos dar un nombre a cada elemento de nuestro árbol XML a través de la propiedad XName, esta utilidad será de gran ayuda al momento de realizar copias, reemplazos o al renombrar los Nodos. Creación de estructuras XML.- El Ejercicio 1 expone la gran facilidad con la que se puede crear estructuras XML a través del Lenguaje Integrado de Consultas. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 19

20 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 también 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 básicos para trabajar con formatos XML a nuestro criterio son XElement y XAttribute. Aunque otros desarrolladores también incorporan a XName, nosotros hemos preferido no hacerlo. Como ya hemos explicado antes XName es una gran innovación pero respaldados en los ejercicios que se han desarrollado en esta investigación creemos que no se lo debe tratar como un elemento básico de LINQ. EJERCICIO 1 Crear un archivo XML, que contenga la información básica de una persona. Para poder probar el ejercicio deberá crear un formulario con dos botones el uno para la forma Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 20

21 tradicional y el segundo utilizando el lenguaje Integrado de Consultas, además 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("Cédula"); nodcedula.innertext = " "; nodcontacto.appendchild(nodcedula); XmlElement nodnombre = DocumentoXML.CreateElement("Nombre"); nodnombre.innertext = "Juan Carlos Pérez Maldonado"; nodcontacto.appendchild(nodnombre); XmlElement noddireccion = DocumentoXML.CreateElement("Dirección"); noddireccion.innertext = "Av. De las Américas y Batán"; nodcontacto.appendchild(noddireccion); XmlElement nodtelefonos = DocumentoXML.CreateElement("Teléfonos"); Contacto.AppendChild(nodTelefonos); XmlElement nodtelcasa = DocumentoXML.CreateElement("Convencional1"); nodtelcasa.setattribute("hogar", " "); nodtelefonos.appendchild(nodtelcasa); XmlElement nodteltrabajo = DocumentoXML.CreateElement("Convencional2"); nodteltrabajo.setattribute("oficina", " "); nodteltrabajo.setattribute("desde", "09H00 AM"); nodteltrabajo.setattribute("hasta", "19h00 PM"); nodtelefonos.appendchild(nodteltrabajo); XmlElement nodtelcelular = DocumentoXML.CreateElement("Celular"); nodtelcelular.setattribute("celular", " "); nodtelefonos.appendchild(nodtelcelular); DocumentoXML.Save("d:\\SinLINQ.xml"); 2.- Utilizando LINQ XElement Persona = new XElement("Persona", new XElement("Contacto1", new XElement("Cédula", " "), new XElement("Nombre", "Juan Carlos Pérez Maldonado"), new XElement("Dirección", "Av. De las Américas y Batán"), new XElement("Teléfonos", new XElement("Convencional1", new XAttribute("Hogar"," ")), new XElement("Convencional2", new XAttribute("Oficina"," "), new XAttribute("Desde","09H00AM"), new XAttribute("Hasta","19H00pM")), new XElement("Celular", new XAttribute("Celular"," ")) ) ), ); Persona.Save("d:\\ConLINQ.xml"); Código: 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 código resalta a la vista. Esto se profundizará cuando estudiemos la clase XElement y XAttribute que son dos de los pilares de la funcionalidad XML. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 21

22 En el Ejercicio 1 podemos darnos cuenta de la inmensa ventaja de utilizar LINQ, si ejecutamos los dós codigos podremos comprobar que ambos crean un archivo XML exactamente igual, pero la cantidad de código que utilizamos es considerable. Es muy importante recalcar que LINQ también incorpora Intellisence, lo que significa que el mismo compilador nos permitirá detectar errores de sintaxis en la construcción de consultas Diferencias entre LINQ y XML La diferencia entre LINQ a XML y la programación habitual de XML no está unicamente en la cantidad de líneas de código que son necesarias escribir para poder crear árboles, documentos, atributos, leer archivos XML o modificarlos. Está claro que esta es una característica muy importante pero también hay otras mas que serán de mucha utilidad estudiarlas. No es indispensable un documento XML.- Si revisamos el Ejercicio #2 en la programacion común es indispensable primero crear o disponer de un documento Xml para poder continuar con la costrucción 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 ningún momento tuvimos que crear o cargar un documento contenedor (Documento XML). Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 22

23 Compatibilidad con espacios en blanco.- Los espacios en blanco siempre han significado un problema al momento de desarrollar código para leer, cargar o editar archivos XML, con LINQ a XML podemos tratar los espacios através de nodos texto conocidos como xtext. Compatibilidad con anotaciones.- Nos proporciona información de un elemento, si está enlazado con alguna interfaz de usuario, información de esquemas o cualquier otra información específica de una aplicación. 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 serialización se definirá los prefijos. Así mismo para cambiar el nombre de un nodo XML, se debía crear un nodo con diferente nombre y copiar todo el contenido del nodo original. En cambio LINQ soluciona este problema apoyándose 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 orígenes de datos, es más, tal vez ni siquiera haya un único origen de datos entonces Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 23

24 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 podría también ser una combinación entre XMLReader y las bondades que nos ofrece LINQ 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í también se dispone de la clase XAttribute que tiene la misma función 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, más bien podríamos decir que estos son parte de los nodos y que están 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 más facil manejar archivos unicamente con elementos y atributos. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 24

25 Cuando utilizamos la clase XDocument debemos tomar en cuenta que un documento solo puede tener un elemento secundario, siendo este el nodo ráiz. 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 mayoría de métodos que implementan cada una de ellas son muy similares entre sí. Ejemplo: XElement elemento = new XElement("MiElemento", new XAttribute("MiAtributo", "12")); Código: 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 código podemos darnos cuenta que instanciamos un objeto XElement, el primer parámetro 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 parámetros el nombre del elemento en este caso MiElemento y como segundo parámetro 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. Según la instancia que se utilice. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 25

26 Cargar un archivo XML Podemos cargar archivos XML a través de su path, con el método XElement.Load(), este método tiene instancias adicionales que nos permite dar opciones de carga como es mantener los espacios en blanco. La sintaxis de este método es la siguiente: XElement MiArchivo = XElement.Load("d:\\ConLINQ.xml"); XDocument MiArchivo = XDocument.Load("d:\\ConLINQ.xml"); Código: La primera línea carga el documento XML en un objeto XElement y la segunda carga el mismo documento pero en un objeto XDocument. El método 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 través de XDocument se crea un nodo para el documento y el nodo raíz 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 parámetro 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); Código: El segundo parámetro del metodo Load() indica que debe preservar los espacios en blanco Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 26

27 EJERCICIO 2 En este ejercicio vamos a cargar el archivo XML ConLINQ.xml que creamos al principio de este tema y despúes vamos a presentar el nombre del contacto. XElement Contacto = XElement.Load("d:\\ConLINQ.xml"); IEnumerable<XElement> NodosHijo = from persona in Contacto.Elements() select persona; foreach (XElement persona in NodosHijo) MessageBox.Show("Nombre: " + persona.nextnode.tostring()); Código: La instrucción de consulta carga todos los subnodos del nodo Contactos (NodoRaiz) y luego a través 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 código. Si queremos obtener el valor de un elemento XML, entonces solo debemos cambiar la presentacion del resultado por: MessageBox.Show("Nombre: " + persona.value.tostring()); 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. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 27

28 Una vez que hemos explicado cual es la funcionalidad de LINQ a SQL comenzaremos a realizar algunos ejemplos que no permitirán 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 diálogo 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: Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 28

29 Ahora debemos crear una conexión a la base de datos con la que deseamos trabajar para poder arrastrar las tablas y procedimientos almacenados que vayamos a manipular en nuestra aplicación Qué es mejor utilizar LINQ o Procedimientos Almacenados? Muchas veces los desarrolladores nos preguntamos que hace más eficiente nuestro código, 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 aplicación. 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 podría ser que terminemos desperdiciando recursos del equipo y por lo tanto nuestros programas se ralenticen. Por el contrario si decidimos obviarlo por completo también podemos perder mucho tiempo implementando código que se simplificaría mucho con el Lenguaje Integrado de Consultas. Esta decisión la deberá tomar el desarrollador después de analizar el entorno en el que va a funcionar los programas que construya. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 29

30 2.2 Cómo funciona LINQ? Siempre que comencemos a utilizar una herramienta o tecnología es importante saber cómo funciona? Y más aun si es nueva. Para entender mejor cómo?, y en qué? manera beneficiará esta a nuestra aplicación. 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 análisis correcto de estos agentes tendremos aplicaciones más 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 milésimas de segundo pero que en aplicaciones críticas podrían significar una gran diferencia. También si ejecutamos un programa que contenga código LINQ paso a paso, veremos que después de creada la consulta esta es una instrucción SQL, por lo que se convierte en un proceso similar a escribir sentencias SQL dentro del código de la aplicación. Y los Procedimientos Almacenados?. Si personalmente creemos que aunque utilicemos LINQ deberíamos conectarnos a la base de datos con PA que estén cargados en el contexto y dejar las consultas para los objetos DataSet y archivos XML. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 30

31 En conclusión podríamos decir que LINQ funciona como un intérprete de las transacciones que nosotros escribimos en el código de nuestro programa convirtiéndolas a T-SQL, XQuery, etc. Según cuál 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 también debemos indicar son diferentes. La primera es orientada específicamente para bases de datos que se encuentran almacenadas en un motor de SQL Server mientras que la segunda hace la misma función 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í también estas clases podrán ser instanciadas y por lo tanto también tendrán propiedades y métodos ajustados a cada una de ellas. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 31

32 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 específicamente como LINQ a SQL. Esta es solo una de las variantes de LINQ, puesto que el mismo puede utilizarse con otros orígenes 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 fácilmente 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 través de las consultas embebidas en los lenguajes de programación. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 32

33 En el gráfico anterior podemos observar como hemos creado la conexión a nuestra base de datos através 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 gráfico superior. Guardamos los cambios realizados en nuestra aplicación. Para terminar debemos hacer una instancia de nuestro ORM que tenemos creado. Esto se realiza de la siguiente forma: BDLINQDataContext MiEsquema = new BDLINQDataContext(); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 33

34 Absolutamente todas las entidades de la base de datos que deseamos utilizar con consultas LINQ deberán estar cargadas en el esquema de Base de datos. Podemos seguir agregando más entidades después 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 través del Lenguaje Integrado de Consultas se debe realizar a través de LINQ a Entidades. La siguiente instrucción 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; Código: Asignamos directamente el resultado de la consulta como DataSource de la grilla. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 34

35 3. ACCESO A LOS ARCHIVOS QUE CONTIENEN LA INFORMACION 3.1 CLAÚSULA SELECT CON LINQ SENTENCIA SELECT CON ORIGENES DE DATOS XML 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 información 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 específico 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 código es el siguiente: <?xml version="1.0" encoding="utf-8"?> <Report> <Section> <Heading> <Column Name="CustomerId">=Customer.CustomerId.Heading</Column> <Column Name="Name">=Customer.Name.Heading</Column> </Heading> <Detail> <Column Name="CustomerId">=Customer.CustomerId</Column> <Column Name="Name">=Customer.Name</Column> </Detail> </Section> </Report> Guardamos el archivo con el nombre EjemploMsdn1.xml y a continuación creamos un formulario con un botón. En el click del botón digitamos el siguiente código: Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 35

36 XElement root = XElement.Load("d:\\EjemploMsdn1.xml"); IEnumerable<XElement> 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()); Código: Creamos una sentencia LINQ en donde cargue todos los nodos descendientes del documento que llamamos en donde el valor del método ValorPresentar() que se construirá a continuación empiece con la letra C. Después de la llave que cierra la clase del formulario creamos una clase estática con el siguiente código: public static class MiExtension public static string ValorPresentar(this XElement xe) return xe.nodes().oftype<xtext>().aggregate(new StringBuilder(), (k, j) => k.append(j), k => k.tostring()); Ejercicio tomado de la ayuda de MSDN. Código: El código anterior extrae los nodos del elemento que estamos procesando que sean de tipo texto a través del método OfType(). Y estructura la cadena resultado a través de método Agregate que recibe tres parámetros: - 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 método Append() a la cadena que creamos en el paso anterior. - El tercero es una cadena que necesita el método agregate para presentar el resultado, la expresion lambda hace la asignacion Buscar Descendientes con un Nombre Específico El siguiente ejercicio nos muestra una forma sencilla de buscar descendientes con un nombre específico, este método tiene un funcionamiento similar al Find() o FindRows() que nos evitan las iteraciones cuando queremos encontrar elementos determinados en los DataViews. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 36

37 EJERCICIO 4 XElement archivo = XElement.Load("D:\\ConLINQ.xml"); IEnumerable<string> 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"); Código: Cargamos nuestro documento XML, luego escribimos la consulta LINQ, indicando que nos devolverá los nodos hijos a través del método Descendants() y pasando como parámetro 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 instrucción le ejecutamos el método Agregate() que recibe tres parámteros: - 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 extraído a partir del método Append() a la cadena que creamos en el paso anterior. - El tercero es una cadena que utiliza el método Agregate() para presentar el resultado, la expresión lambda hace la asignacion. Finalmente se presenta el resultado al usuario a través de un cuadro de diálogo 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 búsqueda 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 <Tests> <Test TestId="0001" TestType="CMD"> <Name>Convert number to string</name> <CommandLine>Examp1.EXE</CommandLine> <Input>1</Input> <Output>One</Output> </Test> <Test TestId="0002" TestType="CMD"> <Name>Find succeeding characters</name> <CommandLine>Examp2.EXE</CommandLine> <Input>abc</Input> <Output>def</Output> </Test> <Test TestId="0003" TestType="GUI"> <Name>Convert multiple numbers to strings</name> <CommandLine>Examp2.EXE /Verbose</CommandLine> <Input>123</Input> <Output>One Two Three</Output> </Test> Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 37

38 <Test TestId="0004" TestType="GUI"> <Name>Find correlated key</name> <CommandLine>Examp3.EXE</CommandLine> <Input>a1</Input> <Output>b1</Output> </Test> <Test TestId="0005" TestType="GUI"> <Name>Count characters</name> <CommandLine>FinalExamp.EXE</CommandLine> <Input>This is a test</input> <Output>14</Output> </Test> <Test TestId="0006" TestType="GUI"> <Name>Another Test</Name> <CommandLine>Examp2.EXE</CommandLine> <Input>Test Input</Input> <Output>10</Output> </Test> </Tests> En nuestro botón del formulario escribimos el siguiente código: XElement root = XElement.Load("D:\\EJEMPLO1.xml"); IEnumerable<XElement> 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")); Código: 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 através del bucle foreach SENTENCIA SELECT CON ORÍGENES DE DATOS SQL SERVER Existen tres formas básicas de realizar consultas con LINQ a SQL: - Mediante la sintaxis de consulta - Mediante la sintaxis de método - Mediante una combinación 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. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 38

39 Comenzaremos haciendo unos ejercicios que nos permitan cargar información de nuestra base de datos a través de la cláusula 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 pequeña explicación del código 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: BDLINQDataContext MiEsquema = new BDLINQDataContext(); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 39

40 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; Código: 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 parámetro, al ejecutar el programa quedará visualizando el último registro en el texto, también 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; Código: Se diferencia del ejercicio anterior porque la consulta implementa una condición where para que visualice los registros en los que el nombre del cliente empiece con las letras C o J Ordenar Resultados de Consultas Toda la información que presenten nuestras aplicaciones deberá estar ordenada para simplificar al usuario su análisis. Esta operación se hace posible a través del operador OrderBy. En los siguientes ejercicios indicaremos el funcionamiento de esta cláusula ordenando los resultados por nombre en forma ascendente y luego descendente. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 40

41 Ejercicio 8 public IQueryable LitaOrdenadaASC() var Consulta = from cliente in MiEsquema.Cliente orderby cliente.nomcli ascending select cliente; return Consulta; public IQueryable LitaOrdenadaDSC() var Consulta = from cliente in MiEsquema.Cliente orderby cliente.nomcli descending select cliente; return Consulta; Código: Tenemos 2 métodos 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 Operadores: Sumar, Promedio y Contar Continuamente es necesario realizar cálculos a través de consultas para evitar tener que implementarlas después en el código del programa a través de barridos. En los siguientes ejemplos haremos ejercicios que nos darán como resultado el número 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); Código: El código 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 método Count() para que nos devuelva el número de registros. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 41

42 Para facilitar el entendimiento del código vamos a crear los siguientes dos métodos de la entidad producto en nuestra clase cliente, para obtener el costo promedio de los precios que tienen nuestra mercadería. EJERCICIO 10 System.Nullable<Decimal> Promedio = (from prom in MiEsquema.Producto select prom.preprd).average(); MessageBox.Show("El costo promedio de los productos es: " + Promedio.ToString(),"Calcular Promedio"); Código: Construimos la consulta LINQ entre parentesis y después de la palabra clave select seleccionamos la propiedad precio (prom.preprd) despues cerramos el parentesis y llamamos al método Average() que calcula el promedio y devuelve un valor decimal. Finalmente presentamos el resultado en un cuadro de diálogo. Ejercicio 11 public void SumaPrd() System.Nullable<Decimal> 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"); Código: Es el mismo proceso que el cálculo del promedio, unicamente cambiamos la llamada al método Average() por el método Sum() 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 newestado=g.key,cantidad = g.count(); string cadena = ""; Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 42

43 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:"); Código: 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, después digitamos la palabra reservada by seguido de los campos por los que vamos a agrupar. En el caso de ser más 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 através 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 deberán estar agrupados o ser parte de una funcion de agrupación. Los resultados se presentan através 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 diálogo. El código del formulario para llamar a los métodos que hemos creado en nuestra clase cliente estaría 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(); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 43

44 private void btnagrupar_click(object sender, EventArgs e) objcliente.agruparprd(); Código: Solo son llamadas a los métodos que hemos creado en la clase cliente. En el botón ordenar podemos ver una línea 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 Insertar, Modificar y Eliminar nodos de un archivo XML. Hasta aquí hemos hecho pequeños ejemplos sobre el funcionamiento de la cláusula Select que nos permite consultar y cargar los datos de archivos XML, pero como hemos mencionado en la introducción las consultas embebidas en los lenguajes de programación también nos sirven para editar el contenido de los archivos con este formato. Consecuentemente nos faltaría hacer el ejercicio que haga un AGE (Actualizar, Guardar y Eliminar) a los datos de estos orígenes XML utilizando el potencial de LINQ a XML para esto crearemos un pequeño formulario como se muestra en la siguiente figura: EJERCICIO 13 Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 44

45 En el evento click del botón de crear archivo escribiremos el siguiente código a través 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", " ") ), new XElement("Registro", new XElement("Codigo", 2), new XElement("Nombre", "Martha Florinda Iñiguez Santillán"), new XElement("Telefono", " ") ) ) ); 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); Código: 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. También podemos notar que después de hacer la instancia del documento utilizamos la clase XComment que agrega un comentario al documento XML. El siguiente paso consiste en crear una enumeración y luego dos métodos 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; Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 45

46 CargarNodo.ElementAt(0).ReplaceAll( new XElement("Codigo", txtcodigo.text), new XElement("Nombre", txtnombre.text), new XElement("Telefono", txttelefono.text)); DocXML.Save("d:\\EjemploAGE.xml"); break; case opciones.eliminar: var EliminarNodo = from NodoEliminar in DocXML.Descendants("Registro") where NodoEliminar.Element("Codigo").Value == txtcodigo.text select NodoEliminar; catch EliminarNodo.Remove(); DocXML.Save("d:\\EjemploAGE.xml"); break; MostarArchivo("Transaccion compleatada. El nuevo archivo es:"); MostarArchivo("No se pudo completar la transaccion. El archivo actualmente se encuentra de la siguiente forma:"); Código: Instanciamos y cargamos nuestro archivo con el método 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 través de la clase XElement instanciada con el nombre de Nuevo Registro. Terminada de crear la nueva estructura la implementamos a través del método Add() y finalmente guardamos el documento con el método Save(). - Modificar.- A través de una consulta LINQ, colocamos en la variable CargarNodo el elemento XElement que va a ser modificado, después con el método ReplaceAll(), reemplazamos los nuevos valores del nodo y guardamos el documento con el método 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 través del método Remove(), y de igual forma que en guardar y actualizar guardamos el documento con el método 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); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 46

47 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 código, nombre, dirección y teléfono del cliente; tres botones de edición: guardar, modificar y eliminar. Además 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 código referente a la creación, actualización y eliminación de registros que hagamos con la entidad clientes. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 47

48 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(); Código: Instanciamos la clase cliente, luego asignamos a las propiedades los valores de los parámetros que recibe el método. Finalmente através de la instancia (MiEsquema) de nuestro ORM seleccionamos la entidad que va a ser cambiada (Cliente) y llamamos al metodo InsertOnSubmit, le pasamos de parámetro nuestro objeto cliente (objcliente) y el método 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; MiEsquema.SubmitChanges(); Código: 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 instrucción hemos utilizado el método First(); que indica que el resultado es solo un registro. A continuación asignamos los nuevos valores y enviamos a guardar através del método 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); MiEsquema.SubmitChanges(); Código: Igual que al momento de actualizar cargamos el registro que vamos a eliminar. Y ejecutamos la acción a través del método DeleteOnSubmit pasando como parámetro objelimina. Y el método SubmitChanges() confirma los cambios en la BD. Y el código 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(); private void btnmodificar_click(object sender, EventArgs e) objcliente.modificar(txtcodigo.text,txtnombre.text, txtdireccion.text, txttelefono.text); Cargar(); private void btneliminar_click(object sender, EventArgs e) Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 48

49 objcliente.eliminar(txtcodigo.text); Cargar(); #region CargarDatosCliente private void Cargar() dtglistado.datasource=objcliente.listadocliente(); #endregion Código: En cada uno de los botones hacemos el llamado a los métodos de la clase cliente y pasamos de parámetros los valores de las cajas de texto. El método 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 continuación vamos a utilizar el mismo formulario del ejercicio anterior y solamente incrementaremos tres métodos más a la clase clsclientes Antes de comenzar a escribir código 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, también deberemos realizar la instancia del contexto. BDLINQDataContext MiEsquema = new BDLINQDataContext(); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 49

50 En nuestro ejemplo hemos implementado el código 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 métodos de nuestra clase. Esto con la finalidad de tener una sola clase a la que iremos agregando más 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)); Código: 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 parámetros (). 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 paréntesis los parámetros que este necesite. El código 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); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 50

51 Cargar(); private void btnmodificar_click(object sender, EventArgs e) objcliente.modificarpa(txtcodigo.text,txtnombre.text,txtdireccion.text, txttelefono.text); Cargar(); private void btneliminar_click(object sender, EventArgs e) objcliente.eliminarpa(txtcodigo.text); Cargar(); #endregion #region CargarDatosCliente private void Cargar() dtglistado.datasource=objcliente.listadocliente(); #endregion Código: En el formulario se hace el mismo procedimiento que cuando hicimos las transacciones con sentencias LINQ, solamente cambiando el nombre de los métodos de la clase. 3.4 EJEMPLO Aplicación Demo Hemos desarrollado ejemplos de consultas con la instrucción Select y también hemos realizado operaciones de insertar, modificar y eliminar información tanto de fuentes XML como bases de datos relacionales. Por lo que hemos creído conveniente terminar el proceso de investigación construyendo una aplicación demo, que imite el funcionamiento de una factura de venta y cree un archivo XML con el contenido de la transacción que realizamos. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 51

52 Iniciemos creando un proyecto windows y agregando un formulario similar al que se muestra en la figura anterior que nos permitirá realizar: 1.- Búsquedas de clientes a través del botón que se encuentra a lado del código. 2.- Agregar productos a nuestra factura con el botón Productos. 3.- Crear clientes. 4.- Y en el menú tenemos las opciones para crear y guardar las facturas. Cuando guardemos la transacción 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 código. Vamos a agregar una clase factura (clsfactura) a nuestro proyecto que acabamos de crear y escribiremos el siguiente código: BDLINQDataContext MiEsquema = new BDLINQDataContext(); DataTable dtdetalle; public clsfactura() Código: Librerías utilizadas,instancia del contexto, declaración el DataTable que será el detalle de la factura y creación del constructor por defecto de la clase factura. Ahora si podemos comenzar a implementar los métodos 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; Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 52

53 dtdetalle.columns["total"].expression= "("+dtdetalle.columns["cantidad"]+")*("+dtdetalle.columns["precio"]+")"; return dtdetalle; Código: 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 expresión de cálculo al DataTable con el propósito que se calcule automáticamente cada línea de la factura. Mensaje private void Mensaje(string mensaje, string titulo) MessageBox.Show(mensaje, titulo, MessageBoxButtons.OK, MessageBoxIcon.Warning); Código: Este método será el encargado de presentar los mensajes de información de la clase factura Número de Factura public int pnumerofactura get try return (from numero in MiEsquema.FacturaCabecera select numero.numfac).max() + 1; catch throw; Código: Propiedad que devuelve el número de factura, La instrucción LINQ busca en la cabecera de factura el máximo valor que tenga el campo NumFac y le suma 1. Actualizar Detalle public void ActualizarDetalle() if (dtdetalle!= null) dtdetalle.acceptchanges(); Código: Actualiza todos los cambios que se hayan hecho en el DataTable dtdetalle. Es como realizar una confirmación y aceptación a las modificaciones realizadas en este. Deshacer Cambios public void DeshacerCambiosDetalle()dtDetalle.RejectChanges(); Código: 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 código de cliente válido", "Datos del cliente"); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 53

54 return false; else if (Nombre.Trim() == "") Mensaje("No ha ingresado el nombre del cliente", "Datos del cliente"); return false; else if (Direccion.Trim() == "") Mensaje("No ha ingresado la dirección del cliente", "Datos del cliente"); return false; else if (Nombre.Trim() == "") Mensaje("No ha indicado la fecha de facturación", "Fecha Factura"); return false; else if (dtdetalle.rows.count == 0) Mensaje("Debe ingresar al menos un item paa facturar", "Facturar en cero"); return false; return true; catch throw; Código: Método de validación que devuelve verdadero si todos los datos están correctos, caso contrario a través del método mensaje informa al usuario que campos le falta llenar. Guardar Factura public void Guardar(string CodCliente, string NomCliente, string Direccion, string telefono, string Fecha, string total) try ActualizarDetalle(); int numero = pnumerofactura; if (Validar(CodCliente, NomCliente, Direccion, Fecha)) MiEsquema.FacCabGuarda(numero,short.Parse(CodCliente), DateTime.Parse(Fecha),decimal.Parse(total)); for (int i = 0; i < dtdetalle.rows.count; i++) MiEsquema.FacDetGuarda(numero, short.parse(dtdetalle.rows[i][0].tostring().trim()), int.parse(dtdetalle.rows[i][2].tostring().trim()), decimal.parse(dtdetalle.rows[i][3].tostring().trim()), decimal.parse(dtdetalle.rows[i][4].tostring().trim())); if (MessageBox.Show("Desea generar el archivo XML de esta factura", "XML", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) SaveFileDialog sfdarchivo = new SaveFileDialog(); bool Preguntar = true; while (Preguntar == true) Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 54

55 sfdarchivo.showdialog(); if (sfdarchivo.filename.trim() == "") if (MessageBox.Show("Debe indicar una ruta para generar el archvivo. Desea volver a intentar", "Ruta archivo XML", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) Preguntar = false; else Preguntar = false; GenerarXML(numero, CodCliente, NomCliente, Direccion, telefono, total, sfdarchivo.filename); catch (Exception ex) Mensaje(ex.Message, "Guardar"); Código: Este es el método más grande de nuestra clase. Pero no es nada complicado. 1.- En las dos primeras líneas actualizamos el detalle de la factura para que se confirmen los cambios y después calculamos nuevamente el número de documento. 2.- Llamamos al método validar que devuelve un booleano para verificar que todos los campos indispensables estén llenados. Cualquier error lo reportrá el propio método. 3.- Ejecutamos nuestro procedimiento almacenado para guardar la cabecera de la factura (FacCabGuarda) enviando los parámetros que necesita. 4.- A continuación construimos un bucle para enviar a guardar el detalle. También con Procedimiento almacenado(facdetguarda) enviando los parámetros que necesita. 5.- Pregunta al usuario a través de una caja de dialogo si quiere generar un archivo XML, de la factura que generó. 6.- Si la respuesta del usuario fue SI, entonces declaramos un componente SaveFileDialog y una variable booleana Preguntar que se inicia en false. 7.- Creamos un bucle que le presente al usuario el SaveFileDialog cuantas veces necesite para guardar el archivo. Si el usuario no da una ubicación del archivo entonces le advierte que no se generará el archivo y le preguntará si quiere asignar una ubicación o prefiere cancelar la creación del archivo. 8.- Llama al método generar el archivo XML y pasa los parámetros que necesita. 9.- Solo si en alguno de los pasos anteriores ocurre un error, entraría al Catch y envía el contenido de la variable de Excepción ex. GENERAR ARCHIVO XML private void GenerarXML(int numero,string CodCliente,string NomCliente,string DirCliente,string TelCliente,string totfactura,string ruta) if (ruta.trim()!= "") XElement Factura = new XElement("Factura", new XElement("Cabecera", new XElement("Numero", numero), new XElement("Cod_Cliente", CodCliente), new XElement("Cliente", NomCliente), new XElement("Dirección", DirCliente), Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 55

56 new XElement("Telefono", TelCliente) ) ); XElement Detalle = new XElement("Detalle"); for (int i = 0; i < dtdetalle.rows.count; i++) XElement item = new XElement("Item", new XAttribute("Linea", (i + 1))); XElement Codigo = new XElement("Cod_Producto", dtdetalle.rows[i][0].tostring().trim()); XElement Descripcion = new XElement("Descripción", dtdetalle.rows[i][1].tostring().trim()); XElement Cantidad = new XElement("Cantidad", dtdetalle.rows[i][2].tostring().trim()); XElement Precio = new XElement("Precio", dtdetalle.rows[i][3].tostring().trim()); XElement Total = new XElement("Total", dtdetalle.rows[i][4].tostring().trim()); item.add(codigo, Descripcion, Cantidad, Precio, Total); Detalle.Add(item); XElement ntotal = new XElement("Total", totfactura); Factura.Add(Detalle); Factura.Add(nTotal); Factura.Save(ruta + ".xml"); Código: Crea el archvio XML de la factura que se guardó. Comienza haciendo una validación que el parámetro ruta no esté en blanco. Esto porque en el bucle que hay en el método que guarda la factura, sí se da la opción al usuario de que no seleccione ningún lugar para guardar. En este caso no se genera el archivo XML. Si pasa esta condición empieza a realizar los giguientes pasos: 1.- Declara un XElement Factura y dentro de esta instancia crea el nodo cabecera. 2.- En la misma instancia del nodo cabecera, crea los nodos hijos que tendrán la información de la cabecera de la factura. Estos elementos son: - Número de factura - Código del cliente. - Nombre del cliente. - Dirección del cliente. - Teléfono del cliente. 3.- Creamos un nodo detalle que contendrá todos los productos vendidos. 4.- Dentro del nodo detalle creamos elementos que contengan los valores: - Item que es el número de línea del detalle - Codido del producto - Descripción del producto - Cantidad vendida - Precio de venta - Total de línea 5.- Agregamos todos los subnodos al nodo item. 6.- Creamos el elemento Total y asignamos el valor de la venta. 7.- Agregamos el nodo item al nodo detalle. 8.- Agregamos el nodo detalle al nodo factura. 9.- Agregamos el nodo total a la factura Guardamos el archivo xml en la ruta especificada por el usuario. Ahora debemos escribir el siguiente código en el formulario de la factura METODOS private void total() objfactura.actualizardetalle(); double acumulador = 0; Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 56

57 for (int i = 0; i < dtgdetalle.rowcount; i++) acumulador = acumulador + double.parse(dtgdetalle.rows[i].cells["total"].value.tostring()); txttotal.text = acumulador.tostring(); private void EstadoControles(bool Habilitar) gbcabecera.enabled = Habilitar; gbdetalle.enabled = Habilitar; btncrearcliente.enabled = btnagregarproductos.enabled = Habilitar; mnuguardar.enabled = Habilitar; mnunuevo.enabled =!Habilitar; Código: Creamos dos métodos. El primero que calculará el total de la venta y el segundo que habilitará e inhabilitará los controles de acuerdo al parámetro que reciba. BOTONES private void btnbuscarcliente_click(object sender, EventArgs e) frmbuscarcliente objbuscar = new frmbuscarcliente(); objbuscar.showdialog(); object[] valor = objbuscar.pcliente; if (valor!= null) txtcodcliente.text = valor[0].tostring(); txtnombre.text = valor[1].tostring(); txtdireccion.text = valor[2].tostring(); txttelefono.text = valor[3].tostring(); private void btnagregarproductos_click(object sender, EventArgs e) frmproductos objproducto = new frmproductos((datatable)dtgdetalle.datasource); objproducto.showdialog(); total(); private void btncrearcliente_click(object sender, EventArgs e) Clientes.frmCliente objcliente = new pruebalinq.clientes.frmcliente(); objcliente.showdialog(); Código: En los tres botones del formulario escribimos el Código correspondiente a cada uno de ellos. Acuérdese el botón buscar cliente está representado por, lo que hacemos en cada uno de los botones es llamar al respectivo formulario. 1.- Botón Buscar Cliente.- Llamamos al formulario de buscar clientes que nos devolverá un vector con toda la información del cliente que seleccionemos. Como se verá al momento que construyamos dicho formulario. 2.- Botón Agregar Productos.- Llama al formulario que agrega los productos. Este formulario recibe de parámetro un DataTable que será el que almacene los items. Después de cargar cada item llama al método que calcula el Total(). 3.- Llama al formulario que crea, modifica y elimina los clientes. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 57

58 EVENTOS private void txttelefono_keypress(object sender, KeyPressEventArgs e) if (!Char.IsDigit(e.KeyChar) && e.keychar!= 13 && e.keychar!= 8) e.handled = true; private void dtgdetalle_dataerror(object sender, DataGridViewDataErrorEventArgs e) MessageBox.Show("Los valores ingresados en el detalle no son correctos", "Detalle Factura"); private void dtgdetalle_cellvaluechanged(object sender, DataGridViewCellEventArgs e) if (e.rowindex >= 0) frmproductos objproducto = new frmproductos(); if (e.columnindex == 2) if (int.parse(dtgdetalle.rows[e.rowindex].cells[e.columnindex].value.tostring()) <= objproducto.disponible(dtgdetalle.rows[e.rowindex].cells[0].value)) total(); else objfactura.deshacercambiosdetalle(); MessageBox.Show("No dispone de la cantidad solicitada", "Existencias", MessageBoxButtons.OK, MessageBoxIcon.Warning); Código: Se manejan unicamente tres eventos. 1.- KeyPress.- Del texto de teléfono para que el usuario solo pueda ingresar números, dar enter y borrar. 2.- DataError.- De la grilla que contiene el detalle de la factura. Esto para que el mensaje de error sea personalizado. No es indispensable pero si no se le maneja y el usuario ingresa letras en la columna cantidad tendrá un mensaje similar al siguiente: Esto se debe a que al crear el DataTable nosotros asignamos el tipo de datos entero. Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 58

59 3.-CellValueChanged.- Cuando cambia el valor en la celda de la grilla. Preguntamos si el valor que cambió fue en la columna 2, que representa la cantidad del producto. Entonces llamamos al método Disponible() del formulario productos, que nos avisará cuanto podemos facturar. Este método lo revisaremos mejor en el siguiente paso cuando construyamos el formulario de Agregar Productos. FORMULARIO AGREGAR PRODUCTOS La forma más sencilla de Agregar Productos es através de un formulario que contenga información de los mismos, con sus: códigos, nombres, precios y existencia actual. En este ejemplo hemos creado un formulario con el nombre de frmproductos como se muestra en la figura de abajo. El código de esta pantalla es el siguiente: DataTable dtfacturado = new DataTable(); BDLINQDataContext MiEsquema = new BDLINQDataContext(); public frmproductos() Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 59

60 public frmproductos(datatable Factura) InitializeComponent(); this.dtfacturado = Factura; Código: Las primeras líneas declaran las instancias del DataTable y del contexto. Después podemos ver que tenemos dos constructores el uno sin parámetros que controla la existencia de productos cuando se lo llama desde la factura en el evento CellValueChanged y el otro que recibe de parámetro un DataTable que se utiliza cuando se está agregando productos. Ver botón Productos en el formulario de Factura. LOAD private void frmproductos_load(object sender, EventArgs e) dtgproductos.datasource = from prd in MiEsquema.Producto where prd.estprd == true orderby prd.codprd select new Codigo = prd.codprd, Descripcion = prd.desprd, Precio = prd.preprd, Existencia=prd.ExiPrd ; dtgfacturados.datasource = dtfacturado; Código: En el Load() del formulario, escribimos la instrucción LINQ que cargue los registros de la entidad producto en los cuales el estado del producto sea activo y ordenado por código. En el select podemos observar que cada campo de la entidad producto esta precedido por un identificador y el signo igual. Esto es el equivalente a la palabra clave AS de las sentencias SQL. METODOS private bool VerificarExistencia(object Codigo) for (int i = 0; i < dtfacturado.rows.count; i++) if (dtfacturado.rows[i][0].tostring().trim() == Codigo.ToString().Trim()) if (Disponible(Codigo) > (int.parse(dtfacturado.rows[i][2].tostring()))) dtfacturado.rows[i][2] = int.parse(dtfacturado.rows[i][2].tostring()) + 1; else MessageBox.Show("No dispone de la cantidad solicitada", "Existencia", MessageBoxpButtons.OK, MessageBoxIcon.Warning); return true; return false; public int Disponible(object codigo) return int.parse(((from exis in MiEsquema.Producto where exis.codprd.trim() == codigo.tostring().trim() select exis.exiprd).single()).tostring()); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 60

61 Código: El método VerificarExistencia(). Comprueba si el producto que está seleccionando ya ha sido facturado. En ese caso no se incrementa ninguna fila en la grilla de la factura, sino solo se incrementa uno en la cantidad. El método Disponible() ejecuta la sentencia LINQ que devuelve la existencia de un producto en base al código del mismo. Podemos notar que la instrucción al final llama al método Single(), que indica que el resultado de la consulta será un solo valor. EVENTOS private void dtgproductos_rowheadermouseclick(object sender,datagridviewcellmouseeventargs e) if (!VerificarExistencia(dtgProductos.Rows[e.RowIndex].Cells[0].Value)) if (Disponible(dtgProductos.Rows[e.RowIndex].Cells[0].Value) > 0) DataRow fila = dtfacturado.newrow(); fila[0] = dtgproductos.rows[e.rowindex].cells[0].value; fila[1] = dtgproductos.rows[e.rowindex].cells[1].value; fila[2] = 1; fila[3] = dtgproductos.rows[e.rowindex].cells[2].value; dtfacturado.rows.add(fila); else MessageBox.Show("No dispone de la cantidad solicitada", "Existencia", MessageBoxButtons.OK, MessageBoxIcon.Warning); Código: Este es el único evento que tiene el formulario de agregar productos. Cuando hace click en la cabecera de las filas. Agrega una fila al DataTable que pasamos de parámetro y se reflejan los cambios en el detalle de la factura inmediatamente. FORMULARIO BUSCAR CLIENTE Ahora nos toca hacer una pantalla que nos permita buscar nuestros clientes. Este formulario es el más pequeño de todos y tiene la siguiente forma: Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 61

62 En la figura anterior podemos notar que hay una pantalla encerrada. Esa es la que nos permitirá buscar a nuestros clientes. El código es el siguiente BDLINQDataContext MiEsquema = new BDLINQDataContext(); object[] cliente = null; Código: De igual forma que en las ventanas anteriores, debemos instanciar nuestro contexto. También tenemos un vector object que nos devolverá el cliente seleccionado. LOAD private void frmbuscarcliente_load(object sender, EventArgs e) dtgcliente.datasource = from cli in MiEsquema.Cliente where cli.estcli == true select new cli.codcli, cli.nomcli, cli.dircli, cli.telcli ; Código: Instrucción LINQ que carga todos los clientes que estén activos y el resultado se asigna a una grilla. EVENTOS private void dtgcliente_rowheadermouseclick(object sender, DataGridViewCellMouseEventArgs e) pcliente= new object[] dtgcliente.rows[e.rowindex].cells[0].value, dtgcliente.rows[e.rowindex].cells[1].value, dtgcliente.rows[e.rowindex].cells[2].value, dtgcliente.rows[e.rowindex].cells[3].value, ; this.close(); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 62

63 Código: Toma la fila seleccionada y la asigna al vector que declaramos en la parte superior. PROPIEDADES public object[] pcliente set cliente = value; get return cliente; Código: Unicamente devuelve el vector que fue cargado en el evento anterior. Para terminar haremos la implementación del formulario crear cliente. Que será llamado desde el botón cliente. El formulario para realizar transacciones con clientes ha sdido implementado basándonos en el formulario de los ejemplos de LINQ a SQL, dejando solo los métodos que ejecutan los procedimientos almacenados. El código del formulario es el siguiente: public partial class frmcliente : Form Clientes.clsCliente objcliente = new clscliente(); public frmcliente() InitializeComponent(); Investigadores: Tngl. Andrés León O. - Ing. Jorge Ochoa Página 63