Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

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

OData (Open Data Protocol) è un protocollo per il trasferimento di dati in Internet. Molti provider di dati espongono l'accesso ai dati pubblicando un servizio Web OData. È possibile accedere ai dati da qualsiasi origine OData in F# 3.0 utilizzando i tipi di dati generati automaticamente dal provider di tipo ODataService. Per ulteriori informazioni su OData, vedere Introducing OData.

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

In questa procedura dettagliata vengono illustrate le seguenti attività, che è consigliabile eseguire in quest'ordine perché la procedura abbia successo:

In questo passaggio, viene configurato un progetto per utilizzare un provider di tipo OData.

Per configurare un progetto client per un servizio OData

  • Aprire un Progetto di applicazione console F# e quindi aggiungere un riferimento all'assembly Framework System.Data.Services.Client.

  • In Estensioni, aggiungere un riferimento all'assembly FSharp.Data.TypeProviders.

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

Per accedere ai tipi OData

  • Nell'editor di codice, aprire un file 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 di tipo F# ed è stato istruito per creare un set di tipi basati sull'URI di OData specificato. Sono disponibili due oggetti che contengono 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 per i feed. L'altro oggetto, fullContext in questo esempio, è un'istanza di DataContext e contiene molti metodi, proprietà ed eventi aggiuntivi.

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

Per eseguire una query su un servizio OData

  1. Ora che è stato installato il provider di tipo, è possibile eseguire una query su un servizio OData.

    OData supporta solo un sottoinsieme di operazioni di query disponibili. Le seguenti operazioni e le corrispondenti parole chiave sono supportate:

    • proiezione (select)

    • filtraggio (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 Considerazioni su LINQ (WCF Data Services).

    Se si desiderano tutte le voci in 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)
    
    
  2. Specificare i campi o le colonne che si desiderano utilizzando 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)
    
    
  3. 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))                         
    
    
    
  4. Specificare la condizione di una sottostringa alla query tramite il metodo Contains. La seguente query restituisce tutti i prodotti che presentano “cuoco" nel nome. Si noti inoltre l'utilizzo di GetValueOrDefault. Il valore UnitPrice è nullable, 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()))
    
    
  5. Utilizzare il metodo EndsWith per specificare che una stringa 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()))
    
    
  6. 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 ?< sono nullable. È possibile utilizzare un set completo di uguaglianze nullable e operatori di confronto. Per ulteriori informazioni, vedere Modulo Linq.NullableOperators (F#).

  7. Utilizzare l'operatore di query sortBy per specificare l'ordinamento e utilizzare thenBy per specificare un altro livello di ordinamento. Si noti inoltre l'utilizzo di una tupla nella parte selezionata della query. Di conseguenza, la query ha 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)
    
    
  8. Ignorare 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)) 
    
    

Ogni query OData viene convertita in una specifica richiesta URI di OData. È possibile verificare l' URI, magari per il debug, aggiungendo un gestore eventi per l'evento SendingRequest nell'oggetto completo di contesto dati.

Per testare la richiesta di OData

  • Per verificare la richiesta 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 è .

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

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft