Utiliser LINQ pour créer une requête

  • Article

 

Date de publication : janvier 2017

S’applique à : Dynamics 365 (online), Dynamics 365 (on-premises), Dynamics CRM 2016, Dynamics CRM Online

Le fournisseur de requêtes Language-Integrated Query (LINQ) .NET dans Microsoft Dynamics 365 (Online et local) utilise une syntaxe LINQ standard. La première étape dans le cadre de la création d’une requête LINQ consiste à identifier les types d’entités pertinentes et les relations entre elles. Vous pouvez ensuite spécifier la source de données et les autres paramètres de requête.

La clause from est utilisée pour renvoyer une seule entité « racine ». Le fournisseur de requêtes ne peut renvoyer que des entités d’un seul type. Les clauses orderby et select doivent faire référence à cette entité racine. Vous pouvez utiliser les clauses join pour ajouter des entités avec une relation à l’entité « racine ».

Contenu de la rubrique

Opérateurs LINQ

Limitations LINQ

Filtrer plusieurs entités

Opérateurs LINQ

Toutes les expressions de requête LINQ ont un format similaire. Le tableau suivant indique les clauses les plus courantes dans une expression de requête LINQ lors de l’utilisation du fournisseur de requêtes LINQ Microsoft Dynamics 365.

Opérateur LINQ

Description

Exemple

Obtenir une source de données (la clause from)

En cas d’utilisation du contexte de service généré et de la liaison anticipée, utilisez le groupe d’entités IQueryable, tel que AccountSet, dans le contexte généré.

En l’absence d’utilisation du contexte généré, la méthode CreateQuery sur l’objet de contexte de service de l’organisation vous permet d’accéder aux entités Microsoft Dynamics 365.

Utilisation du contexte de service généré :

var query1 = from c in context.ContactSet
select c;

Utilisation de la méthode CreateQuery :

var query1 = from c in context.CreateQuery<Contact>()
select c;

clause join

La clause join représente une jointure interne. Vous utilisez la clause pour travailler avec deux, voire plusieurs entités qui peuvent être jointes avec une valeur d’attribut courante.

 
from c in context.ContactSet
join a in context.AccountSet on c.ContactId equals a.PrimaryContactId.Id

Filtrage (la clause where)

La clause where applique un filtre aux résultats, souvent à l’aide d’une expression booléenne. Le filtre spécifie les éléments à exclure de la séquence source. Chaque clause where ne peut contenir que des conditions par rapport à un seul type d’entité. Une condition composite impliquant plusieurs entités n’est pas valide. En revanche, chaque entité doit être filtrée dans des clauses distinctes where.

 
from a in context.AccountSet
where (a.Name.StartsWith("Contoso") && a.Address1_StateOrProvince == "WA")

orderby

L’opérateur orderby place les attributs de la requête renvoyée dans un ordre spécifique.

 
var query1 = from c in context.CreateQuery<Contact>()   
    orderby c.FullName ascending   
    select c;
foreach ( var q in query1)   
{
    Console.WriteLine(q.FirstName + " " + q.LastName);   
}

Clause select

La clause select définit la forme des données renvoyées. La clause crée un groupe de colonnes basé sur les résultats de l’expression de requête. Vous pouvez également définir une instance d’un nouvel objet avec lequel travailler. L’objet créé à l’aide de la clause select n’est pas créé sur le serveur, mais est une instance locale.

 
select new Contact   
{
    ContactId = c.ContactId,
    FirstName = c.FirstName,
    LastName = c.LastName,
    Address1_Telephone1 = c.Address1_Telephone1   
};

Limitations LINQ

Le fournisseur de requêtes LINQ prend en charge un sous-ensemble des opérateurs LINQ. Les conditions pouvant être exprimées dans LINQ ne sont pas toutes prises en charge. Le tableau suivant indique certaines des limites des opérateurs LINQ de base.

Opérateur LINQ

Limitations

join

Représente une jointure interne ou externe. Seuls les jointures externes de gauche sont prises en charge.

from

Prend en charge une clause from par requête.

where

À gauche de la clause doit figurer un nom d’attribut et à sa droite doit figurer une valeur. Vous ne pouvez pas définir une constante à gauche. Les deux parties de la clause ne peuvent pas être des constantes.

Prend en charge les fonctions StringContains, StartsWith, EndsWithet Equals.

groupBy

Non pris en charge. FetchXML prend en charge les options de regroupement qui ne sont pas disponibles avec le fournisseur de requêtes LINQ.Pour plus d'informations : Utiliser l’agrégation FetchXML

orderBy

Prend en charge le tri par attribut d’entité, tel que Contact.FullName.

select

Prend en charge les types, constructeurs et initialiseurs anonymes.

last

L’opérateur last n’est pas pris en charge.

skip et take

Prend en charge skip et take à l’aide de la pagination côté serveur. La valeur skip doit être supérieure ou égale à la valeur take.

aggregate

Non pris en charge. FetchXML prend en charge les options d’agrégation qui ne sont pas disponibles avec le fournisseur de requêtes LINQ.Pour plus d'informations : Utiliser l’agrégation FetchXML

Filtrer plusieurs entités

Vous pouvez créer des requêtes Language-Integrated Query (LINQ) .NET complexes dans Microsoft Dynamics 365 et Microsoft Dynamics 365 (Online). Vous utilisez plusieurs clauses Join avec des clauses de filtre pour créer un résultat qui est filtré sur les attributs à partir de plusieurs entités.

L’exemple suivant indique comment créer une requête LINQ qui fonctionne avec deux entités et qui filtre le résultat basé sur des valeurs issues de chacune des entités.


using (ServiceContext svcContext = new ServiceContext(_serviceProxy))
{
 var query_where3 = from c in svcContext.ContactSet
                    join a in svcContext.AccountSet
                    on c.ContactId equals a.PrimaryContactId.Id
                    where a.Name.Contains("Contoso")
                    where c.LastName.Contains("Smith")
                    select new
                    {
                     account_name = a.Name,
                     contact_name = c.LastName
                    };

 foreach (var c in query_where3)
 {
  System.Console.WriteLine("acct: " +
   c.account_name +
   "\t\t\t" +
   "contact: " +
   c.contact_name);
 }
}


Using svcContext As New ServiceContext(_serviceProxy)
 Dim query_where3 = From c In svcContext.ContactSet _
                    Join a In svcContext.AccountSet _
                    On c.ContactId Equals a.account_primary_contact.Id _
                    Where a.Name.Contains("Contoso") _
                    Where c.LastName.Contains("Smith") _
                    Select New With {Key .account_name = a.Name,
                                     Key .contact_name = c.LastName}

 For Each c In query_where3
  Console.WriteLine("acct: " &amp; c.account_name &amp; vbTab &amp; vbTab _
                    &amp; vbTab &amp; "contact: " &amp; c.contact_name)
 Next c
End Using

Voir aussi

Exemple : Créer une requête LINQ
Exemple : Requêtes LINQ complexes
Générer des requêtes avec LINQ (Language-Integrated Query .NET)
Utiliser la classe d’entités de liaison tardive avec une requête LINQ
Blog : lecteur de LINQPad 4 pour l'API de Dynamics CRM REST/Web disponible sur CodePlex

Microsoft Dynamics 365

© 2017 Microsoft. Tous droits réservés. Copyright