Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Considerazioni su LINQ (WCF Data Services)

In questo argomento vengono fornite informazioni sulla modalità con cui le query LINQ vengono composte ed eseguite quando si utilizza il client WCF Data Services e sulle limitazioni dell'utilizzo di LINQ per eseguire una query su un servizio dati che implementa Protocollo OData (Open Data). Per ulteriori informazioni sulla composizione ed esecuzione di query per un servizio dati basato su OData, vedere Esecuzione di query sul servizio dati (WCF Data Services).

LINQ consente di comporre query per una raccolta di oggetti che implementa IEnumerable<T>. La finestra di dialogo Aggiungi riferimento al servizio in Visual Studio e lo strumento DataSvcUtil.exe sono utilizzati per generare la rappresentazione di un servizio OData come classe di contenitore di entità che eredita da DataServiceContext e gli oggetti che rappresentano le entità restituite nei feed. Questi strumenti generano anche le proprietà per la classe contenitore di entità delle raccolte esposte come feed dal servizio. Ognuna di queste proprietà della classe che incapsula il servizio dati restituisce un elemento DataServiceQuery<TElement>. Dal momento che la classe DataServiceQuery<TElement> implementa l'interfaccia IQueryable<T> definita da LINQ, è possibile comporre una query LINQ per i feed esposti dal servizio dati che vengono convertiti dalla libreria client in un URI di richiesta query inviato al servizio dati in esecuzione.

Nota importante Importante

La sintassi LINQ consente di esprimere un set di query più ampio di quello consentito dalla sintassi URI utilizzata dai servizi dati OData. Quando non è possibile eseguire il mapping della query a un URI nel servizio dati di destinazione, viene generato un oggetto NotSupportedException. Per ulteriori informazioni, vedere Metodi non supportati di LINQ in questo argomento.

Nell'esempio seguente viene riportata una query LINQ che restituisce Orders con un costo di spedizione maggiore di 30 dollari e ordina i risultati in base alla data di spedizione, partendo da quella più recente:


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


Questa query LINQ viene convertita nel seguente URI di query che viene eseguito sul servizio dati Guida rapida basato su Northwind:

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

Per informazioni generali su LINQ, vedere LINQ (Language-Integrated Query).

LINQ consente di comporre query tramite la sintassi di query dichiarativa specifica della lingua, mostrata nell'esempio precedente, e un set di metodi di query noti come operatori di query standard. Una query equivalente a quella dell'esempio precedente può essere composta solo tramite la sintassi basata sul metodo, come indicato nell'esempio seguente:


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


Il client WCF Data Services è in grado di convertire entrambi tipi di query composte in un URI di query ed è possibile estendere una query LINQ aggiungendo i metodi di query a un'espressione di query. Quando si compongono query LINQ aggiungendo la sintassi del metodo a un'espressione di query o un elemento DataServiceQuery<TElement>, le operazioni vengono aggiunte all'URI della query nell'ordine di chiamata dei metodi. Equivale alla chiamata del metodo AddQueryOption per aggiungere ogni opzione di query all'URI della query.

Alcuni metodi di query LINQ, ad esempio First<TSource>(IEnumerable<TSource>) o Single<TSource>(IEnumerable<TSource>), quando vengono aggiunti alla query ne causano l'esecuzione. Una query viene eseguita anche quando i risultati vengono enumerati in modo implicito, ad esempio durante un ciclo foreach o quando la query è assegnata a una raccolta List. Per ulteriori informazioni, vedere Esecuzione di query sul servizio dati (WCF Data Services).

Il client esegue una query LINQ in due parti. Ogni qualvolta possibile, le espressioni LINQ di una query vengono prima valutate sul client e quindi viene generata una query basata sull'URI che viene inviata al servizio dati per la valutazione rispetto ai dati del servizio. Per ulteriori informazioni, vedere la sezione Esecuzione del client e del server in Esecuzione di query sul servizio dati (WCF Data Services).

Quando non è possibile convertire una query LINQ in un URI di query conforme a OData, viene generata un'eccezione quando viene tentata l'esecuzione. Per ulteriori informazioni, vedere Esecuzione di query sul servizio dati (WCF Data Services).

Negli esempi delle sezioni seguenti vengono illustrati i tipi di query LINQ che possono essere eseguiti su un servizio OData.

Ee622463.collapse_all(it-it,VS.110).gifFiltro

Negli esempi di query LINQ in questa sezione vengono filtrati i dati nel feed restituito dal servizio.

Negli esempi seguenti vengono illustrate query equivalenti che filtrano le entità Orders restituite in modo che vengano restituiti solo gli ordini con un costo di spedizione maggiore di $30:

  • Uso della sintassi di query LINQ:

    
    var filteredOrders = from o in context.Orders
                            where o.Freight > 30
                            select o;
    
    
    
  • Uso dei metodi di query LINQ:

    
    var filteredOrders = context.Orders
        .Where(o => o.Freight > 30);
    
    
    
  • Opzione $filter della stringa di query:

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

Tutti gli esempi precedenti vengono convertiti nell'URI di query: http://localhost:12345/northwind.svc/Orders()?$filter=Freight gt 30M.

Ee622463.collapse_all(it-it,VS.110).gifOrdinamento

Negli esempi seguenti vengono illustrate query equivalenti che ordinano i dati restituiti in base al nome dell'azienda e al codice postale, in ordine decrescente:

  • Uso della sintassi di query LINQ:

    
    var sortedCustomers = from c in context.Customers
                         orderby c.CompanyName ascending, 
                         c.PostalCode descending
                         select c;
    
    
    
  • Uso dei metodi di query LINQ:

    
    var sortedCustomers = context.Customers.OrderBy(c => c.CompanyName)
        .ThenByDescending(c => c.PostalCode);
    
    
    
  • Opzione $orderby della stringa di query:

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

Tutti gli esempi precedenti vengono convertiti nell'URI di query: http://localhost:12345/northwind.svc/Customers()?$orderby=CompanyName,PostalCode desc.

Ee622463.collapse_all(it-it,VS.110).gifProiezione

Negli esempi seguenti vengono illustrate query equivalenti che ordinano i dati restituiti dal progetto nel tipo CustomerAddress più ristretto:

  • Uso della sintassi di query 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
                };
    
    
    
  • Uso dei metodi di query 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

L'opzione di query $select non può essere aggiunta a un URI di query tramite il metodo AddQueryOption. Si consiglia di utilizzare il metodo LINQ Select in modo che il client generi l'opzione di query $select nell'URI della richiesta.

Entrambi gli esempi precedenti vengono convertiti nell'URI di query: "http://localhost:12345/northwind.svc/Customers()?$filter=Country eq 'GerGerm'&$select=CustomerID,Address,City,Region,PostalCode,Country".

Ee622463.collapse_all(it-it,VS.110).gifPaging del client

Negli esempi seguenti vengono illustrate query equivalenti che richiedono una pagina delle entità ordinate che include 25 ordini, ignorando i primi 50 ordini:

  • Applicazione di metodi di query a una query LINQ:

    
    var pagedOrders = (from o in context.Orders
                          orderby o.OrderDate descending
                         select o).Skip(50).Take(25);
    
    
    
  • Opzioni $skip e $top della stringa di query dell'URI:

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

Entrambi gli esempi precedenti vengono convertiti nell'URI di query: http://localhost:12345/northwind.svc/Orders()?$orderby=OrderDate desc&$skip=50&$top=25.

Ee622463.collapse_all(it-it,VS.110).gifEspansione

Quando si esegue una query su un servizio dati OData, è possibile richiedere che le entità relative all'entità di destinazione della query siano incluse nel feed restituito. Il metodo Expand viene chiamato su DataServiceQuery<TElement> per il set di entità indirizzato dalla query LINQ, con il relativo nome del set di entità fornito come parametro path. Per ulteriori informazioni, vedere Caricamento di contenuto posticipato (WCF Data Services).

Negli esempi seguenti vengono mostrate modalità equivalenti per utilizzare il metodo Expand in una query:

  • Nella sintassi della query LINQ:

    
    var ordersQuery = from o in context.Orders.Expand("Order_Details")
                         where o.CustomerID == "ALFKI"
                         select o;
    
    
    
  • Con i metodi di query LINQ:

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

Entrambi gli esempi precedenti vengono convertiti nell'URI di query: http://localhost:12345/northwind.svc/Orders()?$filter=CustomerID eq 'ALFKI'&$expand=Order_Details.

Nella tabella seguente sono riportate le classi dei metodi LINQ non supportati che non possono essere incluse in una query eseguita su un servizio OData:

Tipo di operazione 

Metodo non supportato

Operatori di impostazione

Tutti gli operatori di impostazione non sono supportati con DataServiceQuery<TElement>, compresi quelli indicati di seguito:

Operatori di ordinamento

Gli operatori di ordinamento seguenti che richiedono IComparer<T> non sono supportati con DataServiceQuery<TElement>:

Operatori di proiezione e di filtro

I seguenti operatori di proiezione e filtro che accettano un argomento posizionale non sono supportati con DataServiceQuery<TElement>:

Operatori di raggruppamento

Tutti gli operatori di raggruppamento non sono supportati con DataServiceQuery<TElement>, compresi quelli indicati di seguito:

È necessario eseguire le operazioni di raggruppamento sul client.

Operatori di aggregazione

Tutti gli operatori di aggregazione non sono supportati con DataServiceQuery<TElement>, compresi quelli indicati di seguito:

Le operazioni di aggregazione devono essere eseguite sul client o devono essere incapsulate da un'operazione del servizio.

Operatori di paging

Gli operatori di paging seguenti non sono supportati con DataServiceQuery<TElement>:

Nota Nota
Gli operatori di paging eseguiti in una sequenza vuota restituiscono Null.

Altri operatori

Gli operatori seguenti non sono supportati con DataServiceQuery<TElement>:

  1. Empty<TResult>

  2. Range

  3. Repeat<TResult>

  4. ToDictionary

  5. ToLookup

Le proprietà e i metodi Common Language Runtime (CLR) riportati di seguito sono supportati perché possono essere convertiti in un'espressione di query per l'inclusione nell'URI della richiesta a un servizio OData:

Membro String

Funzione OData supportata

Concat(String, String)

string concat(string p0, string p1)

Contains(String)

bool substringof(string p0, string p1)

EndsWith(String)

bool endswith(string p0, string p1)

IndexOf(String, Int32)

int indexof(string p0, string p1)

Length

int length(string p0)

Replace(String, String)

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

Substring(Int32)

string substring(string p0, int pos)

Substring(Int32, Int32)

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

ToLower()

string tolower(string p0)

ToUpper()

string toupper(string p0)

Trim()

string trim(string p0)

Membro1DateTime

Funzione OData supportata

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)

1In Visual Basic sono supportate anche le proprietà equivalenti di data e ora di Microsoft.VisualBasic.DateAndTime, nonché il metodo DatePart.

Membro Math

Funzione OData supportata

Ceiling(Decimal)

decimal ceiling(decimal p0)

Ceiling(Double)

double ceiling(double p0)

Floor(Decimal)

decimal floor(decimal p0)

Floor(Double)

double floor(double p0)

Round(Decimal)

decimal round(decimal p0)

Round(Double)

double round(double p0)

Membro Expression

Funzione OData supportata

TypeIs(Expression, Type)

bool isof(type p0)

È possibile che il client sia anche in grado di valutare funzioni CLR aggiuntive sul client. Viene generata un'eccezione NotSupportedException per qualsiasi espressione che non può essere valutata sul client e non può essere convertita in un URI della richiesta valido per la valutazione sul server.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft