Procedura dettagliata: accesso a un servizio OData tramite provider di tipi (F#)

Articolo
02/28/2013

OData, significante il protocollo aperto di dati, è un protocollo per trasferire dati su Internet.Molti provider di dati espongono l'accesso ai dati pubblicando un servizio Web OData.È possibile accedere ai dati da qualsiasi origine di OData in F# 3,0 utilizzando i tipi di dati generati automaticamente dal provider del tipo ODataService.Per ulteriori informazioni su OData, vedere Introducing OData.

In questa procedura dettagliata viene illustrato come utilizzare il provider del tipo F# ODataService per generare i tipi client per un servizio di OData e feed di dati di query che il servizio.

In questa procedura dettagliata vengono illustrate le seguenti attività, che è consigliabile eseguire in quest'ordine per la procedura dettagliata riesca:

Configuring a client project for an OData service
Accessing OData types
Querying an OData service
Verifying the OData requests

Configurazione del progetto client per un servizio di OData

In questo passaggio, è stato configurato un progetto utilizzare un provider di tipo OData.

Per configurare un progetto client per un servizio di OData

Aprire un progetto di applicazione console F# e quindi aggiungere un riferimento all'assembly System.Data.Services.Client Framework.
In estensioni, aggiungere un riferimento all'assembly FSharp.Data.TypeProviders.

Accedere ai tipi di OData

In questo passaggio, creare un provider del tipo che fornisce l'accesso ai tipi e ai dati per un servizio di OData.

Per accedere ai tipi di OData

Nell'editor di codice, aprire un file di origine F# e digitare il codice seguente.
```
open Microsoft.FSharp.Data.TypeProviders


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

let db = Northwind.GetDataContext()
let fullContext = Northwind.ServiceTypes.NorthwindEntities()
```
In questo esempio, è stato richiamato il provider del tipo F# e indicare lo stato per creare un set di tipi basati sull'URI di OData specificato.Due oggetti sono disponibili con informazioni sui dati; uno è un contesto dati semplificato, db nell'esempio.Questo oggetto contiene solo i tipi di dati associati al database, inclusi i tipi per le tabelle o feed.L'altro oggetto, fullContext in questo esempio, è un'istanza DataContext e contiene molti metodi, proprietà ed eventi aggiuntivi.

Eseguire una query su un servizio di OData

In questo passaggio, utilizzare le espressioni di query F# per eseguire una query sul servizio di OData.

Per eseguire una query su un servizio di OData

Dopo avere installato il provider di tipo, è possibile eseguire una query su un servizio di OData.

OData supporta solo un sottoinsieme di operazioni di query disponibili.Le seguenti operazioni e parole chiave corrispondenti sono supportate:
- proiezione (select)
- eliminando (where, mediante le operazioni di data e di stringa)
- paging (skip, take)
- ordinamento (orderBy, thenBy)
- AddQueryOption e Expand, che sono operazioni OData-specifiche
Per ulteriori informazioni, vedere LINQ Considerations.

Se si desidera che tutte le voci di un feed o in una tabella, utilizzare la forma più semplice dell'espressione di query, come nel codice seguente:
```
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)
```

Specificare i campi o le colonne che si desidera utilizzare una tupla dopo la parola chiave selezionata.

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)

Specificare le condizioni utilizzando una clausola 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))

Specificare uno stato di una sottostringa alla query tramite il metodo Contains.La seguente query restituisce tutti i prodotti che presentano “cuoco„ solo nei nomi.Si noti inoltre l'utilizzo GetValueOrDefault.UnitPrice è un valore NULL, pertanto è necessario ottenere il valore della proprietà Value, o è necessario chiamare 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()))
```

Utilizzare il metodo EndsWith per specificare una stringa che termina con una determinata sottostringa.

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()))

Combinare i termini nella clausola where utilizzando l'operatore &&.

// 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()))

Gli operatori ?> e ?< operatori sono nullable.È possibile utilizzare una serie completa di uguaglianza nullable e operatori di confronto.Per ulteriori informazioni, vedere Modulo Linq.NullableOperators (F#).

Utilizzare l'operatore di query sortBy per specificare l'ordine e utilizzare thenBy per specificare un altro livello di ordine.Si noti inoltre l'utilizzo di una tupla nella parte selezionata della query.Di conseguenza, la query è una tupla come tipo di elemento.

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)

Ignora un numero specificato di record utilizzando l'operatore di salto e utilizzare l'operatore di controllo per specificare una serie di record da restituire.In questo modo, è possibile implementare lo spostamento tra le pagine in feed di dati.

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

Verificare la richiesta di OData

Ogni query di OData viene convertito in URI specifico di OData.È possibile verificare che URI, magari per il debug, aggiungendo un gestore eventi per l'evento SendingRequest l'oggetto completo del contesto dati.

Per testare la richiesta di OData

Per verificare l'uri di OData, utilizzare il codice seguente:

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

L'output del codice precedente è:

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

Vedere anche

Share via