Introduzione a LINQ in Visual BasicIntroduction to LINQ in Visual Basic

LINQ (Language-Integrated Query) aggiunge funzionalità di query a Visual Basic e fornisce funzionalità semplici e potenti quando si utilizzano tutti i tipi di dati.Language-Integrated Query (LINQ) adds query capabilities to Visual Basic and provides simple and powerful capabilities when you work with all kinds of data. Anziché inviare una query a un database da elaborare o usare una sintassi di query diversa per ogni tipo di dati che si sta cercando, LINQ introduce le query come parte del linguaggio Visual Basic.Rather than sending a query to a database to be processed, or working with different query syntax for each type of data that you are searching, LINQ introduces queries as part of the Visual Basic language. Utilizza una sintassi unificata indipendentemente dal tipo di dati.It uses a unified syntax regardless of the type of data.

LINQ consente di eseguire query sui dati da un database SQL Server, XML, matrici e raccolte in memoria, set di dati ADO.NET o qualsiasi altra origine dati remota o locale che supporta LINQ.LINQ enables you to query data from a SQL Server database, XML, in-memory arrays and collections, ADO.NET datasets, or any other remote or local data source that supports LINQ. Questa operazione può essere eseguita con gli elementi comuni del linguaggio Visual Basic.You can do all this with common Visual Basic language elements. Poiché le query sono scritte nel linguaggio Visual Basic, i risultati della query vengono restituiti come oggetti fortemente tipizzati.Because your queries are written in the Visual Basic language, your query results are returned as strongly-typed objects. Questi oggetti supportano IntelliSense, che consente di scrivere il codice più velocemente e di individuare errori nelle query in fase di compilazione anziché in fase di esecuzione.These objects support IntelliSense, which enables you to write code faster and catch errors in your queries at compile time instead of at run time. Le query LINQ possono essere utilizzate come origine di query aggiuntive per perfezionare i risultati.LINQ queries can be used as the source of additional queries to refine results. Possono anche venire associate a controlli in modo che gli utenti possano facilmente visualizzare e modificare i risultati della query.They can also be bound to controls so that users can easily view and modify your query results.

Nell'esempio di codice seguente viene illustrata una query LINQ che restituisce un elenco di clienti da una raccolta e li raggruppa in base alla località.For example, the following code example shows a LINQ query that returns a list of customers from a collection and groups them based on their location.

' Obtain a list of customers.
Dim customers As List(Of Customer) = GetCustomers()

' Return customers that are grouped based on country.
Dim countries = From cust In customers
                Order By cust.Country, cust.City
                Group By CountryName = cust.Country
                Into CustomersInCountry = Group, Count()
                Order By CountryName

' Output the results.
For Each country In countries
    Debug.WriteLine(country.CountryName & " count=" & country.Count)

    For Each customer In country.CustomersInCountry
        Debug.WriteLine("   " & customer.CompanyName & "  " & customer.City)
    Next
Next

' Output:
'   Canada count=2
'      Contoso, Ltd  Halifax
'      Fabrikam, Inc.  Vancouver
'   United States count=1
'      Margie's Travel  Redmond

Esecuzione degli esempiRunning the examples

Per eseguire gli esempi nell'introduzione e nella struttura di una sezione di query LINQ , includere il codice seguente, che restituisce elenchi di clienti e ordini.To run the examples in the introduction and in the Structure of a LINQ Query section, include the following code, which returns lists of customers and orders.

' Return a list of customers.
Private Function GetCustomers() As List(Of Customer)
    Return New List(Of Customer) From
        {
            New Customer With {.CustomerID = 1, .CompanyName = "Contoso, Ltd", .City = "Halifax", .Country = "Canada"},
            New Customer With {.CustomerID = 2, .CompanyName = "Margie's Travel", .City = "Redmond", .Country = "United States"},
            New Customer With {.CustomerID = 3, .CompanyName = "Fabrikam, Inc.", .City = "Vancouver", .Country = "Canada"}
        }
End Function

' Return a list of orders.
Private Function GetOrders() As List(Of Order)
    Return New List(Of Order) From
        {
            New Order With {.CustomerID = 1, .Amount = "200.00"},
            New Order With {.CustomerID = 3, .Amount = "600.00"},
            New Order With {.CustomerID = 1, .Amount = "300.00"},
            New Order With {.CustomerID = 2, .Amount = "100.00"},
            New Order With {.CustomerID = 3, .Amount = "800.00"}
        }
End Function

' Customer Class.
Private Class Customer
    Public Property CustomerID As Integer
    Public Property CompanyName As String
    Public Property City As String
    Public Property Country As String
End Class

' Order Class.
Private Class Order
    Public Property CustomerID As Integer
    Public Property Amount As Decimal
End Class

Provider LINQLINQ providers

Un provider LINQ esegue il mapping delle query LINQ Visual Basic all'origine dati sottoposta a query.A LINQ provider maps your Visual Basic LINQ queries to the data source being queried. 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.When you write a LINQ query, the provider takes that query and translates it into commands that the data source will be able to execute. Il provider converte anche i dati dall'origine negli oggetti che costituiscono il risultato della query.The provider also converts data from the source to the objects that make up your query result. Infine, converte gli oggetti in dati quando si inviano aggiornamenti all'origine dati.Finally, it converts objects to data when you send updates to the data source.

Visual Basic include i provider LINQ seguenti.Visual Basic includes the following LINQ providers.

ProviderProvider DescrizioneDescription
LINQ to ObjectsLINQ to Objects Il provider LINQ to Objects consente di eseguire una query su raccolte e matrici in memoria.The LINQ to Objects provider enables you to query in-memory collections and arrays. Se un oggetto supporta l'interfaccia IEnumerable o IEnumerable<T>, il provider LINQ to Objects consente di eseguire una query su di esso.If an object supports either the IEnumerable or IEnumerable<T> interface, the LINQ to Objects provider enables you to query it.

È possibile abilitare il provider di LINQ to Objects importando lo System.Linq spazio dei nomi, che viene importato per impostazione predefinita per tutti i progetti di Visual Basic.You can enable the LINQ to Objects provider by importing the System.Linq namespace, which is imported by default for all Visual Basic projects.

Per ulteriori informazioni sul provider LINQ to Objects, vedere LINQ to Objects.For more information about the LINQ to Objects provider, see LINQ to Objects.
LINQ to SQLLINQ to SQL Il provider LINQ to SQL consente di eseguire query e di modificare i dati su un database SQL server.The LINQ to SQL provider enables you to query and modify data in a SQL Server database. Questo semplifica il mapping del modello a oggetti per un'applicazione alle tabelle e agli oggetti in un database.This makes it easy to map the object model for an application to the tables and objects in a database.

Visual Basic semplifica l'uso di LINQ to SQL includendo il Object Relational Designer (O/R Designer).Visual Basic makes it easier to work with LINQ to SQL by including the Object Relational Designer (O/R Designer). Questa finestra di progettazione viene utilizzata per creare un modello a oggetti in un'applicazione con mapping sugli oggetti in un database.This designer is used to create an object model in an application that maps to objects in a database. In Progettazione relazionale oggetti è inoltre disponibile la funzionalità per eseguire il DataContext mapping di stored procedure e funzioni all'oggetto, che gestisce la comunicazione con il database e archivia lo stato per i controlli di concorrenza ottimistica.The O/R Designer also provides functionality to map stored procedures and functions to the DataContext object, which manages communication with the database and stores state for optimistic concurrency checks.

Per ulteriori informazioni sul provider LINQ to SQL, vedere LINQ to SQL.For more information about the LINQ to SQL provider, see LINQ to SQL. Per ulteriori informazioni sulla Object Relational Designer, vedere LINQ to SQL Tools in Visual Studio.For more information about the Object Relational Designer, see LINQ to SQL Tools in Visual Studio.
LINQ to XMLLINQ to XML Il provider LINQ to XML consente di eseguire query e di modificare l'XML.The LINQ to XML provider enables you to query and modify XML. È possibile modificare l'XML in memoria o caricare l'XML da file o salvare l'XML in un file.You can modify in-memory XML, or you can load XML from and save XML to a file.

Inoltre, il provider di LINQ to XML Abilita i valori letterali XML e le proprietà Axis XML che consentono di scrivere codice XML direttamente nel codice di Visual Basic.Additionally, the LINQ to XML provider enables XML literals and XML axis properties that enable you to write XML directly in your Visual Basic code. Per ulteriori informazioni, vedere XML.For more information, see XML.
LINQ to DataSetLINQ to DataSet Il provider di LINQ to DataSet consente di eseguire query e aggiornare i dati in un set di dati ADO.NET.The LINQ to DataSet provider enables you to query and update data in an ADO.NET dataset. È possibile aggiungere le caratteristiche avanzate di LINQ ad applicazioni che utilizzano set di dati per semplificare ed estendere le funzionalità per l'esecuzione di query, l'aggregazione e l'aggiornamento dei dati nel set di dati.You can add the power of LINQ to applications that use datasets in order to simplify and extend your capabilities for querying, aggregating, and updating the data in your dataset.

Per altre informazioni, vedere LINQ to DataSet.For more information, see LINQ to DataSet.

Struttura di una query LINQStructure of a LINQ query

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.A LINQ query, often referred to as a query expression, consists of a combination of query clauses that identify the data sources and iteration variables for the query. Un'espressione di query può includere anche istruzioni per ordinare, filtrare, raggruppare e unire o eseguire calcoli da applicare ai dati di origine.A query expression can also include instructions for sorting, filtering, grouping, and joining, or calculations to apply to the source data. La sintassi delle espressioni di query è simile alla sintassi SQL; pertanto, gran parte della sintassi risulterà familiare.Query expression syntax resembles the syntax of SQL; therefore, you may find much of the syntax familiar.

Un'espressione di query inizia con una clausola From.A query expression starts with a From clause. Questa clausola identifica i dati di origine per una query e le variabili utilizzate per fare riferimento a ogni singolo elemento dell'insieme di origine.This clause identifies the source data for a query and the variables that are used to refer to each element of the source data individually. Queste variabili sono denominate variabili di intervallo o variabilidi iterazione.These variables are named range variables or iteration variables. La clausola From è obbligatoria per una query, tranne per le query Aggregate, in cui la clausola From è facoltativa.The From clause is required for a query, except for Aggregate queries, where the From clause is optional. Dopo che l'ambito e l'origine della query sono identificati nelle clausole From o Aggregate, è possibile includere qualsiasi combinazione di clausole di query per perfezionare la query.After the scope and source of the query are identified in the From or Aggregate clauses, you can include any combination of query clauses to refine the query. Per informazioni dettagliate sulle clausole di query, vedere Visual Basic operatori di query LINQ più avanti in questo argomento.For details about query clauses, see Visual Basic LINQ Query Operators later in this topic. Ad esempio, nella query seguente viene identificata una raccolta di origine di dati sul cliente come variabile customers e una variabile di iterazione denominata cust.For example, the following query identifies a source collection of customer data as the customers variable, and an iteration variable named cust.

Dim customers = GetCustomers()

Dim queryResults = From cust In customers

For Each result In queryResults
    Debug.WriteLine(result.CompanyName & "  " & result.Country)
Next

' Output:
'   Contoso, Ltd  Canada
'   Margie's Travel  United States
'   Fabrikam, Inc.  Canada

In questo esempio viene illustrata una query valida; tuttavia, la query diventa molto più efficace quando si aggiungono altre clausole di query per perfezionare il risultato.This example is a valid query by itself; however, the query becomes far more powerful when you add more query clauses to refine the result. Ad esempio, è possibile aggiungere una clausola Where per filtrare il risultato per uno o più valori.For example, you can add a Where clause to filter the result by one or more values. Le espressioni di query consistono in una sola riga di codice; è possibile inserire clausole aggiuntive solo alla fine della query.Query expressions are a single line of code; you can just append additional query clauses to the end of the query. È possibile suddividere una query su più righe di testo per migliorare la leggibilità utilizzando il carattere di continuazione_di riga ().You can break up a query across multiple lines of text to improve readability by using the underscore (_) line-continuation character. Nell'esempio di codice seguente viene illustrato un esempio di query che include una clausola Where.The following code example shows an example of a query that includes a Where clause.

Dim queryResults = From cust In customers
                   Where cust.Country = "Canada"

Un'altra efficace clausola di query è Select, che consente di restituire dall'origine dati solo i campi selezionati.Another powerful query clause is the Select clause, which enables you to return only selected fields from the data source. Le query LINQ restituiscono raccolte enumerabili di oggetti fortemente tipizzati.LINQ queries return enumerable collections of strongly typed objects. Una query può restituire una raccolta di tipi anonimi o tipi denominati.A query can return a collection of anonymous types or named types. È possibile utilizzare la clausola Select per restituire solo un unico campo dall'origine dati.You can use the Select clause to return only a single field from the data source. Quando si esegue questa operazione, il tipo dell'insieme restituito è il tipo di quell'unico campo.When you do this, the type of the collection returned is the type of that single field. È possibile utilizzare anche la clausola Select per restituire più campi dall'origine dati.You can also use the Select clause to return multiple fields from the data source. In questo caso, il tipo della raccolta restituita è un nuovo tipo anonimo.When you do this, the type of the collection returned is a new anonymous type. È anche possibile far corrispondere i campi restituiti dalla query ai campi di un tipo denominato specificato.You can also match the fields returned by the query to the fields of a specified named type. Nell'esempio di codice seguente viene illustrata un'espressione di query che restituisce una raccolta di tipi anonimi che hanno membri popolati con dati dai campi selezionati dell'origine dati.The following code example shows a query expression that returns a collection of anonymous types that have members populated with data from the selected fields from the data source.

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

Le query LINQ possono essere utilizzate anche per combinare più origini di dati e restituire un unico risultato.LINQ queries can also be used to combine multiple sources of data and return a single result. Questa operazione può essere eseguita con una o più clausole From oppure utilizzando le clausole di query Join o Group Join.This can be done with one or more From clauses, or by using the Join or Group Join query clauses. Nell'esempio di codice seguente viene illustrata un'espressione di query che combina dati del cliente e dell'ordine e restituisce una raccolta di tipi anonimi che contengono dati del cliente e dell'ordine.The following code example shows a query expression that combines customer and order data and returns a collection of anonymous types containing customer and order data.

Dim customers = GetCustomers()
Dim orders = GetOrders()

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

For Each result In queryResults
    Debug.WriteLine(result.ord.Amount & "  " & result.ord.CustomerID & "  " & result.cust.CompanyName)
Next

' Output:
'   200.00  1  Contoso, Ltd
'   300.00  1  Contoso, Ltd
'   100.00  2  Margie's Travel
'   600.00  3  Fabrikam, Inc.
'   800.00  3  Fabrikam, Inc.

È possibile utilizzare la clausola Group Join per creare un risultato della query gerarchico che contiene una raccolta di oggetti Customer.You can use the Group Join clause to create a hierarchical query result that contains a collection of customer objects. Ogni oggetto Customer ha una proprietà che contiene una raccolta di tutti gli ordini per quel cliente.Each customer object has a property that contains a collection of all orders for that customer. 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 una raccolta di tipi anonimi.The following code example shows a query expression that combines customer and order data as a hierarchical result and returns a collection of anonymous types. La query restituisce un tipo che include una proprietà CustomerOrders che contiene una raccolta di dati dell'ordine per tale cliente.The query returns a type that includes a CustomerOrders property that contains a collection of order data for the customer. Include anche una proprietà OrderTotal che contiene la somma dei totali per tutti gli ordini per quel cliente.It also includes an OrderTotal property that contains the sum of the totals for all the orders for that customer. (Questa query è equivalente a una query LEFT OUTER JOIN).(This query is equivalent to a LEFT OUTER JOIN.)

Dim customers = GetCustomers()
Dim orders = GetOrders()

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

For Each result In queryResults
    Debug.WriteLine(result.OrderTotal & "  " & result.CustomerID & "  " & result.CompanyName)
    For Each ordResult In result.CustomerOrders
        Debug.WriteLine("   " & ordResult.Amount)
    Next
Next

' Output:
'   500.00  1  Contoso, Ltd
'      200.00
'      300.00
'   100.00  2  Margie's Travel
'      100.00
'   1400.00  3  Fabrikam, Inc.
'      600.00
'      800.00

Esistono molti altri operatori di query LINQ che è possibile utilizzare per creare efficaci espressioni di query.There are several additional LINQ query operators that you can use to create powerful query expressions. Nella prossima sezione di questo argomento vengono discusse le varie clausole di query che è possibile includere in un'espressione di query.The next section of this topic discusses the various query clauses that you can include in a query expression. Per informazioni dettagliate sulle clausole di query Visual Basic, vedere query.For details about Visual Basic query clauses, see Queries.

Visual Basic operatori di query LINQVisual Basic LINQ query operators

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.The classes in the System.Linq namespace and the other namespaces that support LINQ queries include methods that you can call to create and refine queries based on the needs of your application. Visual Basic include parole chiave per le clausole di query comuni seguenti.Visual Basic includes keywords for the following common query clauses. Per informazioni dettagliate sulle clausole di query Visual Basic, vedere query.For details about Visual Basic query clauses, see Queries.

Clausola FromFrom clause

Per iniziare una query è Aggregate necessario specificare una From clausola o una clausola.Either a From clause or an Aggregate clause is required to begin a query. Una clausola From specifica una raccolta di origine e una variabile di iterazione per una query.A From clause specifies a source collection and an iteration variable for a query. Ad esempio:For example:

' Returns the company name for all customers for which
' the Country is equal to "Canada".
Dim names = From cust In customers
            Where cust.Country = "Canada"
            Select cust.CompanyName

clausola SelectSelect clause

facoltativo.Optional. Una clausola dichiara un set di variabili di iterazione per una query. Select A Select clause declares a set of iteration variables for a query. Ad esempio:For example:

' 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 viene specificata nessuna clausola Select, le variabili di iterazione per la query consistono nelle variabili di iterazione specificate dalla clausola From o Aggregate.If a Select clause is not specified, the iteration variables for the query consist of the iteration variables specified by the From or Aggregate clause.

Clausola WhereWhere clause

facoltativo.Optional. Una clausola specifica una condizione di filtro per una query. Where A Where clause specifies a filtering condition for a query. Ad esempio:For example:

' 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]Order By clause]

| Opzionale.|Optional. Una clausola specifica il tipo di ordinamento per le colonne in una query. Order By An Order By clause specifies the sort order for columns in a query. Ad esempio:For example:

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

clausola JoinJoin clause

facoltativo.Optional. Una clausola combina due raccolte in un'unica raccolta. Join A Join clause combines two collections into a single collection. Ad esempio:For example:

' 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 ByGroup By clause

facoltativo.Optional. Una clausola raggruppa gli elementi di un risultato della query. Group By A Group By clause groups the elements of a query result. Può essere usato per applicare funzioni di aggregazione a ogni gruppo.It can be used to apply aggregate functions to each group. Ad esempio:For example:

' 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 JoinGroup Join clause

facoltativo.Optional. Una clausola combina due raccolte in un'unica raccolta gerarchica. Group Join A Group Join clause combines two collections into a single hierarchical collection. Ad esempio:For example:

' 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.Amount)
                   Select cust.CompanyName, cust.CustomerID,
                          CustomerOrders, TotalOfOrders

clausola di aggregazioneAggregate clause

Per iniziare una query è From necessario specificare una clausola o una clausola. Aggregate Either an Aggregate clause or a From clause is required to begin a query. Una clausola Aggregate applica una o più funzioni di aggregazione a una raccolta.An Aggregate clause applies one or more aggregate functions to a collection. È ad esempio possibile utilizzare la Aggregate clausola per calcolare una somma di tutti gli elementi restituiti da una query, come avviene nell'esempio seguente.For example, you can use the Aggregate clause to calculate a sum for all the elements returned by a query, as the following example does.

' Returns the sum of all order amounts.
Dim orderTotal = Aggregate order In orders
                 Into Sum(order.Amount)

È anche possibile utilizzare la clausola Aggregate per modificare una query.You can also use the Aggregate clause to modify a query. Ad esempio, è possibile utilizzare la clausola Aggregate per eseguire un calcolo su una raccolta di query correlata.For example, you can use the Aggregate clause to perform a calculation on a related query collection. Ad esempio:For example:

' Returns the customer company name and largest 
' order amount for each customer.
Dim customerMax = From cust In customers
                  Aggregate order In cust.Orders
                  Into MaxOrder = Max(order.Amount)
                  Select cust.CompanyName, MaxOrder

Let (clausola)Let clause

facoltativo.Optional. Una clausola calcola un valore e lo assegna a una nuova variabile nella query. Let A Let clause computes a value and assigns it to a new variable in the query. Ad esempio:For example:

' 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 DistinctDistinct clause

facoltativo.Optional. Una Distinct clausola limita i valori della variabile di iterazione corrente per eliminare i valori duplicati nei risultati della query.A Distinct clause restricts the values of the current iteration variable to eliminate duplicate values in query results. Ad esempio:For example:

' Returns a list of cities with no duplicate entries.
Dim cities = From item In customers
             Select item.City
             Distinct

Skip (clausola)Skip clause

facoltativo.Optional. Una clausola ignora un numero specificato di elementi in una raccolta e quindi restituisce gli elementi rimanenti. Skip A Skip clause bypasses a specified number of elements in a collection and then returns the remaining elements. Ad esempio:For example:

' 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

Skip While (clausola)Skip While clause

facoltativo.Optional. true UnaSkip While clausola ignora gli elementi di una raccolta finché una condizione specificata è e quindi restituisce gli elementi rimanenti.A Skip While clause bypasses elements in a collection as long as a specified condition is true and then returns the remaining elements. Ad esempio:For example:

' 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)

Take (clausola)Take clause

facoltativo.Optional. Una clausola restituisce un numero specificato di elementi contigui dall'inizio di una raccolta. Take A Take clause returns a specified number of contiguous elements from the start of a collection. Ad esempio:For example:

' Returns the first 10 customers.
Dim customerList = From cust In customers
                   Take 10

Take While (clausola)Take While clause

facoltativo.Optional. true UnaTake While clausola include elementi in una raccolta, purché una condizione specificata sia e ignori gli elementi rimanenti.A Take While clause includes elements in a collection as long as a specified condition is true and bypasses the remaining elements. Ad esempio:For example:

' 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)

Usare funzionalità di query LINQ aggiuntiveUse additional LINQ query features

È possibile utilizzare le funzionalità aggiuntive delle query LINQ chiamando i membri dei tipi enumerabili e disponibili per query forniti da LINQ.You can use additional LINQ query features by calling members of the enumerable and queryable types provided by LINQ. È possibile utilizzare queste funzionalità aggiuntive chiamando un particolare operatore di query sul risultato di un'espressione di query.You can use these additional capabilities by calling a particular query operator on the result of a query expression. Nell'esempio seguente, ad esempio, viene Enumerable.Union utilizzato il metodo per combinare i risultati di due query in un unico risultato della query.For example, the following example uses the Enumerable.Union method to combine the results of two queries into one query result. Viene utilizzato il metodo Enumerable.ToList per restituire il risultato della query come elenco generico.It uses the Enumerable.ToList method to return the query result as a generic list.

Public Function GetAllCustomers() As List(Of Customer)
    Dim customers1 = From cust In domesticCustomers
    Dim customers2 = From cust In internationalCustomers

    Dim customerList = customers1.Union(customers2)

    Return customerList.ToList()
End Function

Per informazioni dettagliate sulle funzionalità LINQ aggiuntive, vedere Cenni preliminari sugli operatori di query standard.For details about additional LINQ capabilities, see Standard Query Operators Overview.

Connettersi a un database tramite LINQ to SQLConnect to a database by using LINQ to SQL

In Visual Basic, è possibile identificare gli oggetti di database SQL Server, ad esempio tabelle, viste e stored procedure, a cui si desidera accedere utilizzando un file LINQ to SQL.In Visual Basic, you identify the SQL Server database objects, such as tables, views, and stored procedures, that you want to access by using a LINQ to SQL file. Un file LINQ to SQL ha un'estensione .dbml.A LINQ to SQL file has an extension of .dbml.

Quando si dispone di una connessione valida a un database di SQL Server, è possibile aggiungere un modello di elemento classi LINQ to SQL al progetto.When you have a valid connection to a SQL Server database, you can add a LINQ to SQL Classes item template to your project. Verrà visualizzato Object Relational Designer (O/R Designer).This will display the Object Relational Designer (O/R designer). La finestra di progettazione di O/R consente di trascinare gli elementi a cui si desidera accedere nel codice dall' Esplora server/Esplora database nell'area di progettazione.The O/R Designer enables you to drag the items that you want to access in your code from the Server Explorer/Database Explorer onto the designer surface. Il file LINQ to SQL aggiunge un oggetto DataContext al progetto.The LINQ to SQL file adds a DataContext object to your project. Questo oggetto include proprietà e raccolte per tabelle e visualizzazioni alle quali si desidera accedere e metodi per le stored procedure che si desidera chiamare.This object includes properties and collections for the tables and views that you want access to, and methods for the stored procedures that you want to call. Dopo avere salvato le modifiche nel file LINQ to SQL (.dbml), è possibile accedere a questi oggetti nel codice facendo riferimento all'oggetto DataContext che viene definito da O/R Designer.After you have saved your changes to the LINQ to SQL (.dbml) file, you can access these objects in your code by referencing the DataContext object that is defined by the O/R Designer. L'oggetto DataContext per il progetto viene denominato in base al nome del file LINQ to SQL.The DataContext object for your project is named based on the name of your LINQ to SQL file. Ad esempio, un file LINQ to SQL denominato Northwind.dbml creerà un oggetto DataContext chiamato NorthwindDataContext.For example, a LINQ to SQL file that is named Northwind.dbml will create a DataContext object named NorthwindDataContext.

Per esempi di istruzioni dettagliate, vedere procedura: Eseguire una query su un database e procedura: Chiamare una stored procedure.For examples with step-by-step instructions, see How to: Query a Database and How to: Call a Stored Procedure.

Visual Basic funzionalità che supportano LINQVisual Basic features that support LINQ

Visual Basic include altre importanti funzionalità che rendono l'utilizzo di LINQ semplice e riducono la quantità di codice che è necessario scrivere per eseguire query LINQ.Visual Basic includes other notable features that make the use of LINQ simple and reduce the amount of code that you must write to perform LINQ queries. tra cui:These include the following:

  • Tipi anonimi, che consentono di creare un nuovo tipo in base al risultato di una query.Anonymous types, which enable you to create a new type based on a query result.

  • Variabili tipizzate in modo implicito, che consentono di rinviare la specifica di un tipo e consentire al compilatore di dedurre il tipo in base al risultato della query.Implicitly typed variables, which enable you to defer specifying a type and let the compiler infer the type based on the query result.

  • Metodi di estensione, che consentono di estendere un tipo esistente con metodi personalizzati senza modificare il tipo stesso.Extension methods, which enable you to extend an existing type with your own methods without modifying the type itself.

Per informazioni dettagliate, vedere Visual Basic funzionalità che supportano LINQ.For details, see Visual Basic Features That Support LINQ.

Esecuzione di query posticipata e immediataDeferred and immediate query execution

L'esecuzione della query è distinta dalla creazione della query.Query execution is separate from creating a query. Dopo che una query viene creata, l'esecuzione viene attivata da un meccanismo separato.After a query is created, its execution is triggered by a separate 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).

Per impostazione predefinita, quando si crea una query, la query stessa non viene eseguita immediatamente.By default, when you create a query, the query itself does not execute immediately. Al contrario, la definizione della query viene archiviata nella variabile utilizzata per fare riferimento al risultato della query.Instead, the query definition is stored in the variable that is used to reference the query result. Quando si accede in un secondo momento alla variabile del risultato della query nel codice, ad esempio in un ciclo For…Next, la query viene eseguita.When the query result variable is accessed later in code, such as in a For…Next loop, the query is executed. Questo processo viene definito esecuzione posticipata.This process is referred to as deferred execution.

Le query possono essere eseguite anche quando vengono definite, a cui viene fatto riferimento come esecuzione immediata.Queries can also be executed when they are defined, which is referred to as immediate execution. È possibile attivare l'esecuzione immediata applicando un metodo che richiede l'accesso ai singoli elementi del risultato della query.You can trigger immediate execution by applying a method that requires access to individual elements of the query result. Questo potrebbe risultare dall'inclusione di una funzione di aggregazione, come Count, Sum, Average, Min o Max.This can be the result of including an aggregate function, such as Count, Sum, Average, Min, or Max. Per ulteriori informazioni sulle funzioni di aggregazione, vedere clausola Aggregate.For more information about aggregate functions, see Aggregate Clause.

Anche l'utilizzo dei metodi ToList o ToArray forza l'esecuzione immediata.Using the ToList or ToArray methods will also force immediate execution. Ciò può essere utile quando si desidera eseguire immediatamente la query e memorizzare nella cache i risultati.This can be useful when you want to execute the query immediately and cache the results. Per ulteriori informazioni su questi metodi, vedere conversione di tipi di dati.For more information about these methods, see Converting Data Types.

Per ulteriori informazioni sull'esecuzione di query, vedere scrittura della prima query LINQ.For more information about query execution, see Writing Your First LINQ Query.

XML in Visual BasicXML in Visual Basic

Le funzionalità XML in Visual Basic includono valori letterali XML e proprietà Axis XML, che consentono di creare, accedere, eseguire query e modificare XML nel codice in modo semplice.The XML features in Visual Basic include XML literals and XML axis properties, which enable you easily to create, access, query, and modify XML in your code. I valori letterali XML consentono di scrivere l'XML direttamente nel codice.XML literals enable you to write XML directly in your code. Il compilatore di Visual Basic tratta l'XML come oggetto dati di prima classe.The Visual Basic compiler treats the XML as a first-class data object.

Nell'esempio di codice seguente viene mostrato come creare un elemento XML, accedere ai sottoelementi e agli attributi ed eseguire una query sul contenuto dell'elemento utilizzando LINQ.The following code example shows how to create an XML element, access its sub-elements and attributes, and query the contents of the element by using 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.For more information, see XML.

ArgomentoTopic DescrizioneDescription
XMLXML Vengono descritte le funzionalità XML in Visual Basic su cui è possibile eseguire query e che consentono di includere XML come oggetti dati di prima classe nel codice di Visual Basic.Describes the XML features in Visual Basic that can be queried and that enable you to include XML as first-class data objects in your Visual Basic code.
QueryQueries Vengono fornite informazioni di riferimento sulle clausole di query disponibili in Visual Basic.Provides reference information about the query clauses that are available in Visual Basic.
LINQ (Language-Integrated Query)LINQ (Language-Integrated Query) Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ.Includes general information, programming guidance, and samples for LINQ.
LINQ to SQLLINQ to SQL Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ to SQL.Includes general information, programming guidance, and samples for LINQ to SQL.
LINQ to ObjectsLINQ to Objects Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ to Objects.Includes general information, programming guidance, and samples for LINQ to Objects.
LINQ to ADO.NET (pagina portale)LINQ to ADO.NET (Portal Page) Sono inclusi collegamenti a informazioni generali, indicazioni di programmazione ed esempi per LINQ to ADO.NET.Includes links to general information, programming guidance, and samples for LINQ to ADO.NET.
LINQ to XMLLINQ to XML Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ to XML.Includes general information, programming guidance, and samples for LINQ to XML.

Procedure e procedure dettagliateHow to and walkthrough topics

Procedura: Eseguire query su un databaseHow to: Query a Database

Procedura: Chiamare una stored procedureHow to: Call a Stored Procedure

Procedura: Modificare i dati in un databaseHow to: Modify Data in a Database

Procedura: Combinare i dati con joinHow to: Combine Data with Joins

Procedura: Ordina risultati queryHow to: Sort Query Results

Procedura: Filtrare i risultati delle queryHow to: Filter Query Results

Procedura: Conteggio, somma o media di datiHow to: Count, Sum, or Average Data

Procedura: Trovare il valore minimo o massimo in un risultato della queryHow to: Find the Minimum or Maximum Value in a Query Result

Procedura: Assegnare stored procedure per eseguire aggiornamenti, inserimenti ed eliminazioni (O/R Designer)How to: Assign stored procedures to perform updates, inserts, and deletes (O/R Designer)

Capitolo 17: LINQ nella programmazione Visual Basic 2008Chapter 17: LINQ in Programming Visual Basic 2008

Vedere ancheSee also