Partager via

Procédure pas à pas : accès à un service OData à l'aide des fournisseurs de type (F#)

  • Article

OData, qui signifie Open Data Protocol, est un protocole de transfert des données sur Internet. De nombreux fournisseurs de données exposent un accès à leurs données en publiant un service Web OData. Vous pouvez accéder aux données d'une source d'OData en F# 3.0 à l'aide des types de données qui sont générés automatiquement par le fournisseur de type ODataService. Pour plus d’informations sur l'OData, voir Introducing OData.

Cette procédure pas - à - pas vous indique comment utiliser le fournisseur de type F# ODataService pour générer les types clients pour un service d'OData et requêter les sources de données que le service fournit.

Cette procédure pas - à - pas décrit les tâches suivantes, que vous devez exécuter dans cette commande pour la procédure pas - à - pas réussisse :

  • Configurer un projet client pour un service d'OData

  • Accéder aux types OData

  • Interrogation d'un service OData

  • Vérifier les requêtes OData

Configurer un projet client pour un service d'OData

Dans cette étape, vous installez un projet pour utiliser un fournisseur de type OData.

Pour configurer un projet client pour un service d'OData

  • Ouvrez un projet d'application console F#, puis ajoutez une référence à l'assembly d'infrastructure System.Data.Services.Client.

  • Sous Extensions, ajoutez une référence à l'assembly FSharp.Data.TypeProviders.

Accéder aux types OData

Dans cette étape, vous créez un fournisseur de type qui permet d'accéder aux types et aux données d'un service d'OData.

Pour accéder aux types d'OData

  • Dans l'éditeur de code, ouvrez un fichier source F#, puis entrez le code suivant.

    open Microsoft.FSharp.Data.TypeProviders


type Northwind = ODataService<"http://services.odata.org/Northwind/Northwind.svc/">

let db = Northwind.GetDataContext()
let fullContext = Northwind.ServiceTypes.NorthwindEntities()

    Dans cet exemple, vous avez appelé le fournisseur de type F# et lui avez demandé de créer un ensemble de types basés sur l'URI d'OData que vous avez spécifié. Deux objets sont disponibles qui contiennent les informations sur les données ; l'un est un contexte simplifié de données, db dans l'exemple. Cet objet contient uniquement des types de données associés à la base de données, notamment des types pour des tables ou des sources. L'autre l'objet, fullContext dans cet exemple, est une instance de DataContext et contient de nombreuses propriétés, de méthodes, et des événements supplémentaires.

Interrogation d'un service OData

Dans cette étape, vous utilisez des expressions de requête F# pour interroger le service d'OData.

Pour interroger un service d'OData

  1. Maintenant que vous avez installé le fournisseur de type, vous pouvez interroger un service d'OData.

    OData prend en charge uniquement un sous-ensemble des opérations de requête disponibles. Les opérations suivantes et leurs mots clés correspondants sont pris en charge :

    • projection (select)

    • filtrage (where, en utilisant des opérations de chaîne et de date)

    • pagination (skip, take)

    • classement (orderBy, thenBy)

    • AddQueryOption et Expand, qui sont des opérations d'OData- spécifique

    Pour plus d'informations, consultez Considérations sur LINQ (WCF Data Services).

    Si vous voulez toutes les entrées dans une source ou un tableau, utilisez la forme la plus simple de l'expression de requête, comme dans le code suivant :

    query { for customer in db.Customers do
        select customer }
|> Seq.iter (fun customer ->
    printfn "ID: %s\nCompany: %s" customer.CustomerID customer.CompanyName
    printfn "Contact: %s\nAddress: %s" customer.ContactName customer.Address
    printfn "         %s, %s %s" customer.City customer.Region customer.PostalCode
    printfn "%s\n" customer.Phone)

  2. Spécifiez des champs ou des colonnes que vous souhaitez en utilisant un tuple après le mot clé select.

    query { for cat in db.Categories do
        select (cat.CategoryID, cat.CategoryName, cat.Description) }
|> Seq.iter (fun (id, name, description) ->
    printfn "ID: %d\nCategory: %s\nDescription: %s\n" id name description)

  3. Spécifier des conditions à l'aide d'une clause where.

    query { for employee in db.Employees do
        where (employee.EmployeeID = 9)
        select employee }
|> Seq.iter (fun employee ->
    printfn "Name: %s ID: %d" (employee.FirstName + " " + employee.LastName) (employee.EmployeeID))                        

  4. Spécifiez une condition de sous-chaîne à la requête à l'aide de la méthode Contains. La requête suivante retourne tous les produits qui ont « Chef » dans leur nom. Notez également l'utilisation de GetValueOrDefault. UnitPrice est une valeur nullable, vous devez donc soit obtenir la valeur à l'aide de la propriété Value, ou vous devez appeler GetValueOrDefault.

    query { for product in db.Products do
        where (product.ProductName.Contains("Chef"))
        select product }
|> Seq.iter (fun product ->
    printfn "ID: %d Product: %s" product.ProductID product.ProductName
    printfn "Price: %M\n" (product.UnitPrice.GetValueOrDefault()))

  5. Utilisez la méthode EndsWith pour spécifier qu'une chaîne se termine par une sous-chaîne.

    query { for product in db.Products do
        where (product.ProductName.EndsWith("u"))
        select product }
|> Seq.iter (fun product ->
    printfn "ID: %d Product: %s" product.ProductID product.ProductName
    printfn "Price: %M\n" (product.UnitPrice.GetValueOrDefault()))

  6. Combinez les conditions dans la clause where à l'aide de l'opérateur &&.

    // Open this module to use the nullable operators ?> and ?<.
open Microsoft.FSharp.Linq.NullableOperators

let salesIn1997 = query { for sales in db.Category_Sales_for_1997 do
                          where (sales.CategorySales ?> 50000.00M && sales.CategorySales ?< 60000.0M)
                          select sales }
salesIn1997
|> Seq.iter (fun sales ->
    printfn "Category: %s Sales: %M" sales.CategoryName (sales.CategorySales.GetValueOrDefault()))

    Les opérateurs ?> et ?< sont des opérateurs nullables. Vous pouvez utiliser un jeu complet d'égalité nullable et d'opérateurs de comparaison. Pour plus d'informations, consultez Linq.NullableOperators, module (F#).

  7. Utilisez l'opérateur de requête sortBy pour spécifier le classement, et utilisez thenBy pour spécifier un autre niveau de classement. Notez également l'utilisation d'un tuple dans le select de la requête. Par conséquent, la requête a un tuple comme type d'élément.

    printfn "Freight for some orders: "
query { for order in db.Orders do
        sortBy (order.OrderDate.Value)
        thenBy (order.OrderID)
        select (order.OrderDate, order.OrderID, order.Customer.CompanyName)
         }
|> Seq.iter (fun (orderDate, orderID, company) ->
    printfn "OrderDate: %s" (orderDate.GetValueOrDefault().ToString())
    printfn "OrderID: %d Company: %s\n" orderID company)

  8. Ignore un nombre d'enregistrements spécifiée à l'aide de l'opérateur de saut, puis utilise l'opérateur take pour spécifier un certain nombre d'enregistrements à retourner. De cette façon, vous pouvez implémenter la pagination sur les flux de données.

    printfn "Get the first page of 2 employees."
query { for employee in db.Employees do
        take 2
        select employee }
|> Seq.iter (fun employee ->
    printfn "Name: %s ID: %d" (employee.FirstName + " " + employee.LastName) (employee.EmployeeID)) 

printfn "Get the next 2 employees."
query { for employee in db.Employees do
        skip 2
        take 2
        select employee }
|> Seq.iter (fun employee ->
    printfn "Name: %s ID: %d" (employee.FirstName + " " + employee.LastName) (employee.EmployeeID))

Vérifier la demande d'OData

Chaque requête d'OData est traduite en une URI de requête OData spécifique. Vous pouvez vérifier cette URI, éventuellement à des fins de débogage, en ajoutant un gestionnaire d'événements à l'événement SendingRequest sur l'objet de contexte de données complet.

Pour vérifier la demande d'OData

  • Pour vérifier l'URI de requête OData, utilisez le code suivant :

        // The DataContext property returns the full data context.
    db.DataContext.SendingRequest.Add (fun eventArgs -> printfn "Requesting %A" eventArgs.Request.RequestUri)

    La sortie du code ci-dessus est :

    • 



demande de http://services.odata.org/Northwind/Northwind.svc/Orders()?$orderby=ShippedDate&$select=OrderID,ShippedDate



Voir aussi


Tâches


Expressions de requête (F#)


Référence


ODataService, fournisseur de type (F#)


Concepts


Considérations sur LINQ (WCF Data Services)