Introduzione a LINQ in Visual Basic
Language-Integrated Query (LINQ) aggiunge funzionalità di query a Visual Basic e fornisce semplici e potenti funzionalità da usare 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 cercare, 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 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. È possibile eseguire tutte queste operazioni con gli elementi comuni del linguaggio Visual Basic. Poiché le query sono scritte nel linguaggio Visual Basic, i risultati della query vengono restituiti come oggetti fortemente tipizzati. 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. 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 una raccolta e li raggruppa in base alla località.
' 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 esempi
Per eseguire gli esempi nell'introduzione e nella sezione Struttura di una query LINQ, includere il codice seguente, che restituisce elenchi di clienti e ordini.
' 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 LINQ
Un provider LINQ esegue il mapping delle query LINQ Visual Basic all'origine dati su cui viene effettuata 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 provider LINQ seguenti.
| Provider | Descrizione |
|---|---|
| LINQ to Objects | Il provider LINQ to Objects consente di eseguire una query su raccolte 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 abilitare il provider LINQ to Objects importando lo spazio dei nomi System.Linq, che viene importato per impostazione predefinita per tutti i progetti Visual Basic. Per altre 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 Object Relational Designer. Questa finestra di progettazione viene utilizzata per creare un modello a oggetti in un'applicazione con mapping sugli oggetti in un database. Object Relational Designer fornisce anche la funzionalità per eseguire il mapping di stored procedure e di funzioni all'oggetto DataContext, che consente di gestire la comunicazione con il database e di archiviare le informazioni sullo stato per i controlli di concorrenza ottimistica. Per altre informazioni sul provider LINQ to SQL, vedere LINQ to SQL. Per altre informazioni su Object Relational Designer, vedere Strumenti LINQ to SQL in Visual Studio. |
| LINQ to XML | Il provider LINQ to XML consente di eseguire query e di modificare l'XML. È possibile modificare l'XML in memoria o 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à degli assi XML che consentono di scrivere direttamente XML nel codice di Visual Basic. Per altre informazioni, vedere XML. |
| LINQ to DataSet | Il provider LINQ to DataSet consente di eseguire query e di aggiornare dati in un set di dati ADO.NET. È 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. Per altre 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 da applicare ai 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 una clausola From. 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. Queste variabili sono denominate variabili di intervallo o variabili di iterazione. La clausola From è obbligatoria per una query, tranne per le query Aggregate, in cui la clausola From è facoltativa. 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. Per informazioni dettagliate sulle clausole di query, vedere Operatori di query LINQ in Visual Basic più avanti in questo argomento. 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.
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. 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 inserire clausole aggiuntive solo alla fine della query. È possibile suddividere una query su più righe di testo per migliorarne la leggibilità usando il carattere di continuazione riga, ovvero il 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 = "Canada"
Un'altra efficace clausola di query è Select, che consente di restituire dall'origine dati solo i campi selezionati. Le query LINQ restituiscono raccolte enumerabili di oggetti fortemente tipizzati. Una query può restituire una raccolta di tipi anonimi o tipi denominati. È possibile utilizzare la clausola Select per restituire solo un unico campo dall'origine dati. Quando si esegue questa operazione, il tipo dell'insieme restituito è il tipo di quell'unico campo. È possibile utilizzare anche la clausola Select per restituire più campi dall'origine dati. In questo caso, il tipo della raccolta restituita è 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 una raccolta di tipi anonimi che hanno membri popolati con dati dai campi selezionati dell'origine dati.
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. Questa operazione può essere eseguita con una o più clausole From oppure utilizzando le clausole di 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 una raccolta di tipi anonimi che contengono dati del cliente e dell'ordine.
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. Ogni oggetto Customer ha una proprietà che contiene una raccolta 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 una raccolta di tipi anonimi. La query restituisce un tipo che include una proprietà CustomerOrders che contiene una raccolta di dati dell'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 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. Nella prossima sezione di questo argomento vengono discusse le varie clausole di query che è possibile includere in un'espressione di query. Per informazioni dettagliate sulle clausole di query di Visual Basic, vedere Query.
Operatori di query LINQ in 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 di query comuni seguenti. Per informazioni dettagliate sulle clausole di query di Visual Basic, vedere Query.
Clausola From
Per iniziare una query è obbligatoria una clausola From o una clausola Aggregate. Una clausola From specifica una raccolta di origine e una variabile di iterazione per una query. Ad esempio:
' 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 Select
Facoltativo. Una clausola Select dichiara un set 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 viene specificata nessuna clausola Select, le variabili di iterazione per la query consistono nelle variabili di iterazione specificate dalla clausola From o Aggregate.
Clausola Where
Facoltativo. Una clausola Where specifica una condizione di filtro per una query. Ad 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
Facoltativo. Una clausola Order By specifica l'ordinamento per le colonne in una query. Ad esempio:
' Returns a list of books sorted by price in
' ascending order.
Dim titlesAscendingPrice = From b In books
Order By b.price
clausola Join
Facoltativo. Una clausola Join combina due raccolte in un'unica raccolta. 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
Facoltativo. Una clausola Group By raggruppa gli elementi di un risultato della query. Può essere usata 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
Facoltativo. Una clausola Group Join combina due raccolte in un'unica raccolta gerarchica. 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.Amount)
Select cust.CompanyName, cust.CustomerID,
CustomerOrders, TotalOfOrders
clausola di aggregazione
Per iniziare una query è obbligatoria una clausola Aggregate o una clausola From. Una clausola Aggregate applica una o più funzioni di aggregazione a una raccolta. Ad esempio, è possibile usare la clausola Aggregate per calcolare la somma di tutti gli elementi restituiti da una query, come illustrato nell'esempio seguente.
' 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. Ad esempio, è possibile utilizzare la clausola Aggregate per eseguire un calcolo su una raccolta di query correlata. Ad esempio:
' 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)
Facoltativo. Una clausola Let 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
Facoltativo. Una clausola Distinct 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
Skip (clausola)
Facoltativo. Una clausola Skip ignora un numero specificato di elementi in una raccolta 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
Skip While (clausola)
Facoltativo. Una clausola Skip While ignora gli elementi in una raccolta finché una 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)
Take (clausola)
Facoltativo. Una clausola Take restituisce un numero specificato di elementi contigui dall'inizio di una raccolta. Ad esempio:
' Returns the first 10 customers.
Dim customerList = From cust In customers
Take 10
Take While (clausola)
Facoltativo. Una clausola Take While include gli elementi in una raccolta finché una 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)
Usare funzionalità aggiuntive per le query LINQ
È possibile utilizzare le funzionalità aggiuntive delle query LINQ chiamando i membri dei tipi enumerabili e disponibili per query forniti da LINQ. È possibile utilizzare queste funzionalità aggiuntive chiamando un particolare operatore di query sul risultato di un'espressione di query. Nell'esempio seguente viene usato il metodo Enumerable.Union per combinare i risultati di due query in un unico risultato. Viene utilizzato il metodo Enumerable.ToList per restituire il risultato della query come elenco generico.
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à aggiuntive di LINQ, vedere Panoramica dgli operatori di query standard.
Connessione a un database usando LINQ to SQL
In Visual Basic si identificano gli oggetti del database SQL Server, ad esempio tabelle, viste e stored procedure, a cui si desidera accedere usando 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à visualizzato Object Relational Designer (O/R Designer). Object Relational Designer consente di trascinare gli elementi a cui si vuole accedere nel codice da Esplora server/Esplora database nell'area della finestra di progettazione. Il file LINQ to SQL aggiunge un oggetto DataContext al progetto. 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. 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. 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 chiamato NorthwindDataContext.
Per esempi con istruzioni dettagliate, vedere Procedura: eseguire query su un database e Procedura: chiamare una stored procedure.
Funzionalità di Visual Basic che supportano LINQ
Visual Basic include altre importanti funzionalità che semplificano l'utilizzo di LINQ e riducono la quantità di codice da scrivere per eseguire query LINQ. Di seguito sono elencate le quattro opzioni disponibili.
Tipi anonimi, che consentono di creare un nuovo tipo basato su un risultato della query.
Variabili tipizzate in modo implicito, che consentono di posticipare 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 di 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 non appena viene definita (esecuzione immediata); in alternativa, è 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. Al contrario, la definizione della query viene archiviata nella variabile utilizzata per fare riferimento al risultato della query. 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. Questo processo è noto come 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 di una funzione di aggregazione, come Count, Sum, Average, Min o Max. Per informazioni sulle funzioni di aggregazione, vedere Clausola Aggregate.
Anche l'utilizzo dei metodi ToList o ToArray forza l'esecuzione immediata. Ciò può essere utile quando si desidera eseguire immediatamente la query e memorizzare nella cache i risultati. Per altre informazioni su questi metodi, vedere Conversione dei tipi di dati.
Per altre informazioni sull'esecuzione di query, vedere Scrittura della prima query LINQ.
XML in Visual Basic
Le funzionalità XML in Visual Basic includono i valori letterali XML e le proprietà degli 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 di Visual Basic tratta l'XML come oggetto dati di prima classe.
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.
' 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 altre informazioni, vedere XML.
Risorse correlate
| Argomento | Descrizione |
|---|---|
| XML | Descrive le funzionalità XML in Visual Basic sulle quali è possibile eseguire query e che consentono di includere il codice XML come oggetto dati di prima classe nel codice di Visual Basic. |
| Query | Fornisce informazioni di riferimento sulle clausole di 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) | Include collegamenti a informazioni generali, indicazioni per la programmazione ed esempi per LINQ to ADO.NET. |
| LINQ to XML | Sono incluse informazioni generali, indicazioni di programmazione ed esempi per LINQ to XML. |
Argomenti di procedure e procedure dettagliate
Procedura: Eseguire query in un database
Procedura: Chiamare una stored procedure
Procedura: Modificare dati in un database
Procedura: Combinare dati utilizzando join
Procedura: Ordinare i risultati di query
Procedura: Filtrare i risultati di una query
Procedura: Conteggio, somma o media di dati
Procedura: Trovare il valore minimo o massimo in un risultato di query
Capitoli del libro in evidenza
Capitolo 17: LINQ in Programming Visual Basic 2008
Vedi anche
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per