Tutorial: Obtener acceso a un servicio OData mediante proveedores de tipo (F#)

Artículo
02/19/2013

OData, que significa Open Data Protocol, es un protocolo de transferencia de datos a través de Internet.Muchos proveedores de datos exponen el acceso a sus datos mediante la publicación de un servicio Web de OData.Se puede tener acceso a los datos de cualquier fuente OData en F# 3.0 utilizando los tipos de datos que se generan automáticamente mediante el proveedor de tipos ODataService.Para obtener más información sobre OData, consulte Introducing OData.

Este tutorial muestra cómo utilizar el proveedor de tipos ODataService de F# para generar los tipos de cliente para servicios OData y para las fuentes de datos de consulta que el servicio proporciona.

Este tutorial muestra las tareas que siguen a continuación y que se deben realizar en el orden en que aparecen para que el tutorial se realice correctamente:

Configuración de un proyecto cliente para un servicio OData
Acceder a tipos OData
Consultar un servicio OData
Comprobación de la solicitud OData

Configuración de un proyecto cliente para un servicio OData

En este paso se onfigurará un proyecto para que utilice un proveedor de tipos OData.

Cómo configurar un proyecto cliente para un servicio OData

Abra un proyecto de aplicación de consola de F#, y agregue una referencia al ensamblado del Framework System.Data.Services.Client.
Bajo Extensiones, agregue una referencia al ensamblado FSharp.Data.TypeProviders .

Acceder a tipos OData

En este paso se creará un proveedor de tipos que proporcione acceso a los tipos y datos de un servicio OData.

Cómo tener acceso a los tipos OData

En el editor de código, abra un archivo de código fuente de F#, e inserte el siguiente código.
```
open Microsoft.FSharp.Data.TypeProviders


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

let db = Northwind.GetDataContext()
let fullContext = Northwind.ServiceTypes.NorthwindEntities()
```
En este ejemplo, se ha invocado al proveedor de tipos de F# y se le ha especificado que cree un conjunto de tipos que se basan en el URI de OData especificado.Hay disponibles dos objetos que contienen información sobre los datos; uno es un contexto simplificado de datos, db en el ejemplo.Este objeto contiene únicamente los tipos de datos asociados a la base de datos, que incluyen tipos para las tablas o fuentes.El otro objeto, fullContext en este ejemplo, es una instancia de DataContext y contiene muchas propiedades, métodos y eventos adicionales.

Consultar un servicio OData

En este paso se utilizan las expresiones de consulta de F# para consultar el servicio de OData.

Cómo consultar un servicio OData

Una vez que se ha configurado el proveedor de tipos, se pueden hacer consultas sobre un servicio de OData.

OData solo admite un subconjunto de las operaciones de consulta disponibles.Se admiten las siguientes operaciones y sus palabras clave correspondientes:
- proyección (select)
- filtrado (where mediante operaciones de cadena y de fecha)
- paginación (skip, take)
- ordenamiento (orderBy, thenBy)
- AddQueryOption y Expand que son operaciones específicas de OData
Para obtener más información, vea LINQ Considerations.

Si se desean todas las entradas de una fuente o una tabla, entonces se utiliza la forma más sencilla de expresión de consulta, tal como la que se muestra en el siguiente código:
```
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)
```

Especifique los campos o columnas que desea utilizando una tupla después de la palabra clave 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)

Especifique las condiciones mediante una 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 una condición de subcadena para la consulta mediante el método Contains.La siguiente consulta devuelve todos los productos que tienen “Chef” en su nombre.Observe también el uso de GetValueOrDefault.El UnitPrice es un valor que acepta nulos, por lo que se deberá obtener el valor bien mediante la propiedad Value o se deberá llamar a 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()))
```

Utilice el método EndsWith para especificar que una cadena termina con una subcadena determinada.

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 las condiciones en una cláusula where mediante el 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()))

Los operadores ?> y ?< son operadores que aceptan valores nulos.Se puede utilizar un conjunto completo de operadores de igualdad que acepten nulos y de comparación.Para obtener más información, vea Linq.NullableOperators (Módulo de F#).

Utilice el operador de consulta sortBy para especificar el orden y thenBy para especificar otro nivel de clasificación.Observe también el uso de una tupla en la parte select de la consulta.Por consiguiente, la consulta tiene una tupla como 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)

Omita un número de registros determinado mediante el operador skip y utilice el operador take para especificar el número de registros que se deben devolver.De esta manera,se puede implementar la paginación en las fuentes de datos.

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

Comprobación de la solicitud OData

Cada consulta OData se convierte en un URI concreto de la solicitud de OData .Se puede comprobar dicho URI, quizás para fines de depuración, agregando un controlador de eventos al evento SendingRequest en el objeto de contexto de datos completo.

Cómo comprobar la solicitud de OData

Para comprobar el URI de la solicitud de OData, utilice el siguiente código:

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

La salida del código anterior es:

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

Vea también