Méthodes du Générateur de requêtes (Entity Framework)

La classe ObjectQuery prend en charge les requêtes LINQ to Entities et Entity SQL sur un modèle conceptuel. La classe ObjectQuery implémente également un ensemble de méthodes du Générateur de requêtes qui peuvent être utilisées pour construire de manière séquentielle des commandes de requête équivalentes à des instructions Entity SQL . Les méthodes du Générateur de requêtes de la classe ObjectQuery sont répertoriées ci-dessous avec les instructions Entity SQL équivalentes :

Chaque méthode du Générateur de requêtes retourne une nouvelle instance de ObjectQuery. Cela vous permet de construire une requête dont le jeu de résultats repose sur les opérations de la séquence d'instances ObjectQuery précédentes. L'exemple ci-dessous montre comment utiliser la méthode Where pour filtrer les objets Product retournés par 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));

Dans la mesure où un objet ObjectQuery implémente IQueryable et IEnumerable, il est possible de combiner les méthodes du Générateur de requêtes implémentées par ObjectQuery avec les méthodes d'opérateur de requête standard LINQ, comme First ou Count. À la différence des méthodes du Générateur de requêtes, les opérateurs LINQ ne retournent pas d'objet ObjectQuery. Pour plus d'informations, voir la rubrique Vue d'ensemble des opérateurs de requête standard dans la documentation de Visual Studio 2008.

Sélection de données

Par défaut, un objet ObjectQuery retourne zéro, un ou plusieurs objets entité ou plus correspondant à un type spécifique. L'appel de méthodes de requête suivantes, comme Where et OrderBy, affecte la collection d'objets retournée par la classe ObjectQuery d'origine. Certaines méthodes, comme Select et GroupBy, retournent une projection des données sous la forme d'un objet DbDataRecord plutôt que sous la forme d'un type d'entité. Pour plus d'informations, voir Requêtes d'objet (Entity Framework). L'exemple suivant retourne une collection d'objets DbDataRecord qui contiennent des types d'entités SalesOrderHeader imbriqués.

' 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));

Bien que les méthodes du Générateur de requêtes soient appliquées de manière séquentielle, il est possible de construire le même type de sous-requêtes imbriquées prises en charge par Entity SQL . Pour ce faire, vous devez inclure la sous-requête en tant que Entity SQL dans la méthode. L'exemple suivant utilise une sous-requête Entity SQL SELECT dans la méthode Select pour inclure les enregistrements LastName, imbriqués dans un jeu de résultats et triés alphabétiquement sur la première lettre du nom :

' 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");

Remarque :
Utilisez la méthode ToTraceString pour afficher la commande de source de données qui sera générée par un objet ObjectQuery.Pour plus d'informations, voir Requêtes d'objet (Entity Framework).

Alias

Les méthodes du Générateur de requêtes sont appliquées de manière séquentielle pour construire une commande de requête cumulative. Cela signifie que la commande ObjectQuery actuelle est traitée comme une sous-requête à laquelle la méthode actuelle est appliquée.

Remarque :
La propriété CommandText retourne la commande de l'instance ObjectQuery.

Dans une méthode du Générateur de requêtes, vous faites référence à la commande ObjectQuery actuelle en utilisant un alias. Par défaut, la chaîne « it » est l'alias qui représente la commande actuelle, comme dans l'exemple suivant :

' 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));

Lorsque vous définissez la propriété Name d'un objet ObjectQuery, cette valeur devient l'alias dans les méthodes suivantes. L'exemple suivant développe le précédent en affectant le nom « product » à l'objet ObjectQuery, puis en utilisant cet alias dans la méthode OrderBy suivante :

' 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");

Paramètres

Toutes les méthodes du Générateur de requêtes qui acceptent une entrée de chaîne Entity SQL prennent également en charge les requêtes paramétrables. Dans Entity SQL , les noms des paramètres sont définis dans des expressions de requête avec le symbole at (@) comme préfixe. Pour plus d'informations, voir Paramètres (Entity SQL). Les paramètres sont passés aux méthodes du Générateur de requêtes sous la forme d'un tableau d'instances ObjectParameter. L'exemple suivant passe deux paramètres à la méthode 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));

Considérations relatives à l'utilisation de paramètres

Vous devez tenir compte des points suivants lors de l'utilisation de paramètres avec les méthodes du Générateur de requêtes :

• Les paramètres passés aux méthodes du Générateur de requêtes sont agrégés par les instances suivantes de ObjectQuery dans la séquence. Ils sont accessibles à l'aide de la propriété Parameters. Une fois ajoutés, les paramètres peuvent être supprimés de la collection et la collection peut être effacée, tant que la requête n'a pas été compilée ou exécutée. Les noms des paramètres ne peuvent pas être modifiés, mais leurs valeurs peuvent l'être à tout moment.

• Les paramètres doivent être uniques dans la collection ObjectParameterCollection. Une même collection ne peut pas contenir deux paramètres du même nom.

• En cas d'utilisation de méthodes de composition, telles que Union, UnionAll, Intersect et Except, les collections de paramètres sont fusionnées. Une exception est levée lorsque les jeux de paramètres sont incompatibles, incomplets, ou lorsque le même nom existe dans les collections de paramètres des deux requêtes.

Voir aussi

Concepts

Interrogation d'un modèle conceptuel (Entity Framework)
Chargement d'objets connexes (Entity Framework)