Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese
We recommend using Visual Studio 2017
Questa documentazione è stata archiviata e non viene gestita.

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

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:

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.

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.

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

  1. 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)
    
    
  2. 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)
    
    
  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 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()))
    
    
  5. 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()))
    
    
  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 ?< operatori sono nullable. È possibile utilizzare una serie completa di uguaglianza nullable e operatori di confronto. Per ulteriori informazioni, vedere Modulo Linq.NullableOperators (F#).

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

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
Mostra: