Metodi del generatore di query (Entity Framework)

La classe ObjectQuery supporta sia query LINQ to Entities che Entity SQL su un modello concettuale. ObjectQuery implementa inoltre un set di metodi del generatore di query che è possibile utilizzare per creare in modo sequenziale comandi di query equivalenti a Entity SQL . Di seguito sono illustrati i metodi del generatore di query di ObjectQuery, con le istruzioni Entity SQL equivalenti:

Ogni metodo del generatore query restituisce una nuova istanza di ObjectQuery. In questo modo, è possibile costruire una query il cui set di risultati è basato sulle operazioni della sequenza delle istanze precedenti di ObjectQuery. Nell'esempio riportato di seguito viene illustrato come utilizzare il metodo Where per filtrare gli oggetti Product restituiti in base a ProductID.

' Return Product objects with the specified ID. 
Dim query As ObjectQuery(Of Product) = context.Products.Where("it.ProductID = @product", New ObjectParameter("product", productId))

// Return Product objects with the specified ID.
ObjectQuery<Product> query =
    context.Products
    .Where("it.ProductID = @product",
    new ObjectParameter("product", productId));

Poiché un oggetto ObjectQuery implementa IQueryable e IEnumerable, è possibile combinare i metodi del generatore di query implementati da ObjectQuery con i metodi degli operatori di query standard specifici di LINQ, come First o Count. A differenza dei metodi del generatore di query, gli operatori LINQ non restituiscono un oggetto ObjectQuery. Per ulteriori informazioni, vedere l'argomento Cenni preliminari sugli operatori di query standard nella documentazione di Visual Studio 2008.

Selezione di dati

Per impostazione predefinita, ObjectQuery restituisce zero o più oggetti entità di un tipo specifico. La chiamata a metodi di query successivi, come Where e OrderBy, influisce sulla raccolta di oggetti restituiti dall'oggetto ObjectQuery originale. Alcuni metodi, ad esempio Select e GroupBy, restituiscono una proiezione dei dati sotto forma di un oggetto DbDataRecord anziché un tipo di entità. Per ulteriori informazioni, vedere Query di oggetto (Entity Framework). Nell'esempio seguente viene restituita una raccolta di oggetti DbDataRecord contenenti tipi di entità SalesOrderHeader annidati.

' Define a query that returns a nested 
' DbDataRecord for the projection. 
Dim query As ObjectQuery(Of DbDataRecord) = context.Contacts.Select("it.FirstName, it.LastName, it.SalesOrderHeaders") _
                                            .Where("it.LastName = @ln", New ObjectParameter("ln", lastName))

// Define a query that returns a nested 
// DbDataRecord for the projection.
ObjectQuery<DbDataRecord> query =
    context.Contacts.Select("it.FirstName, "
        + "it.LastName, it.SalesOrderHeaders")
    .Where("it.LastName = @ln", new ObjectParameter("ln", lastName));

Anche se i metodi del generatore di query vengono applicati in sequenza, è possibile costruire lo stesso tipo di sottoquery annidate supportate da Entity SQL . A tale scopo, è necessario includere la sottoquery come tipo Entity SQL nel metodo. Nell'esempio seguente viene utilizzata una sottoquery Entity SQL SELECT nel metodo Select per includere record LastName annidati in un set di risultati e ordinati alfabeticamente in base alla prima lettera del cognome:

' Define the query with a GROUP BY clause that returns 
' a set of nested LastName records grouped by first letter. 
Dim query As ObjectQuery(Of DbDataRecord) = _
    context.Contacts.GroupBy("SUBSTRING(it.LastName, 1, 1) AS ln", "ln") _
    .Select("it.ln AS ln, (SELECT c1.LastName FROM AdventureWorksEntities.Contacts AS c1 " & _
            "WHERE SubString(c1.LastName, 1, 1) = it.ln) AS CONTACT").OrderBy("it.ln")

// Define the query with a GROUP BY clause that returns
// a set of nested LastName records grouped by first letter.
ObjectQuery<DbDataRecord> query =
    context.Contacts
    .GroupBy("SUBSTRING(it.LastName, 1, 1) AS ln", "ln")
    .Select("it.ln AS ln, (SELECT c1.LastName " +
    "FROM AdventureWorksEntities.Contacts AS c1 " +
    "WHERE SubString(c1.LastName, 1, 1) = it.ln) AS CONTACT")
    .OrderBy("it.ln");

Nota:
Utilizzare il metodo ToTraceString per vedere il comando sull'origine dati che verrà generato da ObjectQuery.Per ulteriori informazioni, vedere Query di oggetto (Entity Framework).

Alias

I metodi del generatore di query vengono applicati in sequenza per costruire un comando di query cumulativo. Ciò significa che il comando ObjectQuery corrente viene trattato come una sottoquery a cui è applicato il metodo corrente.

Nota:
La proprietà CommandText restituisce il comando per l'istanza di ObjectQuery.

In un metodo del generatore di query è possibile fare riferimento al comando ObjectQuery corrente utilizzando un alias. Per impostazione predefinita, la stringa "it" è l'alias che rappresenta il comando corrente, come nell'esempio seguente:

' Return Product objects with a standard cost 
' above 10 dollars. 
Dim cost = 10
Dim productQuery As ObjectQuery(Of Product) = context.Products.Where("it.StandardCost > @cost")
productQuery.Parameters.Add(New ObjectParameter("cost", cost))

int cost = 10;
// Return Product objects with a standard cost
// above 10 dollars.
ObjectQuery<Product> productQuery =
    context.Products
    .Where("it.StandardCost > @cost", new ObjectParameter("cost", cost));

Quando si imposta la proprietà Name di un oggetto ObjectQuery, tale valore diventa l'alias nei metodi successivi. Nell'esempio seguente viene esteso l'esempio precedente impostando il nome di ObjectQuery su "product", quindi utilizzando questo alias nel metodo OrderBy successivo:

' Return Product objects with a standard cost 
' above 10 dollars. 
Dim cost = 10
Dim productQuery As ObjectQuery(Of Product) = context.Products.Where("it.StandardCost > @cost")
productQuery.Parameters.Add(New ObjectParameter("cost", cost))

' Set the Name property for the query and then 
' use that name as the alias in the subsequent 
' OrderBy method. 
productQuery.Name = "product"
Dim filteredProduct As ObjectQuery(Of Product) = productQuery.OrderBy("product.ProductID")

int cost = 10;
// Return Product objects with a standard cost
// above 10 dollars.
ObjectQuery<Product> productQuery =
    context.Products
    .Where("it.StandardCost > @cost", new ObjectParameter("cost", cost));

// Set the Name property for the query and then 
// use that name as the alias in the subsequent 
// OrderBy method.
productQuery.Name = "product";
ObjectQuery<Product> filteredProduct = productQuery
    .OrderBy("product.ProductID");

Parametri

Tutti i metodi del generatore di query che accettano un input di tipo stringa Entity SQL supportano anche le query con parametri. I nomi dei parametri in Entity SQL sono definiti nelle espressioni di query con il simbolo chiocciola (@) come prefisso. Per ulteriori informazioni, vedere Parametri (Entity SQL). I parametri vengono passati ai metodi del generatore di query come matrice delle istanze di ObjectParameter. Nell'esempio seguente vengono passati due parametri al metodo Where:

' Get the contacts with the specified name. 
Dim contactQuery As ObjectQuery(Of Contact) = context.Contacts.Where("it.LastName = @ln AND it.FirstName = @fn", _
                                                 New ObjectParameter("ln", lastName), New ObjectParameter("fn", firstName))

// Get the contacts with the specified name.
ObjectQuery<Contact> contactQuery = context.Contacts
    .Where("it.LastName = @ln AND it.FirstName = @fn",
    new ObjectParameter("ln", lastName),
    new ObjectParameter("fn", firstName));

Considerazioni sull'utilizzo dei parametri

Le considerazioni seguenti riguardano l'utilizzo dei parametri con i metodi del generatore di query:

• I parametri passati ai metodi del generatore di query vengono aggregati dalle istanze successive di ObjectQuery nella sequenza. È possibile accedere ai parametri utilizzando la proprietà Parameters. Dopo essere stati aggiunti, i parametri possono essere rimossi dalla raccolta e la raccolta può essere cancellata, a condizione che la query non sia stata compilata o eseguita. I nomi dei parametri non possono essere modificati, ma è possibile cambiare i valori in qualsiasi momento.

• I parametri devono essere univoci in ObjectParameterCollection. Nella raccolta non possono essere presenti due parametri con lo stesso nome.

• Quando si utilizzano i metodi di composizione, ad esempio Union, UnionAll, Intersect e Except, le raccolte di parametri vengono unite. Quando le raccolte di parametri sono incompatibili o incompleti oppure quando è presente lo stesso nome nelle raccolte di parametri di entrambe le query viene generata un'eccezione.

Vedere anche

Concetti

Esecuzione di query su un modello concettuale (Entity Framework)
Caricamento di oggetti correlati (Entity Framework)