Operazioni di query di base (Visual Basic)

Articolo
04/03/2024

In questo argomento viene fornita una breve introduzione alle espressioni LINQ (Language Integrated Query) in Visual Basic e ad alcuni dei tipi tipici di operazioni eseguite in una query. Per ulteriori informazioni, vedi gli argomenti seguenti:

Introduzione a LINQ in Visual Basic

Query

Procedura dettagliata: Scrittura delle query in Visual Basic

Specifica dell'origine dati (da)

In una query LINQ il primo passaggio consiste nello specificare l'origine dati su cui eseguire la query. Pertanto, la clausola From in una query viene sempre eseguita per prima. Gli operatori di query selezionano e modellano il risultato in base al tipo dell'origine.

Dim query = From cust In customers
'           ...

La clausola From specifica l'origine dati, customers, e una variabile di intervallo, cust. La variabile di intervallo è simile a una variabile di iterazione del ciclo, ad eccezione del fatto che in un'espressione di query non si verifica alcuna iterazione effettiva. Quando la query viene eseguita, spesso usando un ciclo For Each, la variabile di intervallo funge da riferimento a ogni elemento successivo in customers. Poiché il compilatore può dedurre il tipo di cust, non è necessario specificarlo in modo esplicito. Per esempi di query scritte con e senza tipizzazione esplicita, vedereRelazioni tra tipi nelle operazioni di query (Visual Basic).

Per altre informazioni su come usare la clausola From in Visual Basic, vedere Clausola From.

Filtro dei dati (dove)

Probabilmente l'operazione di query più comune consiste nell'applicare un filtro sotto forma di espressione booleana. La query restituisce quindi solo gli elementi per i quali l'espressione è true. Per eseguire il filtro viene utilizzata una clausola Where. Il filtro specifica gli elementi nell'origine dati da includere nella sequenza risultante. Nell'esempio seguente vengono inclusi solo i clienti che hanno un indirizzo a Londra.

Dim londonCusts = From cust In customers
                  Where cust.City = "London"
'                 ...

È possibile usare operatori logici come And e Or per combinare espressioni di filtro in una clausola Where. Ad esempio, per restituire solo i clienti che provengono da Londra e il cui nome è Devon, usare il codice seguente:

Where cust.City = "London" And cust.Name = "Devon"

Per restituire i clienti da Londra o Parigi, usare il codice seguente:

Where cust.City = "London" Or cust.City = "Paris"

Per altre informazioni su come usare la clausola Where in Visual Basic, vedere Clausola Where.

Ordinamento dei dati (Order By)

Spesso è utile ordinare i dati restituiti in un ordine specifico. La clausola Order By causerà l'ordinamento degli elementi nella sequenza restituita in base a un campo o a campi specificati. Ad esempio, la query seguente ordina i risultati in base alla proprietà Name. Poiché Name è una stringa, i dati restituiti verranno ordinati alfabeticamente, da A a Z.

Dim londonCusts1 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
'                   ...

Per ordinare i risultati in ordine inverso, da Z ad A, usare la clausola Order By...Descending. Il valore predefinito è Ascending quando non viene specificato né Ascending né Descending.

Per altre informazioni su come usare la clausola Order By in Visual Basic, vedere Clausola Order By.

Selezione di dati (Seleziona)

La clausola Select specifica il form e il contenuto degli elementi restituiti. Ad esempio, è possibile specificare se i risultati saranno costituiti da oggetti Customer completi, da una sola proprietà Customer, da un subset di proprietà, da varie origini dati o da un nuovo tipo di risultato basato su un calcolo. Quando la clausola Select produce un valore diverso da una copia dell'elemento d'origine, l'operazione viene chiamata proiezione.

Per recuperare una raccolta costituita da oggetti Customer completi, selezionare la variabile di intervallo stessa:

Dim londonCusts2 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select cust

Se un'istanza Customer è un oggetto di grandi dimensioni con molti campi e tutto ciò che si desidera recuperare è il nome, è possibile selezionare cust.Name, come illustrato nell'esempio seguente. L'inferenza del tipo locale riconosce che questo modifica il tipo di risultato da una raccolta di oggetti Customer a una raccolta di stringhe.

Dim londonCusts3 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select cust.Name

Per selezionare più campi dall'origine dati, sono disponibili due opzioni:

Nella clausola Select specificare i campi da includere nel risultato. Il compilatore definirà un tipo anonimo che ha tali campi come proprietà. Per altre informazioni, vedere Tipi anonimi.

Poiché gli elementi restituiti nell'esempio seguente sono istanze di un tipo anonimo, non è possibile fare riferimento al tipo in base al nome altrove nel codice. Il nome designato dal compilatore per il tipo contiene caratteri non validi nel normale codice di Visual Basic. Nell'esempio seguente gli elementi della raccolta restituiti dalla query in londonCusts4 sono istanze di un tipo anonimo
```
Dim londonCusts4 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select Name = cust.Name, Phone = cust.Phone

For Each londonCust In londonCusts4
    Console.WriteLine(londonCust.Name & " " & londonCust.Phone)
Next
```
oppure
Definire un tipo denominato contenente i campi specifici da includere nel risultato e creare e inizializzare istanze del tipo nella clausola Select. Utilizzare questa opzione solo se è necessario utilizzare singoli risultati all'esterno della raccolta in cui vengono restituiti o se è necessario passarli come parametri nelle chiamate al metodo. Il tipo di londonCusts5 nell'esempio seguente è IEnumerable(Of NamePhone).
```
Public Class NamePhone
    Public Name As String
    Public Phone As String
    ' Additional class elements
End Class
```
```
Dim londonCusts5 = From cust In customers
                   Where cust.City = "London"
                   Order By cust.Name Ascending
                   Select New NamePhone With {.Name = cust.Name,
                                              .Phone = cust.Phone}
```

Per altre informazioni su come usare la clausola Select in Visual Basic, vedere Clausola Select.

Join di dati (Join e Group Join)

È possibile combinare più origini dati nella clausola From in diversi modi. Ad esempio, il codice seguente usa due origini dati e combina in modo implicito le proprietà di entrambi nel risultato. La query seleziona gli studenti il cui cognome inizia con una vocale.

Dim vowels() As String = {"A", "E", "I", "O", "U"}
Dim vowelNames = From student In students, vowel In vowels
                 Where student.Last.IndexOf(vowel) = 0
                 Select Name = student.First & " " &
                 student.Last, Initial = vowel
                 Order By Initial

For Each vName In vowelNames
    Console.WriteLine(vName.Initial & ":  " & vName.Name)
Next

Nota

È possibile eseguire questo codice con l'elenco di studenti creati in Procedura: Creare un elenco di elementi.

La parola chiave Join equivale a un INNER JOIN in SQL. Combina due raccolte in base ai valori chiave corrispondenti tra gli elementi nelle due raccolte. La query restituisce tutti o parte degli elementi della raccolta con valori di chiave corrispondenti. Ad esempio, il codice seguente duplica l'azione del join implicito precedente.

Dim vowelNames2 = From student In students
                  Join vowel In vowels
                  On student.Last(0) Equals vowel
                  Select Name = student.First & " " &
                  student.Last, Initial = vowel
                  Order By Initial

Group Join combina le raccolte in una singola raccolta gerarchica, proprio come un oggetto LEFT JOIN in SQL. Per altre informazioni, vedere Clausola Join e Clausola Group Join.

Raggruppamento di dati (Group By)

È possibile aggiungere una clausola Group By per raggruppare gli elementi in un risultato della query in base a uno o più campi degli elementi. Ad esempio, il codice seguente raggruppa gli studenti per anno di classe.

Dim studentsByYear = From student In students
                     Select student
                     Group By year = student.Year
                     Into Classes = Group

For Each yearGroup In studentsByYear
    Console.WriteLine(vbCrLf & "Year: " & yearGroup.year)
    For Each student In yearGroup.Classes
        Console.WriteLine("   " & student.Last & ", " & student.First)
    Next
Next

Se si esegue questo codice usando l'elenco di studenti creati in Procedura: Creare un elenco di elementi, l'output dell'istruzione For Each è:

Anno: Junior

Tucker, Michael

Garcia, Hugo

Garcia, Debra

Tucker, Lance

Anno: Senior

Omelchenko, Svetlana

Osada, Michiko

Fakhouri, Fadi

Feng, Hanying

Adams, Terry

Anno: Matricola

Mortensen, Sven

Garcia, Cesar

La variazione illustrata nel codice seguente ordina gli anni della classe e quindi ordina gli studenti entro ogni anno in base al cognome.

Dim studentsByYear2 = From student In students
                      Select student
                      Order By student.Year, student.Last
                      Group By year = student.Year
                      Into Classes = Group

Per altre informazioni su Group By, vedere Clausola Group By.

Condividi tramite