linq to entities
TRANSCRIPT
“Año de la Inversión para el Desarrollo Rural y la Seguridad Alimentaria”
Facultad de Ingeniería
Escuela Académica Profesional de Ingeniería de Sistemas y Computación
UPLAUniversidad Peruana Los Andes
UNIDAD DE EJECUCIÓN CURRICULAR:
DESARROLLO DE SISTEMAS I
DOCENTE:
VEGA FLORES, JORGE ALBERTO
ALUMNO:
CAIRAMPOMA ARTETA, RENZO LUIS
HUANCAYO- PERU
LINQ TO ENTITIES
2013
INDICE
DEDICATORIA...............................................................................................................................1
INTRODUCCION............................................................................................................................2
1. LINQ TO ENTITIES...........................................................................................................3
2. ¿QUÉ ES LINQ TO ENTITIES?......................................................................................4
3. ORM-MAPEO OBJETO-RELACIONAL........................................................................4
4. ENTITY FRAMEWORK....................................................................................................5
5. COMPARANDO LINQ PARA SQL CON LINQ A ENTIDADES................................6
6. LAS CONSULTAS DE LINQ TO ENTITIES..................................................................7
6.1. CONVERSIÓN DE LAS CONSULTAS..................................................................8
7. SINTAXIS DE CONSULTA..............................................................................................9
7.1. LOS OPERADORES DE CONSULTA ESTÁNDAR DE LINQ TO ENTITIES CONSULTAS.........................................................................................................................9
7.2. LOS OPERADORES DE CONSULTA ESTÁNDAR DE LINQ TO ENTITIES CONSULTAS.......................................................................................................................11
Proyección y filtrado Métodos....................................................................................11
Únete Métodos.............................................................................................................11
Establecer métodos.....................................................................................................12
Métodos Orden............................................................................................................12
Métodos de agrupamiento..........................................................................................13
Métodos de agregación..............................................................................................13
Métodos de Tipo..........................................................................................................15
Métodos de paginación...............................................................................................15
8. LAMBDA...........................................................................................................................16
8.1. DECLARACIÓN......................................................................................................17
8.2. EJEMPLOS DE FUNCIONES LAMBDA.............................................................17
WEBGRAFÍA:...........................................................................................................................18
DEDICATORIA
Les dedico este trabajo a mis padres
porque siempre me brindan su apoyo
incondicional en mi plan de ser profesional.
1
INTRODUCCION
Actualmente, la mayor parte de las aplicaciones empresariales se escriben
para tener acceso a datos de bases de datos relacionales. En algún momento,
estas aplicaciones tienen que interactuar con los datos representados en un
formato relacional. El modelo relacional está optimizado para conseguir un
almacenamiento y recuperación eficientes, no para el modelado conceptual que
se usa en la programación orientada a objetos. Varias tablas normalizadas
suelen corresponder a una sola clase, y las relaciones entre las clases no se
representan del mismo modo que las relaciones entre tablas.
2
1. LINQ TO ENTITIES
Entity Framework permite a los programadores trabajar con datos en forma de
objetos y propiedades específicos del dominio, por ejemplo, con clientes y
direcciones, sin tener que pensar en las tablas de las bases de datos
subyacentes y en las columnas en las que se almacenan estos datos. A través
de la infraestructura de Servicios de objeto de Entity Framework, ADO.NET
expone una vista conceptual común de los datos, incluidos los datos
relacionales, como objetos del entorno .NET. Esto hace que la capa de objetos
sea un objetivo ideal para la compatibilidad con LINQ. Esta tecnología LINQ,
LINQ to Entities, permite a los programadores crear consultas flexibles, pero
con establecimiento inflexible de tipos, en el contexto del objeto de Entity
Framework mediante el uso de expresiones y de operadores de consulta
estándar de LINQ directamente desde el entorno de desarrollo (Véase Figura
1.0).
Figura 1.0: Arquitectura de Linq to Entities
3
2. ¿QUÉ ES LINQ TO ENTITIES?
LINQ to Entities es una nueva característica de acceso a datos que está
basado en ADO.NET Entity Framework.
LINQ to Entities proporciona la capacidad de realizar consultas integradas
en lenguajes (LINQ) que permite a los desarrolladores de software escribir
consultas contra el modelo conceptual de Entity Framework mediante
Visual Basic o Visual C#. Las consultas con Entity Framework se
representan mediante consultas de árboles de comandos, que se ejecutan
en el contexto del objeto. LINQ to Entities convierte las consultas de
Language-Integrated Queries (LINQ) en consultas de árboles de
comandos, ejecuta las consultas en Entity Framework y devuelve objetos
que se pueden usar tanto en Entity Framework como en LINQ.1
3. ORM-MAPEO OBJETO-RELACIONAL
ORM es sinónimo de mapeo objeto-relacional. A veces se llama O / RM o
mapeo O / R. Se trata de una técnica de programación que contiene un
conjunto de clases que asignan bases de datos relacionales entidades a
objetos en un lenguaje de programación específico.
Cada base de datos está representada por un objeto de contexto de ORM
en el lenguaje de programación específico, y base de datos de las
entidades tales como tablas están representadas por las clases, con las
relaciones entre estas clases. Por ejemplo, el ORM puede crear
una Alumno de clase para representar la tabla Alumno y
una matricula clase para representar la tabla matricula. El ORM es
responsable de las asignaciones y las conexiones entre estas clases y la
base de datos. Así que, para la aplicación, la base de datos ya está
totalmente representada por estas clases. La aplicación sólo tiene que
hacer frente a estas clases, en lugar de con la base de datos física. La
aplicación no tiene que preocuparse acerca de cómo conectarse a la base
de datos, la forma de construir las sentencias SQL, cómo utilizar el
mecanismo de bloqueo adecuado para garantizar la concurrencia, o cómo
1 http://msdn.microsoft.com/es-es/library/bb386964(v=vs.90).aspx
4
manejar las transacciones distribuidas. Estas actividades de base de datos
relacionados son manejadas por el ORM.
4. ENTITY FRAMEWORK
ADO.NET Entity Framework (EF) es una nueva adición a la familia de
Microsoft ADO.NET. Permite crear aplicaciones de acceso a datos
mediante programación en contra de un modelo de aplicación conceptual
en lugar de programar directamente en un esquema de almacenamiento
relacional. El objetivo es disminuir la cantidad de código y el mantenimiento
requerido para aplicaciones orientadas a datos. Aplicaciones de Entity
Framework proporciona las siguientes ventajas:
Las aplicaciones pueden trabajar en términos de un modelo
conceptual más centrado en las aplicaciones, incluyendo tipos con
herencia, miembros complejos y las relaciones.
Las solicitudes se liberan de las dependencias incluidas en el código
en un motor de datos en particular o un esquema de almacenamiento.
Correlaciones entre el modelo conceptual y el esquema de
almacenamiento específicas pueden cambiar sin cambiar el código de
la aplicación.
Los desarrolladores pueden trabajar con un modelo de objetos de
aplicación coherente que se puede asignar a diferentes esquemas de
almacenamiento, posiblemente ejecutados en diferentes sistemas de
gestión de bases de datos.
Varios modelos conceptuales se pueden asignar a un solo esquema
de almacenamiento.
Integrada Idioma Query (LINQ apoyo) proporciona la validación de
sintaxis en tiempo de compilación Query en un modelo conceptual
(Véase Figura 3.0).
5
Figura 3.0: Linq to Entities2
5. COMPARANDO LINQ PARA SQL CON LINQ A ENTIDADES
Características LINQ para SQL LINQ a Entidades
Modelo conceptual de datos No Sí
Esquema de almacenamiento No Sí
Esquema de asignación No Sí
Nuevo proveedor de acceso a datos
No Sí
Soporte de base de datos no SQL Server
No Sí
Conexión directa de base de datos
Sí No
Extensiones de lenguaje apoyan
Sí Sí
Procedimientos almacenados Sí Sí
Herencia de tabla única Sí Sí
2 http://www.codeproject.com/Articles/246861/LINQ-to-Entities-Basic-Concepts-and-Features
6
Características LINQ para SQL LINQ a Entidades
Herencia múltiple de mesa No Sí
Entidad única de varias tablas No Sí
Lazy Loading Support Sí Sí
6. LAS CONSULTAS DE LINQ TO ENTITIES
Una consulta es una expresión que recupera datos de un origen de datos. Las
consultas se suelen expresar en un lenguaje de consulta especializado, como
SQL para bases de datos relacionales y XQuery para XML. Por lo tanto, los
programadores han tenido que aprender un lenguaje de consultas nuevo para
cada tipo de origen de datos o formato de datos que consultan. Language-
Integrated Query (LINQ) ofrece un modelo coherente y más sencillo para
trabajar con los datos de varios formatos y orígenes de datos. En una consulta
de LINQ siempre se trabaja con objetos de programación.
Una operación de consulta de LINQ consta de tres acciones: obtener el origen
o los orígenes de datos, crear la consulta y ejecutar la consulta.
Los orígenes de datos que implementan las interfaces
genéricas IEnumerable<T> o IQueryable<T> pueden consultarse a través de
LINQ. Las instancias de la clase genérica ObjectQuery<T>, que implementa la
interfaz genérica IQueryable<T>, actúan como origen de datos para las
consultas LINQ to Entities. La clase ObjectQuery<T> genérica representa una
consulta que devuelve una colección de cero o más objetos con tipo. También
puede hacer que el compilador deduzca el tipo de una entidad utilizando la
palabra clave var de C# (Dim en Visual Basic).
En la consulta se especifica exactamente la información que se desea
recuperar del origen de datos. Una consulta también puede especificar cómo
se debe ordenar, agrupar y conformar esa información antes de que se
devuelva. En LINQ, una consulta se almacena en una variable. Si la consulta
devuelve una secuencia de valores, la propia variable de la consulta debe ser
de un tipo que se pueda consultar. Esta variable de consulta no realiza ninguna
7
acción y no devuelve datos; solamente almacena la información de la
consulta. Tras crear una consulta debe ejecutarla para recuperar los datos.
6.1.CONVERSIÓN DE LAS CONSULTAS
Para ejecutar una consulta de LINQ to Entities en Entity Framework, se
debe convertir a una representación de árbol de comandos que se pueda
ejecutar en Entity Framework.
Las consultas de LINQ to Entities están compuestas de operadores de
consulta estándar de LINQ (como Select, Where y GroupBy) y
expresiones (x > 10, Contact.LastName, etcétera). Los operadores de
LINQ no se definen en una clase, sino que son los métodos de una
clase. En LINQ, las expresiones pueden contener todo lo que permitan los
tipos dentro del espacio de nombres System.Linq.Expressions y, por
extensión, todo lo que se pueda representar en una función lambda. Se
trata de un superconjunto de las expresiones permitidas por Entity
Framework, que, por definición, están restringidas a las operaciones
admitidas tanto en la base de datos como por ObjectQuery<T>.
En Entity Framework, tanto los operadores como las expresiones se
representan mediante una jerarquía de tipos simple, que después se
coloca en un árbol de comandos. Entity Framework usa el árbol de
comandos para ejecutar la consulta. Si la consulta de LINQ no se puede
expresar como un árbol de comandos, se producirá una excepción
cuando se convierta la consulta. La conversión de las consultas de LINQ
to Entities implica dos conversiones más: la de los operadores de consulta
estándar y la de las expresiones.
Hay varios operadores de consulta estándar de LINQ que no tienen una
conversión válida en LINQ to Entities. Si se intenta usar estos operadores,
se producirá una excepción al convertir la consulta. Para obtener una lista
de los operadores de LINQ to Entities admitidos, vea Métodos admitidos y
no admitidos de LINQ (LINQ to Entities).
8
Para obtener más información sobre cómo usar los operadores de consulta
estándar en LINQ to Entities, vea Operadores de consulta estándar en las
consultas de LINQ to Entities.
En general, las expresiones de LINQ to Entities se evalúan en el servidor, de
modo que es previsible que el comportamiento de la expresión no siga la
semántica de CLR. Para obtener más información, vea Expresiones en
consultas de LINQ to Entities.
Para obtener información sobre cómo las llamadas a métodos de CLR se
asignan a funciones canónicas del origen de datos, vea Asignar método CLR a
función canónica.
Para obtener información sobre cómo llamar a funciones canónicas, de base de
datos y personalizadas desde consultas de LINQ to Entities, vea Llamar a
funciones en consultas de LINQ to Entities.
7. SINTAXIS DE CONSULTA
LINQ to Entities puede estar compuesta de dos sintaxis diferentes: sintaxis
de expresiones de consulta y sintaxis de consultas basadas en
métodos. Sintaxis de expresiones de consulta es nueva en C # 3.0 y Visual
7.1.LOS OPERADORES DE CONSULTA ESTÁNDAR DE LINQ TO ENTITIES CONSULTAS
En una consulta, debe especificar la información que desea recuperar del
origen de datos. Una consulta también puede especificar cómo se debe
ordenar que la información, agrupados y en forma antes de ser
devuelta. LINQ proporciona un conjunto de métodos de consulta estándar
que se puede utilizar en una consulta. La mayoría de estos métodos
funciona en secuencias, en este contexto, una secuencia es un objeto cuyo
tipo implementa la interfaz IEnumerable o la interfaz IQueryable interfaz. La
funcionalidad de consulta de los operadores de consulta estándar incluye el
9
filtrado, proyección, agregación, clasificación, agrupación, paginación,
etc. Algunos de los operadores de consulta estándar que se utilizan con
más frecuencia han dedicado sintaxis de palabras clave para que puedan
ser convocadas por el uso de la sintaxis de expresiones de consulta. Una
expresión de consulta es una forma diferente, más legible para expresar
una consulta que el equivalente basado en el método. Cláusulas de
expresiones de consulta se traducen en llamadas a los métodos de
consulta en tiempo de compilación. Para obtener una lista de los
operadores de consulta estándar que tienen cláusulas de expresiones de
consulta equivalentes, consulte operadores de consulta estándar . 3
No todos los operadores de consulta estándar son compatibles con LINQ to
Entities. Para obtener más información, consulte Métodos de LINQ
admitidos y no admitidos (LINQ to Entities) . Este tema proporciona
información acerca de los operadores de consulta estándar que es
específico de LINQ to Entities.Para obtener más información acerca de los
problemas conocidos en LINQ to Entities, vea
MÉTODOS DE COMBINACIÓN
La combinación es una operación importante de las consultas
dirigidas a orígenes de datos que no tienen relaciones navegables
entre sí. Una combinación de dos orígenes de datos es la asociación
de objetos en un origen de datos con objetos de otro origen de datos
que comparten un atributo o propiedad comunes. Los métodos de
combinación son Join y GroupJoin.
MÉTODOS DE AGRUPAMIENTO
El agrupamiento hace referencia a la operación de colocar los datos
en grupos de manera que los elementos de cada grupo compartan
un atributo común. El método de agrupamiento es GroupBy.
3 http://msdn.microsoft.com/es-es/library/bb399414(v=vs.90).aspx
10
7.2.LOS OPERADORES DE CONSULTA ESTÁNDAR DE LINQ TO ENTITIES CONSULTAS
Proyección y filtrado Métodos
Proyección refiere a la transformación de los elementos de un conjunto
de resultados en una forma deseada. Por ejemplo, se puede proyectar
un subconjunto de las propiedades que necesita de cada objeto en el
conjunto de resultados, se puede proyectar una propiedad y realizar un
cálculo matemático en él, o que se pueda proyectar todo el objeto del
conjunto de resultados. Los métodos de proyección
son Select y SelectMany .
El filtrado se refiere a la operación de restringir el conjunto de resultados
para contener sólo aquellos elementos que coinciden con una condición
especificada. El método de filtrado es dónde .
La mayoría de las sobrecargas de los métodos de proyección y filtrado
se admiten en LINQ to Entities, con la excepción de los que aceptan un
argumento posicional.
Únete Métodos
Unirse es una operación importante en las consultas a orígenes de datos
que no tienen relaciones navegables entre sí. Una combinación de dos
fuentes de datos es la asociación de los objetos en una fuente de datos
con objetos en el otro origen de datos que comparten un atributo o
propiedad común. Los métodos de combinación
son Únete y GroupJoin .
La mayoría de las sobrecargas de los métodos de combinación son
compatibles, con la excepción de los que utilizan
un IEqualityComparer . Esto es debido a que el comparador no se puede
convertir en el origen de datos.
11
Establecer métodos
Establecer operaciones en LINQ son operaciones de consulta que basan
su resultado conjuntos en la presencia o ausencia de elementos
equivalentes dentro de la misma o en otra colección (o conjunto). Los
métodos de ajuste son todo
, Cualquier , Concat , Contiene , DefaultIfEmpty,Distinct , EqualAll,
Salvo , Intersección y unión .
La mayoría de las sobrecargas de los métodos set se admiten en LINQ
to Entities, aunque hay algunas diferencias de comportamiento en
comparación con LINQ to Objects. Sin embargo, los métodos que
utilizan un conjunto IEqualityComparer no son compatibles debido a que
el comparador no se puede convertir en el origen de datos.
Métodos Orden
Orden, o clasificación, se refiere a la ordenación de los elementos de un
conjunto de resultados sobre la base de uno o más atributos. Si
especifica más de un criterio de clasificación, puede romper los lazos
dentro de un grupo.
La mayoría de las sobrecargas de los métodos de ordenación son
compatibles, con la excepción de los que utilizan un IComparer . Esto es
debido a que el comparador no se puede convertir en el origen de datos.
Los métodos de
ordenaciónson OrderBy , OrderByDescending , ThenBy , ThenByDes
cending yReverse .
Debido a que la consulta se ejecuta en el origen de datos, el
comportamiento de pedido puede diferir de las consultas ejecutadas en
el CLR. Esto se debe a opciones de pedido, como el caso ordenamiento,
kanji pedido, y nulo el pedido, se puede configurar en el origen de
datos. Dependiendo de la fuente de datos, estas opciones de ordenación
pueden producir resultados diferentes en el CLR.
12
Si especifica el mismo selector de llave en más de una operación de
ordenación, se producirá un ordenamiento duplicado. Esto no es válido y
una excepción será lanzada.
Métodos de agrupamiento
Agrupación se refiere a la colocación de datos en grupos de manera
que los elementos en cada grupo comparten un atributo común. El
método de agrupamiento es GroupBy .
La mayoría de las sobrecargas de los métodos de agrupamiento son
compatibles, con la excepción de los que utilizan
un IEqualityComparer . Esto es debido a que el comparador no se puede
convertir en el origen de datos.
Los métodos de agrupamiento se asignan a la fuente de datos
utilizando una clara sub-consulta para el selector de llave. La
comparación selector de llav
sub-consulta se ejecuta utilizando la semántica de la fuente de datos,
incluidas las cuestiones relacionadas con la comparación nulos valores.
Métodos de agregación
Una operación de agregación calcula un único valor a partir de una
colección de valores. Por ejemplo, el cálculo de la temperatura media
diaria del valor de un mes de los valores diarios de temperatura es una
operación de agregación. Los métodos de agregación
son agregados , Promedio , Cuenta ,LongCount , Max , Min y Sum .
La mayoría de las sobrecargas de los métodos de agregación son
compatibles. Para el comportamiento relacionado con valores nulos, los
métodos de agregación utilizan la semántica de fuente de datos. El
comportamiento de los métodos de agregación cuando están en juego
valores nulos puede ser diferente, dependiendo de que se está utilizando
fuentes de datos de back-end. Comportamiento de agregación utilizando
13
la semántica del origen de datos también puede ser diferente de lo que
se espera de los métodos de CLR. Por ejemplo, el comportamiento
predeterminado de la Suma método en SQL Server es ignorar los
valores nulos en lugar de lanzar una excepción.
Las excepciones que resultan de la agregación, como un
desbordamiento de la Suma función, se lanzan como excepciones de
orígenes de datos o excepciones Entity Framework durante la
materialización de los resultados de la consulta.
Para aquellos métodos que implican un cálculo más de una secuencia,
tales como suma o media , el cálculo real se realiza en el
servidor. Como resultado, conversiones de tipos y la pérdida de
precisión se pueden producir en el servidor, y los resultados pueden
diferir de lo que se espera el uso de la semántica de CLR.
El comportamiento predeterminado de los métodos de agregación para
valores nulos / no nulo se muestra en la siguiente tabla:
MétodoNo hay datos
Todos los valores nulos
Algunos valores nulos
No hay valores nulos
Promedio
Devuelve nulo.
Devuelve nulo. Devuelve el promedio de los valores no nulos en una secuencia.
Calcula el promedio de una secuencia de valores numéricos.
Contar Devuelve 0
Devuelve el número de valores nulos en la secuencia.
Devuelve el número de valores nulos y no nulo en la secuencia.
Devuelve el número de elementos de la secuencia.
14
Max Devuelve nulo.
Devuelve nulo. Devuelve el valor máximo no nulo en una secuencia.
Devuelve el valor máximo de una secuencia.
Min Devuelve nulo.
Devuelve nulo. Devuelve el valor no nulo mínimo de una secuencia.
Devuelve el valor mínimo de una secuencia.
Suma Devuelve nulo.
Devuelve nulo. Devuelve la suma de los valores no nulos en una secuencia.
Calcula la suma de una secuencia de valores numéricos.
Métodos de Tipo
Los dos métodos de LINQ que tienen que ver con la conversión de tipo y
pruebas es ambos apoyados en el contexto de Entity Framework. Esto
significa que los únicos tipos admitidos son los tipos que se asignan al
tipo Entity Framework correspondiente. Para obtener una lista de este
tipo, vea Tipos del Entity Data Model . Los métodos del tipo
están Convertir y OFTYPE .
OfType es compatible con los tipos de entidad. Convert es apoyado por
modelos conceptuales tipos primitivos. El C # es y como también se
apoyan métodos.
Métodos de paginación
Operaciones de paginación devuelven un único elemento específico de
una secuencia. Los métodos de elementos
son ElementAt , Primera , FirstOrDefault, pasado , LastOrDefault , in
dividual , Saltar , Tome , TakeWhile .
No se admiten Un número de los métodos de paginación, ya sea debido
a la incapacidad para asignar funciones a la fuente de datos o a la falta
15
de implícita ordenamiento de conjuntos en la fuente de datos. Los
métodos que devuelven un valor por defecto se limitan a modelos
conceptuales tipos primitivos y tipos de referencia con valores
predeterminados nulos. Métodos de paginación que se ejecutan en una
secuencia vacía devolverá null.
8. LAMBDA
Una expresión lambda es una función o una subrutina sin nombre que se
puede utilizar donde haya un delegado válido. Las expresiones lambda se
usan en consultas de LINQ basadas en métodos como argumentos de los
métodos de operador de consulta estándar, tales como Where. Son
ampliamente usadas en el ORM de Microsoft, Entity Framework, donde se
puede ver claramente todo su potencial.
Lambda son funciones, es decir, un conjunto de instrucciones capaces de
retornar un valor partiendo de los parámetros que se les suministra, aunque
en determinados casos es posible que no reciba ningún parámetro, o que
realicen una acción sin retornar nada. Igual que una función tradicional. Y
de hecho, en el cuerpo de una expresión lambda puede haber casi de todo:
llamadas a otras funciones, expresiones, bucles, declaraciones de
variables. Sin embargo, a diferencia de los métodos o funciones habituales,
las lambdas no necesitan de un identificador, puesto que se declaran justo
en el momento en que van a asignarse a una variable o a utilizarse como
parámetro de una función, pasando el destinatario de esta asignación a
actuar como delegado, o puntero, hacia la misma, o a ser el contenedor del
árbol de expresión que la representa.
16
8.1.DECLARACIÓN
Una expresión lambda se declara mediante la siguiente sintaxis:
8.2.EJEMPLOS DE FUNCIONES LAMBDA
17
param => expr
- param será la lista de parámetros separados por comas
- => es la separación entre los parámetros y la declaración de la función
- expr es la implementación de la función
num => num * 2 // Lambda con un parámetro que retorna // el doble del valor que se le pasa.
(a, b) => a + b // Lambda con dos parámetros que retorna // la suma de ambos.
n => n / 10 . // Función que divide un número entre 10
(x,y) => x / y. //Función que divide dos números
N => { N = n*2; return n;}. // Función que multiplica un número por dos
num => { // Lambda con cuerpo que recibe un int x = new Random().Next(); // entero, y retorna la suma de éste return num+x; // con un número aleatorio.
} () => DateTime.Now // Lambda que no recibe parámetros // y retorna la fecha y hora del sistema.
msg => Console.WriteLine(msg); // Recibe un parámetro, realiza una // acción y no retorna nada.
El tipo de retorno es inferido por el contexto. También destacar que si se
realizan varias operaciones es necesario utilizar return. Los paréntesis sólo
son obligatorios cuando hay más de un parámetro.
WEBGRAFÍA:
LINQ to Entities. 2013 Microsoft. http://msdn.microsoft.com/en-us/library/bb386964.aspx
Operadores de consulta estándar en las consultas de LINQ to Entities. 2013 Microsoft.http://msdn.microsoft.com/es-es/library/bb738551.aspx
18