LINQ

Language Integrated

Queries

Descripción general Arquitectura Antes y ahora Operadores de consulta Nuevas características XLinq DLinq Relación entre Linq y Excel Linq to XSD Diferencias entre XSD y Linq SQLMetal Diseñador O/R LinqPAD LinqPREVIEW PLinq Linq y Java Demo Preguntas

LINQ está integrado directamente en tu lenguaje de programación favorito: Simplemente los diseñadores de un lenguaje integran la

funcionalidad de esta API en C# o Visual Basic.NET

Aplicable no solamente to SQL o XML sino a toda clase que implemente IEnumerable<T>

Tipos de LINQ

LINQ: Language Integrated Query for in memory objects (LINQ to Objects)

DINQ: Language Integrated Query for databases (LINQ to ADO NET)

XLINQ: Language Integrated Query for XML (LINQ to XML)

ANTES

SELECT * from Libros WHERE CantidadStock> 50 AND Precio > 50.00

AHORA CON LINQ

var result = from b Libros where b.CantidadStock > 50 AND Precio > 50.00 select b;

Las palabras clave from, where y select pertenecen a los operadores de consulta estándar de LINQ.

Son traducidos por el compilador en C# a un conjunto de métodos.

Ejemplo

//Obtener solo la gente cuyos nombres comiencen por Dvar namesWithD = from poster in mostActive where poster.StartsWith("D") select poster;

Es traducido a: (Explicit Dot Notation)

var namesWithD = mostActive .Where(person => person.StartsWith("D")) .Select(person => person);

Declaración implícita de tiposTipos anónimos Inicializadores de objetosMétodos de extensiónExpresiones lambdaÁrboles de expresión

(Solamente necesitamos importar System.Linq para poder hacer uso de LINQ en nuestro código)

var es una nueva palabra clave en C# 3.0 que se utiliza para indicar al compilador que se quiere hacer uso de la Inferencia de Tipos en una Variable Local de C# 3.0

A diferencia de JavaScript, donde var representa una variable de tipo variable, esta palabra clave en C# indica al compilador que infiera el tipo de la asignación

Ejemplos

var myInt = 5;var myString = "This is pretty stringy";var myGuid = new System.Guid();myInt = "Haha, let's see if we can trick the compiler!";

devuelve un error

int num = 50;

string str = “simple string";

myType obj = new myType();

int[] numbers = new int[]{1,2,3};

Dictionary<int,myType> dic = new

Dictionary<int,myType>();

var num = 50;

var str = "simple string";

var obj = new myType();

var numbers=new int[]{1,2,3};

var dic = new Dictionary<int,myType>();

Permite crear objetos de tipo anónimo --> de nuevo podemos omitir el tipo cuando instanciamos un objeto y este es construido de manera dinámica en tiempo de compilación.

Además de poder definir un objeto de manera anónima, es posible definir propiedades asociadas al mismo.

var Santander=new {NombreCiudad="Santander", PoblacionCiudad=180000}; Console.WriteLine("La ciudad de " + Santander.NombreCiudad + " tiene una población de " + Santander.PoblacionCiudad + " habitantes"); Console.ReadLine(); Console.WriteLine("Santander es de tipo " + Santander.GetType()); Console.ReadLine();

Ejemplo

Salida por pantalla del ejemplo anterior:

Como vemos, aunque hemos declarado un tipo anónimo, el compilador es capaz de inferir el tipo correspondiente y sacar por pantalla los valores de sus propiedades.

El tipo devuelto es <Projection>f __0 que es el que se infiere en tiempo de compilación.

Esta innovación permite inicializar objetos (anónimos o no) en el momento en el que los instanciamos

Ejemplo

public class Ciudad { public string NombreCiudad; public int PoblacionCiudad; } static void Main(string[] args) { Var Santander=new Ciudad{NombreCiudad="Santander", PoblacionCiudad=180000}; Console.WriteLine("La ciudad de " + Santander.NombreCiudad + " tiene una población de " +

Santander.PoblacionCiudad + " habitantes"); Console.ReadLine(); Console.WriteLine("Santander es de tipo " + Santander.GetType()); Console.ReadLine(); }

Combina inferencia de tipos e inicialización de

objetos

Crea clases de extensión que nos permitan extender la funcionalidad de tipos existentes a partir de crear nuevos métodos.

Los métodos de extensión son métodos estáticos que son habilitados como métodos de extensión a través de la palabra reservada this.

static class ExtensionDeTipos { public static string Saludar(this string nombre) { return ("Hola " + nombre + "!"); } } static void Main(string[] args) { string nombre = "Mundo"; Console.WriteLine(nombre.Saludar()); Console.ReadLine(); }

Ejemplo

CARACTERÍSTICA IMPORTANTE

Es que se pueden añadir a cualquier tipo, incluyendo tipos

genéricos como List <T> y Dictionary <T>

Son la evolución de los métodos anónimos de C# 2.0 Habilitan el uso de condiciones sin tener que especificar el tipo.

List <string> NombresLongitudMayor5 = nombres.FindAll(delegate(string s) {return(s.Length)>=5;});

Método anónimo C# 2.0

var NombresLongitudMayor5 = nombres.FindAll(s => s.Length>=5);

Usando expresiones Lambda en C# 3.0

Una expresión Lambda tiene 3 elementos: Un parámetro de lista (s), que puede ser tipado de manera explícita

o implícita . El token => La expresió a aplicar

var nombres=new List<string>(); nombres.Add("Luis"); nombres.Add("Juan Carlos"); nombres.Add("Pepe"); nombres.Add("Ramón");  var NombresLongitudMayor5=nombres.FindAll(s => s.Length>=5); foreach(string nombre in NombresLongitudMayor5) { Console.WriteLine(nombre); } Console.ReadLine();

Habilitan la utilización de expresiones lambda como datos en tiempo de ejecución.

La clave de la definición de árboles de expresión está en un nuevo tipo: Expression <T>.

Expression<Func<string,bool>> NombresLongitudMayor5= s => s.Length>=5;

Console.WriteLine(NombresLongitudMayor5);

Console.ReadLine();

Ejemplo

Dos puntos de vista

Simplificación de la programación XML mediante la adición de consultas específicas para XML.

Xlinq proporciona: Construcción funcional Manipulación de forma natural de elementos XML Empleo de nombres expandidos ( evitar prefijos ) Lenguaje integrado de consultas

Componente proyecto LinqModernización/readaptación API DOM

XAttribute XNode

XCharacterNode

XCData

XComment XContainer XDeclaration

XDocument

XDocumentType

XElement

XName

XProcessingInstruction

XText(internal)

Origen datos: Fichero, cadena texto, XmlReader o TextReader.

Creación de XML por “Scratch”: Construcción funcional. Creación a modo de objetos. Ejemplo:

XElement contacts =new XElement("contacts",new XElement("contact",new XElement("name", "Patrick Hines"), new XElement("phone", "206-555-0144"),new XElement("address",new XElement("street1", "123 Main St"),new XElement("city", "Mercer Island"),new XElement("state", "WA"),new XElement("postal", "68042"))));

Posibilidad de emplear IEnumerable como parámetro en la creación de elementos.

Ejemplo

XElement contacts = new XElement("contacts", from p in persons select new XElement("contact", new XElement("name", p.Name), from ph in p.PhoneNumbers select new XElement("phone", ph) ) );

Obtener hijo/s de un elemento

Elemento.Elements(“Nombre”) ó Elemento.Elements(); Elemento.Content<XElement>();

Obtener el padre de un elemento

Elemento.Parent;

Añadir hijos a un nodo

Elemento.add(); Elemento.addAfterThis(ElementoHijo);

Actualizar elemento

Eliminar elementos

contact.Element("phone").Remove(); Elemento.removeContent() ;

CREACIÓN --> Parecida a la de los elementos.

Ejemplo

XElement contact =new XElement("contact",

new XElement("name", "Patrick Hines"),new XElement("phone",

new XAttribute("type", "home"),"206-555-0144"

),new XElement("phone",

new XAttribute("type", "work"),"425-555-0145"

));

Obtener el valor de un atributo

Elemento.attribute(“NombreAtributo”);

Eliminar atributos

Atributo. remove(); Elemento. setAttribute(null);

Operadores estándar -> lenguaje de consulta completo para los IEnumerable<T>.

La integración de Xlinq con el lenguaje integrado de consultas se basa en:

El impulso de los operadores estándar de consulta

El empleo de extensiones de consulta XML El empleo de transformaciones XML

from c in contacts.Elements("contact")where (string) c.Element("address").Element("state") == "WA"orderby (string) c.Element("name")select (string) c.Element("name");

from c in contacts.Elements("contact"), ph in c.Elements("phone")where (string) c.Element("address").Element("state") == "WA"

&& ph.Value.StartsWith("206")orderby (string) c.Element("name")select c;

Los lenguajes de programación modernos ofrecen el poder trabajar con los datos de forma ágil y rápida (Por ejemplo los objetos).

DLINQ

Proyecto LINQ

Bases de datos relacionales

Lenguajes de programación

modernos.

muchas diferencias

1. Traducción de las consultas en lenguaje integrado de consultas SQL para su ejecución en la base de datos.

2. Los datos recuperados de la consulta son traducidos a la forma de objetos para que sean manipulador por el programador

Adición de atributos personales a la definición corriente de las clases.

Ejemplo

[Table(Name="Customers")]public class Customer{

[Column(Id=true)]public string CustomerID;[Column]public string City;

}

Objeto empleado para la recuperación de las bases de datos. Su finalidad es convertir las peticiones de recuperación de información de las bases de datos, en objetos.

DataContext db = new DataContext("c:\\northwind\\northwnd.mdf");

Table<Customer> Customers = db.GetTable<Customer>();

var q =from c in Customerswhere c.City == "London"select c;

foreach (var cust in q)Console.WriteLine("id = {0}, City = {1}",

cust.CustomerID, cust.City);

public partial class Northwind : DataContext{

public Table<Customer> Customers;public Table<Order> Orders;public Northwind(string connection):

base(connection) {}}

 Northwind db = new Northwind("c:\\northwind\\northwnd.mdf");var q =

from c in db.Customerswhere c.City == "London"select c;

foreach (var cust in q)Console.WriteLine("id = {0}, City =

{1}",cust.CustomerID, cust.City);

No empleo de Joins para relacionar dos o más tablas.

Al tratar los datos como objetos -> empleo de los atributos.

Especificación en la creación de las clases mediante atributos personales.

Método fácil y simple de manipulación de los datos. (c.Orders y o.Customer)

[Table(Name="Customers")]public class Customer{

[Column(Id=true)]public string CustomerID;...private EntitySet<Order> _Orders;

[Association(Storage="_Orders",OtherKey="CustomerID")]

public EntitySet<Order> Orders {get { return this._Orders; }set { this._Orders.Assign(value); }

}}

[Table(Name="Orders")]public class Order{

[Column(Id=true)]public int OrderID;[Column]public string CustomerID;private EntityRef<Customer> _Customer; [Association(Storage="_Customer",

ThisKey="CustomerID")]public Customer Customer {

get { return this._Customer.Entity; }set { this._Customer.Entity = value; }

}}

Libre manipulación de los objetos por parte del programador.

A la hora de almacenar los datos, Dlinq automáticamente traducirá las nuevas modificaciones a la base de datos.

Para almacenar los cambios: ObjetoDataContext. SubmitChanges() ;

No tan extendido como Xlinq y Dlinq.

Manipulación de datos procedentes de una hoja de cálculo.

using(XlsWorkbook book = new XlsWorkbook("TestData\\100.xls")) { var sheets = from s in book.Worksheets

where s.Name == "100" select s;

foreach(var sheet in sheets) Console.WriteLine(sheet.Name);}

Mejora sobre la ya comentada tecnología Xlinq.

Proporciona esquemas los cuales son mapeados a modelos de objetos que permiten manejar la información disponible en xml como la programación orientada a objetos sin emplear etiquetas ni elementos XML

static double CalculateTotal(XElement batch) { XNamespace ns = "http://www.example.com/Orders"; return (from purchaseOrder in batch.Elements(ns + "PurchaseOrder") from item in purchaseOrder.Elements(ns + "Item") select (double)item.Element(ns + "Price")

* (int)item.Element(ns + "Quantity") ).Sum();}

using www.example.com.Orders; 

static double CalculateTotal(Batch batch) {

return (from purchaseOrder in

batch.PurchaseOrder from item in purchaseOrder.Item select item.Price * item.Quantity ).Sum();

}

Herramienta de la línea de comandos que genera el código y las asignaciones del componente LINQ to SQL de .NET Framework.

Acciones posibles

Desde una base de datos, generar código fuente y atributos de asignación (o un archivo de asignación).

Desde una base de datos, generar un archivo de lenguaje intermedio de marcado de base de datos (.dbml) para su personalización.

Desde un archivo .dbml, generar código y atributos de asignación (o un archivo de asignación).

Lenguaje general de SQLMETAL:sqlmetal [options] [<input file>]qlmetal [options] [<input file>]

Opciones Descripción

/server: <nombre> Especifica el nombre del servidor de base de datos.

/database: <nombre>

Especifica el catálogo de base de datos del servidor.

/user: <nombre> Especifica el identificador de usuario de inicio de sesión. El valor predeterminado es "Utilizar autenticación de Windows".

/password: <contraseña>

Especifica la contraseña de inicio de sesión. El valor predeterminado es "Utilizar autenticación de Windows".

/conn: <cadena de conexión>

Especifica la cadena de conexión a bases de datos. No se puede utilizar con las opciones /server, /database, /user o /password.

/timeout: <segundos>

Especifica el valor de tiempo de espera cuando SqlMetal tiene acceso a la base de datos. Valor predeterminado: 0 (es decir, sin límite de tiempo).

Opciones de conexión

Opciones de extracción

Opciones de resultados

Opciones Descripción

/views Extrae las vistas de base de datos.

/functions Extrae las funciones de base de datos.

/sprocs Extrae los procedimientos almacenados.

Opciones Descripción

/dbml [:archivo] Envía el resultado como .dbml. No se puede utilizar con la opción /map.

/code [:archivo] Envía el resultado como código fuente. No se puede utilizar con la opción /dbml.

/map [:archivo] Genera un archivo de asignación XML en lugar de atributos de asignación. No se puede utilizar con la opción /dbml.

oCrear un archivo .dbml que incluya los metadatos de SQL extraídos:sqlmetal /servidor:miservidor/basededatos:northwind

/dbml:mymeta.dbml

oGenerar un archivo .dbml que incluya los metadatos de SQL extraídos de un archivo .mdf mediante SQL Server Express:

sqlmetal /dbml:mismetadatos.dbml miarchivodb.mdf

oGenerar un archivo .dbml que incluya los metadatos de SQL extraídos de SQL Server Express:

sqlmetal /servidor:.\sqlexpress /dbml:mismetadatos.dbml /basededatos:northwind

oCrear el código fuente de un archivo de metadatos .dbml:sqlmetal /espaciodenombres:nwind /código:nwind.cs /lenguaje:csharp mimetal.dbml

oGenerar código fuente directamente a partir de los metadatos de SQL:sqlmetal /servidor:miservidor /basededatos:northwind

/espaciodenombres:nwind /código:nwind.cs /lenguaje:csharp

Más conocido como O/R DESIGNER

Proporciona una superficie de diseño visual para crear clases de entidad y asociaciones (relaciones) de Linq to SQL basadas en los objetos de una base de datos.

Es decir, se usa para crear un modelo de objetos en una aplicación que se asigna a los objetos de una base de datos -> VS2005.

También genera una clase Data Context que se usa para enviar y recibir datos entre las clases de entidad y la base de datos.

SqlMetal es una herramienta de la línea de comandos, puede utilizarse en un proceso de compilación, pero para el diseño necesitamos este tipo de herramientas.

Utilidad gratuita relacionada con LINQ equivalente a SQL Server Management Studio para bases de datos de datos SQL Server Express, pero orientada a LINQ To SQL.

Según la página de su creador, además de permitirnos definir y probar nuestras consultas LINQ contra BD's SQL Server, también podremos hacerlo contra objetos (LINQ To Objects) o archivos XML (LINQ To XML).

Además de servirnos como herramienta de pruebas para nuestras consultas LINQ, LINQPad viene con un montón de ejemplos precargados (más de 200)

Necesidad Framework 3.5

Es la mejor manera de integrar linq en VS2005. Además de las correspondientes plantillas de proyecto, se instalarán un montón de ejemplos tanto para VB como C#.

Funciona en Framerwork 2.0 que viene con VS2005

Demo Instalación

Parallel Language Integrated Query (PLINQ) ofrece una manera fácil de sacar partido del uso de hardware paralelo, incluidos equipos tradicionales con varios procesadores y la última ola de procesadores multinúcleo.

Aparece en respuesta al aumento de disponibilidad de plataformas con procesadores multinúcleo

  PLINQ es un motor de ejecución de consultas que

acepta cualquier consulta LINQ to Objects o LINQ to XML y usa automáticamente varios procesadores o núcleos para su ejecución cuando estos están disponibles.

El cambio en el modelo de programación es minúsculo, lo cual significa que no es necesario ser un gurú de la simultaneidad para poder usarlo.

Es una DSL (Domain Specific Languaje) que añade sintaxis de consultas tipo SQL en el desarrollo de aplicaciones Java basándose en el modelo del proyecto LINQ

Anders Noras es su creador y en su blog encontramos algo más de información aunque no mucha más. (www.andersnoras.com)

Quaere se distribuye bajo una licencia libre.

Aunque todavía no hay una versión totalmente estable, ya era funcional y era capaz de ejecutar todos los ejemplos que Microsoft usa para ilustrar su tecnología.

El proyecto ha sido aceptado por la fundación Codehaus, que también alberga otros proyectos como Groovy, JRuby, Jetty o OpenEJB, y se ha liberado una nueva versión del proyecto.

El parecido fundamental de linq y josql es que intentan embeber sintaxis SQL a la DSLs, aunque siendo rigurosos la verdad es que que lo hacen de maneras muy diferentes.

JoSQL utiliza APIs que parsean cadenas (Strings) que definen la consulta, mientras que en Linq las consultas están integradas a nivel lenguaje de modo que los operadores where, select, orderby, etc., son elementos sintácticos del mismo C# 3.0.

.NET Framework 3.5 :http://www.microsoft.com/downloads/details.aspx?

FamilyID=333325FD-AE52-4E35-B531-508D977D32A6&displaylang=en

LINQ PREVIEW :http://www.microsoft.com/downloads/details.aspx?

familyid=1e902c21-340c-4d13-9f04-70eb5e3dceea&displaylang=en

LINQPadhttp://www.linqpadupdates.net/LINQPad.exe

Presentación en SlideShare:http://www.slideshare.net/guest1c89ec/linq

Instalación y ejemplos con LINQPREVIEW