Scrittura della prima query LINQ (Visual Basic)Writing Your First LINQ Query (Visual Basic)

Una query è un'espressione che recupera dati da un'origine dati.A query is an expression that retrieves data from a data source. Le query sono espresse in un linguaggio di query dedicato.Queries are expressed in a dedicated query language. Nel corso del tempo sono stati sviluppati linguaggi diversi per diversi tipi di origini dati, ad esempio SQL per i database relazionali e XQuery per XML.Over time, different languages have been developed for different types of data sources, for example, SQL for relational databases and XQuery for XML. Questo consente allo sviluppatore di applicazioni di apprendere un nuovo linguaggio di query per ogni tipo di origine dati o formato dati supportato.This makes it necessary for the application developer to learn a new query language for each type of data source or data format that is supported.

LINQ (Language-Integrated Query)Language-Integrated Query (LINQ)semplifica la situazione offrendo un modello coerente per l'utilizzo dei dati in diversi tipi di origini dati e formati.simplifies the situation by offering a consistent model for working with data across various kinds of data sources and formats. In una query LINQLINQ vengono sempre usati gli oggetti.In a LINQLINQ query, you are always working with objects. Si utilizzano gli stessi modelli di codifica di base per eseguire query e trasformare i dati in documenti XML, database SQL, set di dati ADO.NET ed entità, raccolte di .NET Framework e qualsiasi altra origine LINQLINQ o formato per cui è disponibile un provider.You use the same basic coding patterns to query and transform data in XML documents, SQL databases, ADO.NET datasets and entities, .NET Framework collections, and any other source or format for which a LINQLINQ provider is available. In questo documento vengono descritte le tre fasi della creazione e dell'utilizzo LINQLINQ di query di base.This document describes the three phases of the creation and use of basic LINQLINQ queries.

Tre fasi di un'operazione di queryThree Stages of a Query Operation

LINQLINQle operazioni di query sono costituite da tre azioni:query operations consist of three actions:

  1. Ottenere l'origine dati o le origini.Obtain the data source or sources.

  2. Creare la query.Create the query.

  3. Eseguire la query.Execute the query.

In LINQLINQl'esecuzione di una query è diversa dalla creazione della query.In LINQLINQ, the execution of a query is distinct from the creation of the query. Non è possibile recuperare i dati semplicemente creando una query.You do not retrieve any data just by creating a query. Questo punto viene illustrato più dettagliatamente di seguito in questo argomento.This point is discussed in more detail later in this topic.

Nell'esempio seguente vengono illustrate le tre parti di un'operazione di query.The following example illustrates the three parts of a query operation. Nell'esempio viene utilizzata una matrice di numeri interi come un'origine dati comoda a scopo dimostrativo.The example uses an array of integers as a convenient data source for demonstration purposes. Tuttavia, gli stessi concetti si applicano anche ad altre origini dati.However, the same concepts also apply to other data sources.

Nota

Nella pagina compilazione, Progettazione progetti (Visual Basic), assicurarsi che l' opzione deduce sia impostata su on.On the Compile Page, Project Designer (Visual Basic), ensure that Option infer is set to On.

' Data source.
Dim numbers() As Integer = {0, 1, 2, 3, 4, 5, 6}

' Query creation.
Dim evensQuery = From num In numbers
                 Where num Mod 2 = 0
                 Select num

' Query execution.
For Each number In evensQuery
    Console.Write(number & " ")
Next

Output:Output:

0 2 4 6

Origine datiThe Data Source

Poiché l'origine dati nell'esempio precedente è una matrice, supporta implicitamente l'interfaccia generica IEnumerable<T> .Because the data source in the previous example is an array, it implicitly supports the generic IEnumerable<T> interface. In questo modo è possibile utilizzare una matrice come origine dati per una LINQLINQ query.It is this fact that enables you to use an array as a data source for a LINQLINQ query. I tipi che supportano IEnumerable<T> o un'interfaccia derivata, ad esempio l'interfaccia generica IQueryable<T> sono denominati tipi queryable.Types that support IEnumerable<T> or a derived interface such as the generic IQueryable<T> are called queryable types.

Come tipo sottoposta a query in modo implicito, la matrice non richiede alcuna modifica o trattamento LINQLINQ speciale per fungere da origine dati.As an implicitly queryable type, the array requires no modification or special treatment to serve as a LINQLINQ data source. Lo stesso vale per qualsiasi tipo di raccolta che supporta IEnumerable<T>, incluse le classi List<T>generiche, Dictionary<TKey,TValue>e altre classi nella libreria di classi .NET Framework.The same is true for any collection type that supports IEnumerable<T>, including the generic List<T>, Dictionary<TKey,TValue>, and other classes in the .NET Framework class library.

Se i dati di origine non sono già IEnumerable<T>implementati LINQLINQ , è necessario un provider per implementare la funzionalità degli operatori di query standard per tale origine dati.If the source data does not already implement IEnumerable<T>, a LINQLINQ provider is needed to implement the functionality of the standard query operators for that data source. Ad esempio, LINQ to XMLLINQ to XML gestisce il lavoro di caricamento di un documento XML in un XElement tipo Queryable, come illustrato nell'esempio seguente.For example, LINQ to XMLLINQ to XML handles the work of loading an XML document into a queryable XElement type, as shown in the following example. Per ulteriori informazioni sugli operatori di query standard, vedere Cenni preliminari sugli operatori di query standard (Visual Basic).For more information about standard query operators, see Standard Query Operators Overview (Visual Basic).

' Create a data source from an XML document.
Dim contacts = XElement.Load("c:\myContactList.xml")

Con LINQ to SQLLINQ to SQLè prima di tutto necessario creare un mapping relazionale a oggetti in fase di progettazione, manualmente o usando gli strumenti LINQ to SQL in Visual Studio in Visual Studio.With LINQ to SQLLINQ to SQL, you first create an object-relational mapping at design time, either manually or by using the LINQ to SQL Tools in Visual Studio in Visual Studio. È possibile scrivere le query sugli oggetti e in fase di esecuzione LINQ to SQLLINQ to SQL gestisce la comunicazione con il database.You write your queries against the objects, and at run-time LINQ to SQLLINQ to SQL handles the communication with the database. Nell'esempio seguente, customers rappresenta una tabella specifica nel database e Table<TEntity> supporta Generic IQueryable<T>.In the following example, customers represents a specific table in the database, and Table<TEntity> supports generic IQueryable<T>.

' Create a data source from a SQL table.  
Dim db As New DataContext("C:\Northwind\Northwnd.mdf")  
Dim customers As Table(Of Customer) = db.GetTable(Of Customer)  

Per altre informazioni sulla creazione di tipi specifici di origini dati, vedere la documentazione dei diversi provider LINQLINQ.For more information about how to create specific types of data sources, see the documentation for the various LINQLINQ providers. Per un elenco di questi provider, vedere LINQ (Language-Integrated Query). La regola di base è semplice: LINQLINQ un'origine dati è qualsiasi oggetto che supporta l' IEnumerable<T> interfaccia generica o un'interfaccia che eredita da essa.(For a list of these providers, see LINQ (Language-Integrated Query).) The basic rule is simple: a LINQLINQ data source is any object that supports the generic IEnumerable<T> interface, or an interface that inherits from it.

Nota

I tipi, ArrayList ad esempio che supportano l'interfaccia IEnumerable non generica, possono essere LINQLINQ utilizzati anche come origini dati.Types such as ArrayList that support the non-generic IEnumerable interface can also be used as LINQLINQ data sources. Per un esempio che usa un ArrayList, vedere procedura: Eseguire una query su un ArrayList con LINQ (Visual Basic).For an example that uses an ArrayList, see How to: Query an ArrayList with LINQ (Visual Basic).

QueryThe Query

Nella query specificare le informazioni che si desidera recuperare dall'origine o dalle origini dati.In the query, you specify what information you want to retrieve from the data source or sources. È anche possibile specificare il modo in cui le informazioni devono essere ordinate, raggruppate o strutturate prima di essere restituite.You also have the option of specifying how that information should be sorted, grouped, or structured before it is returned. Per abilitare la creazione della query, Visual Basic ha incorporato una nuova sintassi di query nel linguaggio.To enable query creation, Visual Basic has incorporated new query syntax into the language.

Quando viene eseguita, la query nell'esempio seguente restituisce tutti i numeri pari da una matrice di interi, numbers.When it is executed, the query in the following example returns all the even numbers from an integer array, numbers.

' Data source.
Dim numbers() As Integer = {0, 1, 2, 3, 4, 5, 6}

' Query creation.
Dim evensQuery = From num In numbers
                 Where num Mod 2 = 0
                 Select num

' Query execution.
For Each number In evensQuery
    Console.Write(number & " ")
Next

L'espressione di query contiene tre clausole From: Where, e Select.The query expression contains three clauses: From, Where, and Select. La funzione e lo scopo specifici di ogni clausola di espressione di query sono illustrati in operazioni di query di base (Visual Basic).The specific function and purpose of each query expression clause is discussed in Basic Query Operations (Visual Basic). Per ulteriori informazioni, vedere query.For more information, see Queries. Si noti che LINQLINQin una definizione di query spesso è archiviata in una variabile ed eseguita in un secondo momento.Note that in LINQLINQ, a query definition often is stored in a variable and executed later. La variabile evensQuery di query, ad esempio nell'esempio precedente, deve essere un tipo Queryable.The query variable, such as evensQuery in the previous example, must be a queryable type. Il tipo di evensQuery è IEnumerable(Of Integer), assegnato dal compilatore usando l'inferenza del tipo locale.The type of evensQuery is IEnumerable(Of Integer), assigned by the compiler using local type inference.

È importante ricordare che la variabile di query non esegue alcuna azione e non restituisce alcun dato.It is important to remember that the query variable itself takes no action and returns no data. Archivia solo la definizione della query.It only stores the query definition. Nell'esempio precedente si tratta del For Each ciclo che esegue la query.In the previous example, it is the For Each loop that executes the query.

Esecuzione di queryQuery Execution

L'esecuzione della query è separata dalla creazione della query.Query execution is separate from query creation. La creazione della query definisce la query, ma l'esecuzione viene attivata da un meccanismo diverso.Query creation defines the query, but execution is triggered by a different mechanism. Una query può essere eseguita non appena viene definita (esecuzione immediata) oppure la definizione può essere archiviata e la query può essere eseguita in un secondo momento (esecuzione posticipata).A query can be executed as soon as it is defined (immediate execution), or the definition can be stored and the query can be executed later (deferred execution).

Esecuzione posticipataDeferred Execution

Una query LINQLINQ tipica è simile a quella dell'esempio precedente, in cui evensQuery è definito.A typical LINQLINQ query resembles the one in the previous example, in which evensQuery is defined. Consente di creare la query, ma non di eseguirla immediatamente.It creates the query but does not execute it immediately. Al contrario, la definizione della query viene archiviata nella evensQueryvariabile di query.Instead, the query definition is stored in the query variable evensQuery. Si esegue la query in un secondo momento, in For Each genere usando un ciclo, che restituisce una sequenza di valori o applicando un operatore di query standard Count , Maxad esempio o.You execute the query later, typically by using a For Each loop, which returns a sequence of values, or by applying a standard query operator, such as Count or Max. Questo processo viene definito esecuzione posticipata.This process is referred to as deferred execution.

' Query execution that results in a sequence of values.
For Each number In evensQuery
    Console.Write(number & " ")
Next

' Query execution that results in a single value.
Dim evens = evensQuery.Count()

Per una sequenza di valori, è possibile accedere ai dati recuperati usando la variabile di iterazione For Each nelnumber ciclo (nell'esempio precedente).For a sequence of values, you access the retrieved data by using the iteration variable in the For Each loop (number in the previous example). Poiché la variabile di query evensQuery,, include la definizione della query anziché i risultati della query, è possibile eseguire una query con la frequenza desiderata utilizzando la variabile di query più di una volta.Because the query variable, evensQuery, holds the query definition rather than the query results, you can execute a query as often as you want by using the query variable more than one time. È ad esempio possibile che nell'applicazione sia presente un database che viene aggiornato continuamente da un'applicazione separata.For example, you might have a database in your application that is being updated continually by a separate application. Dopo aver creato una query che recupera i dati dal database, è possibile utilizzare un For Each ciclo per eseguire ripetutamente la query, recuperando i dati più recenti ogni volta.After you have created a query that retrieves data from that database, you can use a For Each loop to execute the query repeatedly, retrieving the most recent data every time.

Nell'esempio seguente viene illustrato il funzionamento dell'esecuzione posticipata.The following example demonstrates how deferred execution works. Dopo evensQuery2 che è stato definito ed eseguito For Each con un ciclo, come negli esempi precedenti, alcuni elementi nell'origine numbers dati vengono modificati.After evensQuery2 is defined and executed with a For Each loop, as in the previous examples, some elements in the data source numbers are changed. Quindi, un For Each secondo ciclo evensQuery2 viene eseguito nuovamente.Then a second For Each loop runs evensQuery2 again. I risultati sono diversi la seconda volta, perché il For Each ciclo esegue nuovamente la query, usando i nuovi valori in. numbersThe results are different the second time, because the For Each loop executes the query again, using the new values in numbers.

Dim numberArray() = {0, 1, 2, 3, 4, 5, 6}

Dim evensQuery2 = From num In numberArray
                  Where num Mod 2 = 0
                  Select num

Console.WriteLine("Evens in original array:")
For Each number In evensQuery2
    Console.Write("  " & number)
Next
Console.WriteLine()

' Change a few array elements.
numberArray(1) = 10
numberArray(4) = 22
numberArray(6) = 8

' Run the same query again.
Console.WriteLine(vbCrLf & "Evens in changed array:")
For Each number In evensQuery2
    Console.Write("  " & number)
Next
Console.WriteLine()

Output:Output:

Evens in original array:

0 2 4 6

Evens in changed array:

0 10 2 22 8

Esecuzione immediataImmediate Execution

Nell'esecuzione posticipata delle query, la definizione della query viene archiviata in una variabile di query per un'esecuzione successiva.In deferred execution of queries, the query definition is stored in a query variable for later execution. Nell'esecuzione immediata la query viene eseguita al momento della relativa definizione.In immediate execution, the query is executed at the time of its definition. L'esecuzione viene attivata quando si applica un metodo che richiede l'accesso ai singoli elementi del risultato della query.Execution is triggered when you apply a method that requires access to individual elements of the query result. L'esecuzione immediata viene spesso forzata utilizzando uno degli operatori di query standard che restituiscono valori singoli.Immediate execution often is forced by using one of the standard query operators that return single values. Gli esempi Countsono Max ,Average, e First.Examples are Count, Max, Average, and First. Questi operatori di query standard eseguono la query non appena vengono applicati per calcolare e restituire un risultato singleton.These standard query operators execute the query as soon as they are applied in order to calculate and return a singleton result. Per ulteriori informazioni sugli operatori di query standard che restituiscono valori singoli, vedere operazioni di aggregazione, operazioni sugli elementie operazioni del quantificatore.For more information about standard query operators that return single values, see Aggregation Operations, Element Operations, and Quantifier Operations.

La query seguente restituisce un conteggio dei numeri pari in una matrice di numeri interi.The following query returns a count of the even numbers in an array of integers. La definizione della query non viene salvata numEvens ed è un Integersemplice.The query definition is not saved, and numEvens is a simple Integer.

Dim numEvens = (From num In numbers
                Where num Mod 2 = 0
                Select num).Count()

È possibile ottenere lo stesso risultato usando il Aggregate metodo.You can achieve the same result by using the Aggregate method.

Dim numEvensAgg = Aggregate num In numbers
                  Where num Mod 2 = 0
                  Select num
                  Into Count()

È anche possibile forzare l'esecuzione di una query chiamando ToList il ToArray metodo o su una query (immediate) o su una variabile di query (rinviata), come illustrato nel codice seguente.You can also force execution of a query by calling the ToList or ToArray method on a query (immediate) or query variable (deferred), as shown in the following code.

' Immediate execution.
Dim evensList = (From num In numbers
                 Where num Mod 2 = 0
                 Select num).ToList()

' Deferred execution.
Dim evensQuery3 = From num In numbers
                  Where num Mod 2 = 0
                  Select num
' . . .
Dim evensArray = evensQuery3.ToArray()

Negli esempi precedenti, evensQuery3 è una variabile di query, ma evensList è un elenco ed evensArray è una matrice.In the previous examples, evensQuery3 is a query variable, but evensList is a list and evensArray is an array.

L' ToList utilizzo ToArray di o per forzare l'esecuzione immediata è particolarmente utile negli scenari in cui si desidera eseguire immediatamente la query e memorizzare nella cache i risultati in un singolo oggetto raccolta.Using ToList or ToArray to force immediate execution is especially useful in scenarios in which you want to execute the query immediately and cache the results in a single collection object. Per ulteriori informazioni su questi metodi, vedere conversione di tipi di dati.For more information about these methods, see Converting Data Types.

È anche possibile causare l'esecuzione di una query usando un IEnumerable metodo come il IEnumerable.GetEnumerator metodo.You can also cause a query to be executed by using an IEnumerable method such as the IEnumerable.GetEnumerator method.

Vedere ancheSee also