Passo a passo: Acessando um serviço de OData usando o provedores de tipo (F#)

Artigo
02/25/2013

OData, que quer dizer Protocolo Aberto de Dados, é um protocolo para transferir dados através da Internet.Vários provedores de dados expõem acesso aos seus dados publicando um serviço web OData.Você pode acessar dados de qualquer fonte OData em F# 3.0 usando tipos de dados que são gerados automaticamente pelo provedor de tipos ODataService.Para obter mais informações sobre recursos, consulte Introducing OData.

Este passo-a-passo mostra como usar o provedor de tipos F# ODataService para gerar tipos de cliente para um serviço OData e consultar feeds de dados que o serviço fornece.

Esse guia passo a passo ilustra as seguintes tarefas, que você deve executar nesta ordem para que o guia cumprido sua função:

Configurando um projeto de cliente para um serviço OData
Acessando tipos OData
Consultando um serviço OData
Verificando a solicitação OData

Configurando um projeto de cliente para um serviço OData

Nesta etapa, você configura um projeto para usar um provedor de tipos OData.

Para configurar um projeto cliente para um serviço OData

Abra um novo projeto de aplicativo de console F#, e então adicione uma referência ao conjunto da estrutura System.Data.Services.Client.
Em Extensions, adicione uma referência para o assembly FSharp.Data.TypeProviders.

Acessando tipos OData

Nesta etapa, você cria um provedor de tipos que provê acesso a tipos e a dados para um serviço OData.

Para acessar tipos OData

No editor de códigos, abra um arquivo de origem F#, e insira o código a seguir.
```
open Microsoft.FSharp.Data.TypeProviders


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

let db = Northwind.GetDataContext()
let fullContext = Northwind.ServiceTypes.NorthwindEntities()
```
Nesse exemplo, você chamou o provedor de tipos F# e o instruiu a criar um conjunto de tipos que são baseados na URI OData que você especificou.Dois objetos estão disponíveis que contém informações sobre os dados; um é um contexto simplificado de dados, db no exemplo.Este objeto contém somente os tipos de dados que estão associados com o banco de dados, o que inclui tipos para tabelas ou feeds.O outro objeto, fullContext nesse exemplo, é uma instância de DataContext e contém muitas propriedades, métodos e eventos adicionais.

Consultando um serviço OData

Nesta etapa, você usa expressões de consulta F# para ver o serviço OData.

Para consultar um serviço OData

Agora que você configurou o provedor de tipos, você pode consultar um serviço OData.

OData suporta apenas um subconjunto das operações disponíveis para consulta.As seguintes operações e suas palavras-chaves correspondentes são suportados:
- projeção (select)
- filtrar (where, usando operações de cadeia de caracteres e data)
- paginação (skip, take)
- ordenação (orderBy, thenBy)
- AddQueryOption e Expand, que são operações específicas OData
Para obter mais informações, consulte LINQ Considerations.

Se você deseja todas as entradas em um feed ou em uma tabela, use a forma mais simples de expressão de consulta, como no código a seguir:
```
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)
```

Especificar os campos ou colunas que você deseja usando uma tupla após a palavra-chave 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)

Especificar condições usando uma cláusula 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))

Especifique uma condição da subcadeia de caracteres à consulta usando o método Contains.A consulta a seguir retorna todos os produtos que têm “Chef” em seus nomes.Também observe o uso de GetValueOrDefault.O UnitPrice é um valor anulável, portanto você deve ou obter o valor usando a propriedade Value, ou você deve chamar 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()))
```

Use o método EndsWith para especificar que uma cadeia de caracteres termina com uma determinada subcadeia de caracteres.

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

Combine condições na cláusula WHERE usando o operador &&.

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

Os operadores ?> e ?< são operadores anuláveis.Você pode usar um conjunto completo de operadores anuláveis de igualdade e comparação.Para obter mais informações, consulte Módulo de LINQ.NullableOperators (F#).

Use o operador de consulta sortBy para especificar a ordenação, e use thenBy para especificar um outro nível de ordenação.Também observe o uso de uma tupla na parte select da consulta.Portanto, a consulta possui uma tupla como um tipo de 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)

Ignore um número de registros especificado usando o operador skip, e use o operador take para especificar um número de registros para retornar.Dessa forma, você pode implementar paginação em feeds de dados.

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

Verificando a solicitação OData

Cada consulta OData é convertida em um URI específico de solicitação OData.Você pode verificar o URI, talvez para fins de depuração, adicionando um manipulador de eventos ao evento SendingRequest no objeto de contexto de dados completo.

Para verificar a solicitação OData

Para verificar o URI de solicitação OData, use o seguinte código:

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

A saída do código anterior é:

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

Consulte também

Partilhar via