Métodos del Generador de consultas (Entity Framework)

Artículo
02/27/2011

La clase ObjectQuery admite las consultas LINQ to Entities y Entity SQL en un modelo conceptual. La clase ObjectQuery también implementa un conjunto de métodos del generador de consultas que se pueden usar para construir secuencialmente comandos de consulta equivalentes a Entity SQL . Estos son los métodos del generador de consultas de la clase ObjectQuery junto con las instrucciones de Entity SQL equivalentes:

Método de ObjectQuery	Instrucción de Entity SQL
Distinct	DISTINCT
Except	EXCEPT
GroupBy	GROUP BY
Intersect	INTERSECT
OfType	OFTYPE
OrderBy	ORDER BY
Select	SELECT
SelectValue	SELECT VALUE
Skip	SKIP
Top	TOP y LIMIT
Union	UNION
UnionAll	UNION ALL
Where	WHERE

Cada método del generador de consultas devuelve una nueva instancia de ObjectQuery. Esto le permite construir una consulta cuyo conjunto de resultados se basa en las operaciones de la secuencia de instancias de ObjectQuery anteriores. En el ejemplo siguiente se muestra cómo usar el método Where para filtrar los objetos Product devueltos por ProductID.

' Return Product objects with the specified ID. 
Dim query As ObjectQuery(Of Product) = context.Products.Where("it.ProductID = @product", New ObjectParameter("product", productId))

// Return Product objects with the specified ID.
ObjectQuery<Product> query =
    context.Products
    .Where("it.ProductID = @product",
    new ObjectParameter("product", productId));

Dado que ObjectQuery implementa IQueryable y IEnumerable, se pueden combinar los métodos del generador de consultas implementados por ObjectQuery con los métodos de operador de consultas estándar específicos de LINQ, como First o Count. A diferencia de los métodos del generador de consultas, los operadores de LINQ no devuelven una ObjectQuery. Para obtener más información, vea el tema Información general sobre operadores de consulta estándar en la documentación de Visual Studio 2008.

Seleccionar datos

De forma predeterminada, una ObjectQuery devuelve cero o más objetos entidad de un tipo específico. Llamar a métodos de consulta posteriores, como Where y OrderBy, afecta a la colección de objetos devuelta por la ObjectQuery original. Algunos métodos, como Select y GroupBy, devuelven una proyección de los datos como un DbDataRecord en lugar de un tipo de entidad. Para obtener más información, vea Consultas de objeto (Entity Framework). En el ejemplo siguiente se devuelve una colección de objetos DbDataRecord que contienen tipos de entidad SalesOrderHeader anidados.

' Define a query that returns a nested 
' DbDataRecord for the projection. 
Dim query As ObjectQuery(Of DbDataRecord) = context.Contacts.Select("it.FirstName, it.LastName, it.SalesOrderHeaders") _
                                            .Where("it.LastName = @ln", New ObjectParameter("ln", lastName))

// Define a query that returns a nested 
// DbDataRecord for the projection.
ObjectQuery<DbDataRecord> query =
    context.Contacts.Select("it.FirstName, "
        + "it.LastName, it.SalesOrderHeaders")
    .Where("it.LastName = @ln", new ObjectParameter("ln", lastName));

Aunque los métodos del generador de consultas se aplican secuencialmente, se puede construir el mismo tipo de subconsultas anidadas que las admitidas por Entity SQL . Para ello, debe incluir la subconsulta como subconsulta de Entity SQL en el método. En el ejemplo siguiente, se usa una subconsulta SELECT de Entity SQL dentro del método Select para incluir registros LastName; dichos registros aparecen anidados en un conjunto de resultados y ordenados alfabéticamente por la primera letra del apellido:

' Define the query with a GROUP BY clause that returns 
' a set of nested LastName records grouped by first letter. 
Dim query As ObjectQuery(Of DbDataRecord) = _
    context.Contacts.GroupBy("SUBSTRING(it.LastName, 1, 1) AS ln", "ln") _
    .Select("it.ln AS ln, (SELECT c1.LastName FROM AdventureWorksEntities.Contacts AS c1 " & _
            "WHERE SubString(c1.LastName, 1, 1) = it.ln) AS CONTACT").OrderBy("it.ln")

// Define the query with a GROUP BY clause that returns
// a set of nested LastName records grouped by first letter.
ObjectQuery<DbDataRecord> query =
    context.Contacts
    .GroupBy("SUBSTRING(it.LastName, 1, 1) AS ln", "ln")
    .Select("it.ln AS ln, (SELECT c1.LastName " +
    "FROM AdventureWorksEntities.Contacts AS c1 " +
    "WHERE SubString(c1.LastName, 1, 1) = it.ln) AS CONTACT")
    .OrderBy("it.ln");

Nota:
Use el método ToTraceString para ver el comando de origen de datos que se generará mediante una ObjectQuery.Para obtener más información, vea Consultas de objeto (Entity Framework).

Alias

Los métodos del generador de consultas se aplican secuencialmente para construir un comando de consulta acumulativo. Esto significa que el comando de ObjectQuery actual se trata como una subconsulta a la que se aplica el método actual.

Nota:
La propiedad CommandText devuelve el comando para la instancia de ObjectQuery.

En un método del generador de consultas, deberá hacer referencia al comando de ObjectQuery actual mediante un alias. De forma predeterminada, la cadena "it" es el alias que representa el comando actual, tal y como se muestra en el ejemplo siguiente:

' Return Product objects with a standard cost 
' above 10 dollars. 
Dim cost = 10
Dim productQuery As ObjectQuery(Of Product) = context.Products.Where("it.StandardCost > @cost")
productQuery.Parameters.Add(New ObjectParameter("cost", cost))

int cost = 10;
// Return Product objects with a standard cost
// above 10 dollars.
ObjectQuery<Product> productQuery =
    context.Products
    .Where("it.StandardCost > @cost", new ObjectParameter("cost", cost));

Cuando se establece la propiedad Name de una ObjectQuery, ese valor se convierte en el alias para los métodos posteriores. El ejemplo siguiente es una continuación del anterior; en él se establece el nombre de la ObjectQuery en "product" y, a continuación, se usa este alias en el método OrderBy posterior:

' Return Product objects with a standard cost 
' above 10 dollars. 
Dim cost = 10
Dim productQuery As ObjectQuery(Of Product) = context.Products.Where("it.StandardCost > @cost")
productQuery.Parameters.Add(New ObjectParameter("cost", cost))

' Set the Name property for the query and then 
' use that name as the alias in the subsequent 
' OrderBy method. 
productQuery.Name = "product"
Dim filteredProduct As ObjectQuery(Of Product) = productQuery.OrderBy("product.ProductID")

int cost = 10;
// Return Product objects with a standard cost
// above 10 dollars.
ObjectQuery<Product> productQuery =
    context.Products
    .Where("it.StandardCost > @cost", new ObjectParameter("cost", cost));

// Set the Name property for the query and then 
// use that name as the alias in the subsequent 
// OrderBy method.
productQuery.Name = "product";
ObjectQuery<Product> filteredProduct = productQuery
    .OrderBy("product.ProductID");

Parámetros

Todos los métodos del generador de consultas que toman una entrada de cadena de Entity SQL también admiten consultas con parámetros. Los nombres de los parámetros de Entity SQL se definen en expresiones de consulta con el símbolo (@) como prefijo. Para obtener más información, vea Parámetros (Entity SQL). Los parámetros se pasan a los métodos del generador de consultas como una matriz de instancias de ObjectParameter. En el siguiente ejemplo, se pasan dos parámetros al método Where:

' Get the contacts with the specified name. 
Dim contactQuery As ObjectQuery(Of Contact) = context.Contacts.Where("it.LastName = @ln AND it.FirstName = @fn", _
                                                 New ObjectParameter("ln", lastName), New ObjectParameter("fn", firstName))

// Get the contacts with the specified name.
ObjectQuery<Contact> contactQuery = context.Contacts
    .Where("it.LastName = @ln AND it.FirstName = @fn",
    new ObjectParameter("ln", lastName),
    new ObjectParameter("fn", firstName));

Consideraciones sobre el uso de los parámetros

Las consideraciones siguientes se aplican cuando se usan parámetros con los métodos del generador de consultas:

Los parámetros que se pasan a los métodos del generador de consultas se agregan mediante las instancias de ObjectQuery posteriores en la secuencia. Se puede obtener acceso directamente a ellos con la propiedad Parameters. Una vez agregados, los parámetros se pueden quitar de la colección y ésta, a su vez, se puede borrar, siempre y cuando no se haya compilado ni ejecutado la consulta. No se pueden cambiar los nombres de los parámetros, pero sí se pueden cambiar sus valores en cualquier momento.
Los parámetros deben ser únicos en la ObjectParameterCollection. No puede haber dos parámetros en la colección con el mismo nombre.
Cuando se usan métodos de composición, como Union, UnionAll, Intersect y Except, las colecciones de parámetros se combinan. Cuando los conjuntos de parámetros son incompatibles, incompletos, o cuando existe el mismo nombre en las colecciones de parámetros de ambas consultas, se inicia una excepción.

Vea también

Conceptos

Consultar un modelo conceptual (Entity Framework)
Cargar objetos relacionados (Entity Framework)