Chargement de contenu différé (WCF Data Services)

Article
02/27/2011

Par défaut, Services de données WCF limite la quantité de données retournées par une requête. Toutefois, vous pouvez charger explicitement des données supplémentaires, notamment les entités connexes, les données de réponse paginées et les flux de données binaires, à partir du service de données si nécessaire. Cette rubrique décrit comment charger un contenu différé dans votre application.

Entités connexes

Lorsque vous exécutez une requête, seules les entités dans le jeu d'entités adressées sont retournées. Par exemple, lorsqu'une requête exécutée sur le service de données Northwind retourne les entités Customers, par défaut, les entités Orders connexes ne sont pas retournées, même s'il existe une relation entre Customers et Orders. De plus, lorsque la pagination est autorisée dans le service de données, vous devez charger explicitement les pages de données suivantes à partir du service. Il y a deux façons de charger des entités connexes :

Le chargement hâtif : vous pouvez utiliser l'option de requête $expand pour demander que la requête retourne des entités associées par une association au jeu d'entités demandé par la requête. Utilisez la méthode Expand sur le DataServiceQuery pour ajouter l'option $expand à la requête envoyée au service de données. Vous pouvez demander plusieurs jeux d'entités connexes en les séparant par une virgule, comme dans l'exemple suivant. Toutes les entités demandées par la requête sont retournées dans une réponse unique. L'exemple de code suivant retourne Order_Details et Customers ainsi que le jeu d'entités Orders :
```
' Define a query for orders that also returns items and customers.
Dim query As DataServiceQuery(Of Order) = _
context.Orders.Expand("Order_Details,Customer")
```
```
// Define a query for orders that also returns items and customers.
DataServiceQuery<Order> query =
    context.Orders.Expand("Order_Details,Customer");
```
Services de données WCF limite à 12 le nombre de jeux d'entités pouvant être inclus dans une requête unique à l'aide de l'option de requête $expand.
Le chargement explicite : vous pouvez appeler la méthode LoadProperty sur l'instance DataServiceContext pour charger explicitement des entités connexes. Chaque appel à la méthode LoadProperty crée une demande séparée au service de données. L'exemple suivant charge explicitement Order_Details pour une entité Orders :
```
' Explicitly load the order details for each order.
context.LoadProperty(order, "Order_Details")
```
```
// Explicitly load the order details for each order.
context.LoadProperty(order, "Order_Details");
```

Au moment de choisir l'option à utiliser, sachez qu'il y a une corrélation entre le nombre de demandes adressées au service de données et la quantité de données retournées dans une réponse individuelle. Utilisez le chargement hâtif lorsque votre application requiert des objets associés et que vous souhaitez éviter la latence liée aux demandes supplémentaires nécessaires à leur récupération explicite. Toutefois, s'il y a des cas où l'application ne nécessite que les données pour les instances d'entité connexes spécifiques, vous devez envisager de charger explicitement ces entités en appelant la méthode LoadProperty. Pour plus d'informations, consultez Procédure : charger des entités connexes (WCF Data Services).

Contenu paginé

Lorsque la pagination est autorisée dans le service de données, le nombre d'entrées dans le flux qui sont retournées par le service de données est limité par la configuration du service de données. Des limites de pPage peuvent être définies séparément pour chaque jeu d'entités. Pour plus d'informations, consultez Configuration du service de données (WCF Data Services). Lorsque la pagination est activée, la dernière entrée dans le flux contient un lien vers la page suivante de données. Ce lien est contenu dans un objet DataServiceQueryContinuation. Vous obtenez l'URI vers la page suivante de données en appelant la méthode GetContinuation sur le QueryOperationResponse retourné lorsque DataServiceQuery est exécuté. L'objet DataServiceQueryContinuation retourné est ensuite utilisé pour charger la page suivante de résultats. Vous devez énumérer le résultat de la requête avant d'appeler la méthode GetContinuation. Envisagez d'utiliser une boucle do…while pour énumérer en premier le résultat de la requête, puis rechercher une valeur non-null de lien suivante. Lorsque la méthode GetContinuation retourne Null (Nothing en Visual Basic), il n'y a aucune page de résultat supplémentaire pour la requête d'origine. L'exemple suivant affiche une boucle do…while qui charges des données clientes paginées depuis l'exemple de service de données Northwind.

' With a paged response from the service, use a do...while loop 
' to enumerate the results before getting the next link.
Do
    ' Write the page number.
    Console.WriteLine("Page {0}:", pageCount + 1)

    ' If nextLink is not null, then there is a new page to load.
    If token IsNot Nothing Then
        ' Load the new page from the next link URI.
        response = CType(context.Execute(Of Customer)(token),  _
        QueryOperationResponse(Of Customer))
    End If

    ' Enumerate the customers in the response.
    For Each customer As Customer In response
        Console.WriteLine("\tCustomer Name: {0}", customer.CompanyName)
    Next

    ' Get the next link, and continue while there is a next link.
    token = response.GetContinuation()
Loop While token IsNot Nothing

// With a paged response from the service, use a do...while loop 
// to enumerate the results before getting the next link.
do
{
    // Write the page number.
    Console.WriteLine("Page {0}:", pageCount++);

    // If nextLink is not null, then there is a new page to load.
    if (token != null)
    {
        // Load the new page from the next link URI.
        response = context.Execute<Customer>(token)
            as QueryOperationResponse<Customer>;
    }

    // Enumerate the customers in the response.
    foreach (Customer customer in response)
    {
        Console.WriteLine("\tCustomer Name: {0}", customer.CompanyName);
    }
}

// Get the next link, and continue while there is a next link.
while ((token = response.GetContinuation()) != null);

Lorsqu'une requête demande que les entités connexes soient retournées dans une réponse unique avec le jeu d'entités demandé, des limites de pagination peuvent affecter les flux imbriqués inclus inline avec la réponse. Par exemple, lorsqu'une limite de pagination est définie dans l'exemple de service de données Northwind pour le jeu d'entités Customers, une limite de pagination indépendante peut également être définie pour le jeu d'entités Orders connexe, comme dans l'exemple suivant du fichier Northwind.svc.cs qui définit l'exemple de service de données Northwind.

' Set page size defaults for the data service.
config.SetEntitySetPageSize("Orders", 20)
config.SetEntitySetPageSize("Order_Details", 50)
config.SetEntitySetPageSize("Products", 50)

' Paging requires v2 of the OData protocol.
config.DataServiceBehavior.MaxProtocolVersion = _
    System.Data.Services.Common.DataServiceProtocolVersion.V2

// Set page size defaults for the data service.
config.SetEntitySetPageSize("Orders", 20);
config.SetEntitySetPageSize("Order_Details", 50);
config.SetEntitySetPageSize("Products", 50);

// Paging requires v2 of the OData protocol.
config.DataServiceBehavior.MaxProtocolVersion =
    System.Data.Services.Common.DataServiceProtocolVersion.V2;

Dans ce cas, vous devez implémenter la pagination pour le Customers de niveau supérieur et les flux d'entité Orders imbriqués. L'exemple suivant montre la boucle while utilisée pour charger des pages d'entités Orders associées à une entité Customers sélectionnée.

While nextOrdersLink IsNot Nothing
    For Each o As Order In c.Orders
        ' Print out the orders.
        Console.WriteLine("\t\tOrderID: {0} - Freight: ${1}", _
                o.OrderID, o.Freight)
    Next
    ' Load the next page of Orders.
    Dim ordersResponse = _
    context.LoadProperty(c, "Orders", nextOrdersLink)
    nextOrdersLink = ordersResponse.GetContinuation()
End While

while (nextOrdersLink != null)
{
    foreach (Order o in c.Orders)
    {
        // Print out the orders.
        Console.WriteLine("\t\tOrderID: {0} - Freight: ${1}",
            o.OrderID, o.Freight);
    }

    // Load the next page of Orders.
    var ordersResponse = context.LoadProperty(c, "Orders", nextOrdersLink);
    nextOrdersLink = ordersResponse.GetContinuation();
}

Pour plus d'informations, consultez Procédure : charger des résultats paginés (WCF Data Services).

Flux de données binaires

Services de données WCF vous permet d'accéder à des données d'objet BLOB (binary large object) comme un flux de données. La diffusion en continu diffère le chargement des données binaires tant qu'elles ne sont pas nécessaires, et le client peut traiter ces données plus efficacement. Pour tirer parti de ces fonctionnalités, le service de données doit implémenter le fournisseur IDataServiceStreamProvider. Pour plus d'informations, consultez Fournisseurs de diffusion en continu (WCF Data Services). Lorsque la diffusion en continu est activée, les types d'entité sont retournés sans les données binaires associées. Dans ce cas, vous devez utiliser la méthode GetReadStream de la classe DataServiceContext pour accéder au flux de données pour les données binaires du service. De la même façon, utilisez la méthode SetSaveStream pour ajouter ou modifier les données binaires pour une entité comme un flux de données. Pour plus d'informations, consultez Utilisation de données binaires (WCF Data Services).

Partager via

Chargement de contenu différé (WCF Data Services)

Entités connexes

Contenu paginé

Flux de données binaires

Voir aussi

Concepts

Autres ressources

Ressources supplémentaires