Wskazówki: uzyskiwanie dostępu do usługi OData za pomocą dostawców typów (F#)

  • Artykuł

OData (Open Data Protocol) to protokół przesyłania danych przez Internet.Wielu dostawców danych uwidacznia dostęp do swoich danych przez publikowanie usługi sieci Web OData.Dostęp do danych może być uzyskany z dowolnego źródła OData w wersji 3.0 języka F# przy użyciu typów danych które są automatycznie generowane przez dostawcę typów ODataService.Aby uzyskać więcej informacji na temat OData, zobacz Introducing OData.

Ten instruktaż przedstawia sposób użycia dostawcy typów języka F# ODataService w celu generowania typów klienta usługi i źródeł danych zapytania OData dostarczanych przez usługę.

Następujące zadania pokazane w tym przewodniku muszą zostać wykonane w podanej kolejności, aby ukończenie przewodnika powiodło się:

  • Konfigurowanie usługi OData projektu klienta

  • Dostęp do typów OData

  • Zapytanie do usługi OData

  • Weryfikowanie wniosków OData

Konfigurowanie usługi OData projektu klienta

W tym kroku projekt konfigurowany jest do użycia dostawcy typów OData.

Aby skonfigurować usługę OData projektu klienta

  • Otwórz projekt aplikacji konsolowej F#, a następnie dodaj odwołanie do zestawu platformy System.Data.Services.Client.

  • W obszarze Rozszerzenia dodaj odwołanie do zestawu FSharp.Data.TypeProviders.

Dostęp do typów OData

W tym kroku utworzony zostanie dostawca typów, który zapewnia dostęp do typów i danych dla usługi OData.

W celu uzyskania dostępu do typów OData

  • W edytorze kodu otwórz plik źródłowy F# i wprowadź następujący kod.

    open Microsoft.FSharp.Data.TypeProviders


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

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

    W tym przykładzie został wywoływany dostawca typów F#, a następnie zlecono mu utworzenie zestawu typów opartych o określone URI OData.Dostępne są dwa obiekty zawierające informacje o danych; jeden jest uproszczonym kontekstem danych, na przykład db.Obiekt ten zawiera tylko typy danych, które są skojarzone z bazy danych, które obejmują typy tabel lub źródła danych.Drugi obiekt w tym przykładzie fullContext jest wystąpieniem DataContext i zawiera wiele dodatkowych właściwości, metod i zdarzeń.

Zapytanie do usługi OData

W tym kroku użyte zostanie wyrażenie zapytania F# w celu wysłania zapytania do usługi OData.

W celu wysłania zapytania do usługi OData

  1. Po ustawieniu dostawcy typów można wysłać zapytanie do usługi OData.

    OData obsługuje tylko podzbiór dostępnych zapytań.Obsługiwane są następujące operacje i odpowiadające im słowa kluczowe:

    • projekcja (select)

    • Filtrowanie (where, przy użyciu ciągu znaków i operacji na dacie)

    • stronicowanie (skip, take)

    • szeregowanie (orderBy, thenBy)

    • AddQueryOption i Expand, czyli operacje charakterystyczne dla OData

    Aby uzyskać więcej informacji, zobacz LINQ Considerations (WCF Data Services).

    Jeśli potrzebujesz wszystkich wpisów w źródle lub tabeli użyj najprostszej formy zapytania, tak jak przedstawiono to w poniższym kodzie:

    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. Określ pola lub kolumny, które są potrzebne, poprzez użycie krotki po wybranym słowie kluczowym.

    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. Określ warunki za pomocą klauzuli 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. Określ warunek podciągu zapytania za pomocą metody Contains.Następujące zapytanie zwraca wszystkie produkty, które mają w nazwie ciąg "Chef".Ponadto zwróć uwagę na wykorzystanie GetValueOrDefault.UnitPrice może przyjmować wartość null, więc pobranie wartości musi nastąpić przez właściwość Value lub wywołanie 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. Użyj metody EndsWith w celu określenia podciągu jakim kończy się dany ciąg.

    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. Operator && może być użyty do łączenia warunków klauzuli WHERE.

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

    Operatory ?> i ?< mogą przyjmować wartości null.Można zastosować pełen zestaw operatorów porównania i równości mogących zwrócić wartość null.Aby uzyskać więcej informacji, zobacz Linq.NullableOperators — Moduł (F#).

  7. Użyj operatora zapytania sortBy w celu określenia uporządkowania, oraz thenBy do określenia innego poziomu uporządkowania.Zauważ także użycie krotki w części zapytania związanej z SELECT.Dlatego też zapytanie ma krotki jako typ elementu.

    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. Ignoruj określoną liczbę rekordów przy użyciu operatora pominięcia, a także używaj operatora pobrania w celu określenia liczby rekordów, które należy zwrócić.W ten sposób można zaimplementować stronicowanie na źródle danych.

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

Weryfikowanie żądania OData

Każde zapytanie OData jest tłumaczone na specjalne URI żądania OData.W celu debugowania można zweryfikować dane URI poprzez dodanie obsługi zdarzenia do zdarzenia SendingRequest na obiekcie pełnego kontekstu danych.

Aby zweryfikować żądanie OData

  • Aby zweryfikować URI żądania OData należy użyć następującego kodu:

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

    Dane wyjściowe poprzedniego kodu:

    • 



żądanie (http://services.odata.org/Northwind/Northwind.svc/Orders)? $orderby = DataWysyłki&$select = IDZamówienia DataWysyłki



Zobacz też


Zadania


Zapytania (F#)


Informacje


ODataService — Typ dostawcy (F#)


Koncepcje


LINQ Considerations (WCF Data Services)