Procédure pas à pas : accès à un service OData à l'aide des fournisseurs de type (F#)
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 la demande d'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
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)
Ordering(orderBy,thenBy)
AddQueryOption et Expand, qui sont des opérations d'OData- spécifique
Pour plus d'informations, consultez LINQ Considerations.
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)
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)
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))
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()))
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()))
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#).
Utilisez l'opérateur de requête sortBy pour spécifier le classement, et utilisez thenBy pour spécifier un autre niveau de le 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)
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 :
Demandez http://services.odata.org/Northwind/Northwind.svc/ Orders() ? $orderby=ShippedDate&$select=OrderID, ShippedDate
Voir aussi
Tâches
Référence
ODataService, fournisseur de type (F#)