Introduzione a LINQ in Visual Basic

Articolo
09/12/2008

Aggiornamento: novembre 2007

Language-Integrated Query (LINQ) aggiunge funzionalità di query a Visual Basic e fornisce semplici e potenti funzionalità da utilizzare con qualsiasi tipo di dati. Anziché inviare una query a un database da elaborare, o utilizzare sintassi di query differenti per ogni tipo di dati da ricercare, LINQ introduce le query come parti del linguaggio Visual Basic. Utilizza una sintassi unificata indipendentemente dal tipo di dati.

LINQ consente di eseguire query su dati in un database SQL Server, XML, matrici e insiemi in memoria, dataset ADO.NET o qualsiasi altra origine dati remota o locale che supporta LINQ. È possibile fare tutto per questo con i comuni elementi del linguaggio Visual Basic. Poiché le query sono scritte in Visual Basic, i risultati vengono restituiti come oggetti fortemente tipizzati. Questi oggetti supportano IntelliSense, il che consente di scrivere il codice più velocemente e di individuare errori nelle query in fase di compilazione anziché in fase di esecuzione. Le query LINQ possono essere utilizzate come origine di query aggiuntive per perfezionare i risultati. Possono anche venire associate a controlli in modo che gli utenti possano facilmente visualizzare e modificare i risultati della query.

Nell'esempio di codice seguente viene illustrata una query LINQ che restituisce un elenco di clienti da un insieme e li raggruppa in base alla località.

Dim customers As List(Of Customer) = GetCustomerList()

Dim customersByCountry = From cust In customers _
                         Order By cust.Country, cust.City _
                         Group By CountryName = cust.Country _
                         Into RegionalCustomers = Group, Count() _
                         Order By CountryName

For Each country In customersByCountry
  Console.WriteLine(country.CountryName & _
                    " (" & country.Count & ")" & vbCrLf)

  For Each customer In country.RegionalCustomers
    Console.WriteLine(vbTab & customer.CompanyName & _
                      " (" & customer.City & ")")
  Next
Next

In questo argomento, vengono fornite informazioni relative alle aree seguenti:

Provider LINQ
Struttura di una query LINQ
Operatori di query LINQ di Visual Basic
Connessione a un database utilizzando LINQ to SQL
Funzionalità di Visual Basic che supportano LINQ
Esecuzione query posticipata e immediata
XML in Visual Basic
Risorse correlate
Procedure e procedure dettagliate

Provider LINQ

Un provider LINQ Visual Basic esegue il mapping di query LINQ sull'origine dati su cui eseguire una query. Quando si scrive una query LINQ, il provider prende tale query e la traduce in comandi che l'origine dati sarà in grado di eseguire. Il provider converte anche i dati dall'origine negli oggetti che costituiscono il risultato della query. Infine, converte gli oggetti in dati quando si inviano aggiornamenti all'origine dati.

Visual Basic include i seguenti provider LINQ:

LINQ to Objects
Il provider LINQ to Objects consente di eseguire una query su insiemi e matrici in memoria. Se un oggetto supporta l'interfaccia IEnumerable o IEnumerable<T>, il provider LINQ to Objects consente di eseguire una query su di esso.

È possibile attivare il provider LINQ to Objects importando lo spazio dei nomi System.Linq, che viene importato per impostazione predefinita per ogni progetto Visual Basic.

Per ulteriori informazioni sul provider LINQ to Objects, vedere LINQ to Objects.
LINQ to SQL
Il provider LINQ to SQL consente di eseguire query e di modificare i dati su un database SQL server. Questo semplifica il mapping del modello a oggetti per un'applicazione alle tabelle e agli oggetti in un database.

Visual Basic semplifica l'utilizzo di LINQ to SQL includendo la Progettazione relazionale oggetti. Questa finestra di progettazione viene utilizzata per creare un modello a oggetti in un'applicazione che consente di eseguire il mapping agli oggetti in un database. La Progettazione relazionale oggetti permette inoltre di eseguire il mapping di stored procedure e offre funzioni all'oggetto DataContext che consente di gestire la comunicazione con il database e di archiviare le informazioni di stato per i controlli di concorrenza ottimistica.

Per ulteriori informazioni sul provider LINQ to SQL, vedere LINQ to SQL. Per ulteriori informazioni su Progettazione relazionale oggetti, vedere Progettazione relazionale oggetti.
LINQ to XML
Il provider LINQ to XML consente di eseguire query e di modificare l'XML. È possibile modificare XML in memoria oppure caricare l'XML da file o salvare l'XML in un file.

Inoltre il provider LINQ to XML abilita i valori letterali XML e le proprietà axis XML che consentono di scrivere direttamente l'XML nel codice Visual Basic. Per ulteriori informazioni, vedere XML in Visual Basic.
Da LINQ a DataSet
Il provider LINQ to DataSet consente di eseguire query e di aggiornare dati su un dataset ADO.NET. È possibile aggiungere le caratteristiche avanzate di LINQ ad applicazioni che utilizzano i dataset per semplificare ed estendere le funzionalità per l'esecuzione di query, l'aggregazione e l'aggiornamento dei dati nel dataset.

Per ulteriori informazioni, vedere LINQ to DataSet.

Struttura di una query LINQ

Una query LINQ, spesso definita espressione di queryè costituita da una combinazione di clausole di query che identificano le origini dati e le variabili di iterazione per la query. Un'espressione di query può includere anche istruzioni per ordinare, filtrare, raggruppare e unire, o eseguire calcoli sui dati di origine. La sintassi delle espressioni di query è simile alla sintassi SQL; pertanto, gran parte della sintassi risulterà familiare.

Un'espressione di query inizia con la clausola From. Questa clausola identifica i dati di origine per una query e le variabili utilizzate per fare riferimento a ogni elemento dell'insieme di origine. Queste variabili sono denominate variabili di intervallo o variabili di iterazione. La clausola From è obbligatoria per una query, tranne che per le query Aggregate in cui la clausola From è facoltativa. Dopo che l'ambito e origine della query sono identificate nelle clausole From o Aggregate, è possibile includere qualsiasi combinazione di clausole query per perfezionare la query. Per dettagli sulle clausole query, vedere Operatori di query di Visual Basic più avanti in questo argomento. Ad esempio, nella query seguente viene identificato un insieme di origine di dati cliente come variabile customers e una variabile di iterazione denominata cust.

Dim queryResults = From cust In customers _
                   Select cust.CompanyName

In questo esempio viene illustrata una query valida; tuttavia, la query diviene molto più efficace quando si aggiungono altre clausole di query per perfezionare il risultato. Ad esempio, è possibile aggiungere una clausola Where per filtrare il risultato per uno o più valori. Le espressioni di query consistono in una sola riga di codice; è possibile aggiungere solo clausole aggiuntive alla fine della query. È possibile suddividere una query su più righe del testo per migliorarne la leggibilità utilizzando il carattere di continuazione della riga: segno di sottolineatura (_). Nell'esempio di codice seguente viene illustrato un esempio di query che include una clausola Where.

Dim queryResults = From cust In customers _
                   Where cust.Country = "USA"

Un'altra efficace clausola di query è Select, che consente di restituire dall'origine dati solo i campi selezionati. Le query LINQ restituiscono insiemi enumerabili di oggetti fortemente tipizzati. Una query può restituire un insieme di tipi anonimi o tipi denominati. È possibile utilizzare la clausola Select per restituire solo un unico campo dall'origine dati. In questo caso, il tipo dell'insieme restituito è il tipo di quell'unico campo. È possibile utilizzare la clausola Select per restituire più campi dall'origine dati. In questo caso, il tipo dell'insieme restituito è un nuovo tipo anonimo. È anche possibile far corrispondere i campi restituiti dalla query ai campi di un tipo denominato specificato. Nell'esempio di codice seguente viene illustrata un'espressione di query che restituisce un insieme di tipi anonimi che hanno membri popolati con dati dai campi selezionati dell'origine dati.

Dim queryResults = From cust In customers _
               Where cust.Country = "USA" _
               Select cust.CompanyName, cust.Country

Le query LINQ possono essere utilizzate anche per combinare più origini di dati e restituire un unico risultato. Questa operazione può essere eseguita con una o più clausole From o utilizzando le clausole query Join o Group Join. Nell'esempio di codice seguente viene illustrata un'espressione di query che combina dati del cliente e dell'ordine e restituisce un insieme di tipi anonimi che contengono dati del cliente e dell'ordine.

Dim queryResults = From cust In customers, ord In orders _
                   Where cust.CustomerID = ord.CustomerID _
                   Select cust, ord

È possibile utilizzare la clausola Group Join per creare un risultato della query gerarchico che contiene un insieme di oggetti cliente. Ogni oggetto cliente ha una proprietà che contiene un insieme di tutti gli ordini per quel cliente. Nell'esempio di codice seguente viene illustrata un'espressione di query che combina dati del cliente e dell'ordine in un risultato gerarchico e restituisce un insieme di tipi anonimi. La query restituisce un tipo che include una proprietà CustomerOrders che contiene un insieme di dati ordine per tale cliente. Include anche una proprietà OrderTotal che contiene la somma dei totali per tutti gli ordini per quel cliente. (Questa query è equivalente a una query LEFT OUTER JOIN).

Dim queryResults = From cust In customers _
                   Group Join ord In orders On _
                     cust.CustomerID Equals ord.CustomerID _
                     Into CustomerOrders = Group, _
                          OrderTotal = Sum(ord.Total) _
                   Select cust.CompanyName, cust.CustomerID, _
                          CustomerOrders, OrderTotal

Esistono molti altri operatori di query LINQ che è possibile utilizzare per creare efficaci espressioni di query. Nella prossima sezione di questo argomento vengono discusse le varie clausole query che è possibile includere in un'espressione di query. Per informazioni dettagliate sulle clausole di query di Visual Basic, vedere Query (Visual Basic).

Operatori di query LINQ di Visual Basic

Le classi nello spazio dei nomi System.Linq e negli altri spazi dei nomi che supportano query LINQ includono metodi che è possibile chiamare per creare e perfezionare query basate sulle esigenze dell'applicazione. Visual Basic include parole chiave per le clausole query più comuni, come descritto nella tabella seguente.

Clausola From (Visual Basic)
Per iniziare una query è obbligatoria una clausola From o una clausola Aggregate. La clausola From specifica un insieme di origine e una variabile di iterazione per una query. Ad esempio:
```
' Returns the company name for all customers for whom
' State is equal to "WA".
Dim names = From cust In customers _
            Where cust.State = "WA" _
            Select cust.CompanyName
```
Clausola Select (Visual Basic)
Facoltativo. Dichiara un insieme di variabili di iterazione per una query. Ad esempio:
```
' Returns the company name and ID value for each
' customer as a collection of a new anonymous type.
Dim customerList = From cust In customers _
                   Select cust.CompanyName, cust.CustomerID
```
Se non è specificata alcuna clausola Select, le variabili di iterazione per la query consistono nelle variabili di iterazione specificate dalla clausola From o Aggregate.

Clausola Where (Visual Basic)
Facoltativo. Specifica una condizione di filtro per una query. Esempio:

' Returns all product names for which the Category of
' the product is "Beverages".
Dim names = From product In products _
            Where product.Category = "Beverages" _
            Select product.Name

Clausola Order By (Visual Basic)
Facoltativo. Specifica l'ordinamento per le colonne in una query. Esempio:

' Returns a list of books sorted by price in 
' ascending order.
Dim titlesAscendingPrice = From b In books _
                           Order By b.price

Clausola Join (Visual Basic)
Facoltativo. Combina due insiemi in un unico insieme. Ad esempio:

' Returns a combined collection of all of the 
' processes currently running and a descriptive
' name for the process taken from a list of 
' descriptive names.
Dim processes = From proc In Process.GetProcesses _
                Join desc In processDescriptions _
                  On proc.ProcessName Equals desc.ProcessName _
                Select proc.ProcessName, proc.Id, desc.Description

Clausola Group By (Visual Basic)
Facoltativo. Raggruppa gli elementi di un risultato della query. Può essere utilizzato per applicare funzioni di aggregazione a ogni gruppo. Ad esempio:

' Returns a list of orders grouped by the order date
' and sorted in ascending order by the order date.
Dim orderList = From order In orders _
                Order By order.OrderDate _
                Group By OrderDate = order.OrderDate _
                Into OrdersByDate = Group

Clausola Group Join (Visual Basic)
Facoltativo. Combina due insiemi in un unico insieme gerarchico. Ad esempio:

' Returns a combined collection of customers and
' customer orders.
Dim customerList = From cust In customers _
                   Group Join ord In orders On _
                     cust.CustomerID Equals ord.CustomerID _
                   Into CustomerOrders = Group, _
                        TotalOfOrders = Sum(ord.Total) _
                   Select cust.CompanyName, cust.CustomerID, _
                          CustomerOrders, TotalOfOrders

Clausola di aggregazione (Visual Basic)
Per iniziare una query è obbligatoria una clausola From o una clausola Aggregate. Una clausola Aggregate applica una o più funzioni di aggregazione a un insieme. Ad esempio, è possibile utilizzare la clausola Aggregate per calcolare una somma di tutti gli elementi restituiti da una query.
```
' Returns the sum of all order totals.
Dim orderTotal = Aggregate order In orders _
                 Into Sum(order.Total)
```
È inoltre possibile utilizzare la clausola Aggregate per modificare una query. Ad esempio, è possibile utilizzare la clausola Aggregate per eseguire un calcolo su un insieme di query correlato.
```
' Returns the customer company name and largest 
' order total for each customer.
Dim customerMax = From cust In customers _
                  Aggregate order In cust.Orders _
                  Into MaxOrder = Max(order.Total) _
                  Select cust.CompanyName, MaxOrder
```

Clausola Let (Visual Basic)
Facoltativo. Calcola un valore e lo assegna a una nuova variabile nella query. Ad esempio:

' Returns a list of products with a calculation of
' a ten percent discount.
Dim discountedProducts = From prod In products _
                         Let Discount = prod.UnitPrice * 0.1 _
                         Where Discount >= 50 _
                         Select prod.Name, prod.UnitPrice, Discount

Clausola Distinct (Visual Basic)
Facoltativo. Limita i valori della variabile di iterazione corrente per eliminare i valori duplicati nei risultati della query. Ad esempio:
```
' Returns a list of cities with no duplicate entries.
Dim cities = From item In customers _
             Select item.City _
             Distinct
```

Clausola Skip (Visual Basic)
Facoltativo. Ignora un numero specificato di elementi in un insieme e quindi restituisce gli elementi rimanenti. Ad esempio:

' Returns a list of customers. The first 10 customers
' are ignored and the remaining customers are
' returned.
Dim customerList = From cust In customers _
                   Skip 10

Clausola Skip While (Visual Basic)
Facoltativo. Ignora gli elementi in un insieme finché la condizione specificata è true e quindi restituisce gli elementi rimanenti. Ad esempio:

' Returns a list of customers. The query ignores all
' customers until the first customer for whom
' IsSubscriber returns false. That customer and all
' remaining customers are returned.
Dim customerList = From cust In customers _
                   Skip While IsSubscriber(cust)

Clausola Take (Visual Basic)
Facoltativo. Restituisce un numero specificato di elementi contigui dall'inizio di un insieme. Ad esempio:
```
' Returns the first 10 customers.
Dim customerList = From cust In customers _
                   Take 10
```

Clausola Take While (Visual Basic)
Facoltativo. Include gli elementi in un insieme finché la condizione specificata è true e quindi ignora gli elementi rimanenti. Ad esempio:

' Returns a list of customers. The query returns
' customers until the first customer for whom 
' HasOrders returns false. That customer and all 
' remaining customers are ignored.
Dim customersWithOrders = From cust In customers _
                          Order By cust.Orders.Count Descending _
                          Take While HasOrders(cust)

Per informazioni dettagliate sulle clausole di query di Visual Basic, vedere Query (Visual Basic).

È possibile utilizzare le funzionalità aggiuntive delle query LINQ chiamando i membri dei tipi enumerabili e queryable forniti da LINQ. È possibile utilizzare queste funzionalità aggiuntive chiamando un particolare operatore di query sul risultato di un'espressione di query. Nell'esempio di codice seguente viene utilizzato il metodo Union per combinare i risultati di due query in un unico risultato. Viene utilizzato il metodo ToList<TSource> per restituire il risultato della query come elenco generico.

VbVbalrIntroToLINQ#22

Per dettagli sulle funzionalità LINQ aggiuntive, vedere Cenni preliminari sugli operatori di query standard.

Connessione a un database utilizzando LINQ to SQL

In Visual Basic, si identificano gli oggetti del database SQL Server , ad esempio tabelle, visualizzazioni e stored procedure a cui si desidera accedere, utilizzando un file LINQ to SQL. Un file LINQ to SQL ha un'estensione .dbml.

Quando si dispone di una connessione valida a un database SQL Server, è possibile aggiungere un modello dell'elemento Classi LINQ to SQL al progetto. Verrà visualizzata Progettazione relazionale oggetti. Progettazione relazionale oggetti consente di trascinare gli elementi a cui si vuole accedere nel codice da Esplora server/Esplora database nell'area di progettazione. Il file LINQ to SQL aggiunge un oggetto DataContext al progetto. Questo oggetto include proprietà e insiemi per tabelle e visualizzazioni alle quali si desidera accedere e metodi per le stored procedure che si desidera chiamare. Dopo avere salvato le modifiche nel file LINQ to SQL (.dbml), è possibile accedere a questi oggetti nel codice facendo riferimento all'oggetto DataContext definito da Progettazione relazionale oggetti. L'oggetto DataContext per il progetto viene denominato in base al nome del file LINQ to SQL. Ad esempio, un file LINQ to SQL denominato Northwind.dbml creerà un oggetto DataContext denominato NorthwindDataContext.

Per esempi con istruzioni dettagliate, vedere Procedura: eseguire query in un database utilizzando LINQ (Visual Basic) e Procedura: chiamare una stored procedure utilizzando LINQ (Visual Basic).

Funzionalità di Visual Basic che supportano LINQ

Visual Basic include altre importanti funzionalità che rendono l'utilizzo di LINQ semplice e riducono la quantità di codice da scrivere per eseguire query LINQ. tra cui:

Tipi anonimi che consentono di creare un nuovo tipo basato su un risultato della query.
Variabili tipizzate in modo implicito che consentono di differire la specifica di un tipo e permettere al compilatore di dedurre il tipo in base al risultato della query.
Metodi di estensione che consentono di estendere un tipo esistente con metodi senza modificare il tipo stesso.

Per informazioni dettagliate, vedere Funzionalità di Visual Basic che supportano LINQ.

Esecuzione query posticipata e immediata

L'esecuzione della query è distinta dalla creazione della query. Dopo che una query viene creata, l'esecuzione viene attivata da un meccanismo separato. Una query può essere eseguita appena definita (esecuzione immediata) oppure è possibile archiviare la definizione ed eseguire la query in un secondo momento (esecuzione posticipata).

Per impostazione predefinita, quando si crea una query, la query stessa non viene eseguita immediatamente. Invece, la definizione della query viene archiviata nella variabile utilizzata per fare riferimento al risultato della query. Quando si accede alla variabile del risultato della query nel codice, ad esempio in un ciclo For…Next, la query viene eseguita. Questo processo viene denominato esecuzione posticipata.

Le query possono essere eseguite anche quando vengono definite e in questo caso si parla di esecuzione immediata. È possibile attivare l'esecuzione immediata applicando un metodo che richiede l'accesso ai singoli elementi del risultato della query. Questo potrebbe risultare dall'inclusione una funzione di aggregazione, come Count, Sum, Average, Min o Max. Per ulteriori informazioni sulle funzioni di aggregazione, vedere Clausola di aggregazione (Visual Basic).

Anche l'utilizzo dei metodi ToList o ToArray forza esecuzione immediata. Questo può essere utile quando si desidera eseguire immediatamente la query e memorizzare nella cache i risultati. Per ulteriori informazioni su tali metodi, vedere Conversione del tipo di dati.

Per ulteriori informazioni sull'esecuzione delle query, vedere Scrittura della prima query LINQ (Visual Basic).

XML in Visual Basic

Le funzionalità XML di Visual Basic includono i valori letterali XML e le proprietà axis XML che semplificano la creazione, l'accesso, l'esecuzione di query e la modifica di XML nel codice. I valori letterali XML consentono di scrivere l'XML direttamente nel codice. Il compilatore del Visual Basic trattano l'XML come oggetto dati di prima classe.

Nell'esempio di codice seguente viene mostrato come creare un elemento XML, accedere ai sub-elementi e agli attributi ed eseguire una query sul contenuto dell'elemento utilizzando LINQ.

' Place Imports statements at the top of your program.  
Imports <xmlns:ns="http://SomeNamespace">

Module Sample1

    Sub SampleTransform()

        ' Create test by using a global XML namespace prefix. 

        Dim contact = _
            <ns:contact>
                <ns:name>Patrick Hines</ns:name>
                <ns:phone ns:type="home">206-555-0144</ns:phone>
                <ns:phone ns:type="work">425-555-0145</ns:phone>
            </ns:contact>

        Dim phoneTypes = _
          <phoneTypes>
              <%= From phone In contact.<ns:phone> _
                  Select <type><%= phone.@ns:type %></type> _
              %>
          </phoneTypes>

        Console.WriteLine(phoneTypes)
    End Sub

End Module

Per ulteriori informazioni, vedere XML in Visual Basic.

Risorse correlate

XML in Visual Basic
Descrive le funzionalità XML in Visual Basic sulle quali è possibile eseguire una query e che consentono di includere l'XML come oggetto dati di prima classe nel codice Visual Basic.
Query (Visual Basic)
Vengono fornite informazioni di riferimento sulle clausole query disponibili in Visual Basic.
LINQ (Language-Integrated Query)
Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ.
LINQ to SQL
Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ to SQL.
LINQ to Objects
Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ to Objects.
LINQ to ADO.NET (pagina portale)
Sono inclusi collegamenti a informazioni generali, indicazioni di programmazione ed esempi per LINQ to ADO.NET.
LINQ to XML
Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ to XML.