Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés

Consideraciones sobre LINQ (WCF Data Services)

En este tema se proporciona información sobre cómo se crean y ejecutan consultas LINQ cuando se usa el cliente Servicios de datos de Microsoft WCF y las limitaciones de uso de LINQ para consultar un servicio de datos que implementa Open Data Protocol (OData). Para obtener más información sobre cómo se crean y ejecutan consultas en un servicio de datos basado en OData, vea Consultar el servicio de datos (WCF Data Services).

Este tema contiene las siguientes secciones:

LINQ permite redactar consultas en una colección de objetos que implemente la interfaz IEnumerable<T>. Tanto el cuadro de diálogo Agregar referencia de servicio de Visual Studio como la herramienta DataSvcUtil.exe se usan para generar una representación de un servicio de OData como clase de contendor de entidades que hereda de la clase DataServiceContext, así como objetos que representen las entidades devueltas en fuentes. Estas herramientas también generan propiedades en la clase de contenedor de entidades de las colecciones que el servicio exponen como fuentes. Cada una de estas propiedades de la clase que encapsula el servicio de datos devuelve una clase DataServiceQuery<TElement>. Puesto que la clase DataServiceQuery<TElement> implementa la interfaz IQueryable<T> definida por LINQ, puede crear una consulta LINQ en fuentes expuestas por el servicio de datos, que la biblioteca cliente traduce en un URI de solicitud de consulta que se envía al servicio de datos en la ejecución.

Nota importante Importante

El conjunto de consultas que se pueden expresar en la sintaxis de LINQ es más amplio que los habilitados en la sintaxis URI basada en OData que usan los servicios de datos. Cuando la consulta no se puede asignar a ningún URI del servicio de datos de destino, se produce una excepción NotSupportedException. Para obtener más información, vea Unsupported LINQ Methods en este tema.

El siguiente ejemplo es una consulta LINQ que devuelve Orders con un costo de flete de más de 30 $ y ordena los resultados por la fecha de envío, comenzando por la fecha de envío más reciente:

var selectedOrders = from o in context.Orders
                     where o.Freight > 30
                     orderby o.ShippedDate descending 
                     select o;

Esta consulta LINQ se traduce en el siguiente URI de la consulta que se ejecuta en el servicio de base de datos del tutorial rápido basado en Northwind:

http://localhost:12345/Northwind.svc/Orders?Orderby=ShippedDate&?filter=Freight gt 30

Para obtener más información general acerca de LINQ, vea Language-Integrated Query (LINQ).

LINQ permite redactar consultas mediante el uso tanto de la sintaxis de consulta declarativa específica del lenguaje, mostrada en el ejemplo anterior, como de un conjunto de métodos de consulta denominados operadores de consulta estándar. Una consulta equivalente al ejemplo anterior se puede redactar mediante el uso de la sintaxis basada en métodos únicamente, como se muestra en el siguiente ejemplo:

var selectedOrders = context.Orders
                    .Where(o => o.Freight > 30)
                    .OrderByDescending(o => o.ShippedDate);

El cliente de Servicios de datos de Microsoft WCF puede traducir ambos tipos de consultas redactadas en un URI de la consulta y puede ampliar una consulta LINQ si anexa los métodos de consulta a una expresión de consulta. Cuando redacte consultas LINQ anexando la sintaxis del método a una expresión de consulta o a una clase DataServiceQuery<TElement>, las operaciones se agregan al URI de la consulta en el orden en el que se llama a los métodos. Esto es equivalente a llamar al método AddQueryOption(String, Object) para agregar cada opción de consulta al URI de la consulta.

Ciertos métodos de consulta LINQ, como los métodos First<TSource> o Single<TSource>, cuando se anexan a la consulta, provocan la ejecución de esta. También se ejecuta una consult6a cuando los resultados se enumeran implícitamente, como durante un bucle foreach o cuando la consulta se asigna a una colección List. Para obtener más información, vea Consultar el servicio de datos (WCF Data Services).

El cliente ejecuta una consulta LINQ en dos partes. Siempre que sea posible, las expresiones LINQ de una consulta primero se evalúan en el cliente y, a continuación, se generan y se envían al servicio de datos para su evaluación en los datos del servicio. Para obtener más información, vea la sección Client versus Server Execution de Consultar el servicio de datos (WCF Data Services).

Cuando no se puede traducir ninguna consulta LINQ de un URI de consulta conforme a OData, se produce una excepción al intentar la ejecución. Para obtener más información, vea Consultar el servicio de datos (WCF Data Services).

Los ejemplos de las secciones siguientes muestran los tipos de consultas LINQ que se pueden ejecutar en un servicio de OData.

Filtrar

Los ejemplos de consultas LINQ de esta sección filtran los datos de la fuente devuelta por el servicio.

Los siguientes ejemplos son consultas equivalentes que filtran las entidades Orders devueltas para que solo se devuelvan los pedidos con un costo de flete mayor que 30 $:

  • Usar sintaxis de consulta LINQ:

    var filteredOrders = from o in context.Orders
                            where o.Freight > 30
                            select o;
    
  • Usar métodos de consulta LINQ:

    var filteredOrders = context.Orders
        .Where(o => o.Freight > 30);
    
  • La opción $filter de la cadena de consulta del URI:

    // Define a query for orders with a Freight value greater than 30.
    var filteredOrders
        = context.Orders.AddQueryOption("$filter", "Freight gt 30M");
    

Todos los ejemplos anteriores se traducen en el URI de consulta: http://localhost:12345/northwind.svc/Orders()?$filter=Freight gt 30M.

También puede usar los operadores All<TSource>(IEnumerable<TSource>, Func<TSource, Boolean>) y Any<TSource>(IEnumerable<TSource>) para crear consultas que filtren entidades basándose en propiedades de colección. En este caso, el predicado se evalúa con respecto a propiedades que devuelven tanto colecciones de entidades relacionadas como colecciones de tipos primitivos y complejos. Por ejemplo, la consulta siguiente devuelve todos los empleados que tengan un territorio cuya descripción contenga la cadena proporcionada:

var filteredEmployees = from e in context.Employees
                        where e.Territories.Any(t => t.TerritoryDescription.Contains(territory))
                        select e;

En esta consulta, el operador Any<TSource>(IEnumerable<TSource>) le permite recorrer la asociación varios a varios entre Employees y Territories para filtrar empleados según la evaluación de los territorios relacionados. Para obtener más información, vea la entrada de blog Compatibilidad con Any/All en WCF Data Services.

Ordenar

Los siguientes ejemplos muestran consultas equivalentes que ordenan ascendentemente los datos tanto por nombre de compañía como por código postal:

  • Usar sintaxis de consulta LINQ:

    var sortedCustomers = from c in context.Customers
                         orderby c.CompanyName ascending, 
                         c.PostalCode descending
                         select c;
    
  • Usar métodos de consulta LINQ:

    var sortedCustomers = context.Customers.OrderBy(c => c.CompanyName)
        .ThenByDescending(c => c.PostalCode);
    
  • Opción $orderby de la cadena de consulta del URI):

    var sortedCustomers = context.Customers
        .AddQueryOption("$orderby", "CompanyName, PostalCode desc");
    

Todos los ejemplos anteriores se traducen en el URI de la consulta: http://localhost:12345/northwind.svc/Customers()?$orderby=CompanyName,PostalCode desc.

Proyección

Los siguientes ejemplos muestran las consultas equivalentes que proyectan los datos devueltos en el tipo CustomerAddress más restringido:

  • Usar sintaxis de consulta LINQ:

    var projectedQuery = from c in context.Customers
                select new CustomerAddress
                {
                    CustomerID = c.CustomerID,
                    Address = c.Address,
                    City = c.City,
                    Region = c.Region,
                    PostalCode = c.PostalCode,
                    Country = c.Country
                };
    
  • Usar métodos de consulta LINQ:

    var projectedQuery = context.Customers.Where(c => c.Country == "Germany")
        .Select(c => new CustomerAddress
        {
            CustomerID = c.CustomerID, 
            Address = c.Address,
            City = c.City,
            Region = c.Region,
            PostalCode = c.PostalCode,
            Country = c.Country});                   
    
Nota Nota

La opción de consulta $select no se puede agregar a ningún URI de la consulta mediante el uso del método AddQueryOption(String, Object). Se recomienda usar el método Select<TSource, TResult>(IEnumerable<TSource>, Func<TSource, TResult>) de LINQ para que el cliente genere la opción de consulta $select en el URI de solicitud.

Los dos ejemplos anteriores se traducen en el URI de la consulta: "http://localhost:12345/northwind.svc/Customers()?$filter=Country eq 'GerGerm'&$select=CustomerID,Address,City,Region,PostalCode,Country".

Paginación del cliente

En los siguientes ejemplos se muestran las consultas equivalentes que solicita una página de las entidades de pedidos ordenados que incluye 25 pedidos, omitiendo los 50 primeros pedidos:

  • Aplicar métodos de consulta a una consulta LINQ:

    var pagedOrders = (from o in context.Orders
                          orderby o.OrderDate descending
                         select o).Skip(50).Take(25);
    
  • opciones $skip y $top de cadena de consulta de URI):

    var pagedOrders = context.Orders
        .AddQueryOption("$orderby", "OrderDate desc")
        .AddQueryOption("$skip", 50)
        .AddQueryOption("$top", 25);
    

Los dos ejemplos anteriores se traducen en el URI de la consulta: http://localhost:12345/northwind.svc/Orders()?$orderby=OrderDate desc&$skip=50&$top=25.

Expandir

Cuando se carga un servicio de datos de OData, puede solicitar que las entidades relacionadas con la entidad que sea el destino de la consulta se incluyan en la fuente devuelta. Se llama al método Expand(String) en la clase DataServiceQuery<TElement> para el conjunto de entidades que sean el destino de la consulta LINQ, con el nombre del conjunto de entidades relacionado proporcionado como el parámetro path. Para obtener más información, vea Cargar contenido aplazado (WCF Data Services).

En los siguientes ejemplos se muestran las formas equivalentes de usar el método Expand(String) en una consulta:

  • En la sintaxis de las consultas LINQ:

    var ordersQuery = from o in context.Orders.Expand("Order_Details")
                         where o.CustomerID == "ALFKI"
                         select o;
    
  • Con los métodos de consulta LINQ:

    var ordersQuery = context.Orders.Expand("Order_Details")
                      .Where(o => o.CustomerID == "ALFKI");
    

Los dos ejemplos anteriores se traducen en el URI de la consulta: http://localhost:12345/northwind.svc/Orders()?$filter=CustomerID eq 'ALFKI'&$expand=Order_Details.

La siguiente tabla contiene las clases de métodos LINQ que no se admiten y que no se pueden incluir en una consulta ejecutada en un servicio de OData:

Tipo de operación 

Métodos no admitidos

Operadores de conjuntos

No se admiten los siguientes operadores de conjuntos en DataServiceQuery<TElement>:

Operaciones de ordenación

No se admiten los siguientes operadores de ordenación que requieran la interfaz IComparer<T> en una clase DataServiceQuery<TElement>:

Métodos de proyección y filtrado

No se admiten ninguno de los siguientes operadores de proyección y filtrado que acepten un argumento posicional en una clase DataServiceQuery<TElement>:

Operadores de agrupación

No se admite ningún operador de agrupación en una clase DataServiceQuery<TElement>, que incluya lo siguiente:

Los operadores de agrupación se deben ejecutar en el cliente.

Operadores de agregación

No se admite ninguna operación de agregado en una clase DataServiceQuery<TElement>, que incluya lo siguiente:

Las operaciones de agregado se deben ejecutar en el cliente o las debe encapsular una operación de servicio.

Operadores de paginación

No se admiten los siguientes operadores de paginación en una clase DataServiceQuery<TElement>:

Nota Nota

Los operadores de paginación que se ejecuten en una secuencia vacía devuelven NULL.

Operadores adicionales

No se admiten los siguientes operadores adicionales en una clase DataServiceQuery<TElement>:

  1. Empty<TResult>

  2. Range

  3. Repeat<TResult>

  4. ToDictionary

  5. ToLookup

Se admiten los siguientes métodos y propiedades de Common Language Runtime (CLR) porque se pueden traducir en una expresión de consulta para su inclusión en el URI de solicitud en un servicio de OData:

Miembro de la clase String

Función de OData admitida

Concat

string concat(string p0, string p1)

Contains

bool substringof(string p0, string p1)

EndsWith

bool endswith(string p0, string p1)

IndexOf

int indexof(string p0, string p1)

Length

int length(string p0)

Replace

string replace(string p0, string find, string replace)

Substring

string substring(string p0, int pos)

Substring

string substring(string p0, int pos, int length)

ToLower

string tolower(string p0)

ToUpper

string toupper(string p0)

Trim

string trim(string p0)

Miembro de la estructura DateTime1

Función de OData admitida

Day

int day(DateTime p0)

Hour

int hour(DateTime p0)

Minute

int minute(DateTime p0)

Month

int month(DateTime p0)

Second

int second(DateTime p0)

Year

int year(DateTime p0)

1Las propiedades de fecha y hora equivalentes de la clase Microsoft.VisualBasic.DateAndTime, así como el método DatePart de Visual Basic también se admiten.

Miembro de Math

Función de OData admitida

Ceiling

decimal ceiling(decimal p0)

Ceiling

double ceiling(double p0)

Floor

decimal floor(decimal p0)

Floor

double floor(double p0)

Round

decimal round(decimal p0)

Round

double round(double p0)

Miembro de Expression

Función de OData admitida

TypeIs

bool isof(type p0)

Además, el cliente quizá pueda evaluar las funciones CLR adicionales en el cliente. Se produce una excepción NotSupportedException para cualquier expresión que no se pueda evaluar en el cliente y que no se pueda traducir en un URI de solicitud válido para su evaluación en el servidor.

La compatibilidad con LINQ tiene los siguientes requisitos de versiones del protocolo OData:

Para obtener más información, vea Control de versiones del servicio de datos (Servicios de datos de Microsoft WCF).

Adiciones de comunidad

AGREGAR
Mostrar: