Udostępnij za pośrednictwem

Porady: łączenie danych w LINQ za pomocą sprzężeń (Visual Basic)

  • Artykuł

Język Visual Basic udostępnia Join klauzule i Group Join zapytania, aby umożliwić łączenie zawartości wielu kolekcji na podstawie wspólnych wartości między kolekcjami. Te wartości są nazywane wartościami klucza . Deweloperzy zaznajomieni z pojęciami relacyjnej bazy danych rozpoznają Join klauzulę JAKO SPRZĘŻENIE WEWNĘTRZNE i Group Join klauzulę jako, skutecznie, LEWE SPRZĘŻENIE ZEWNĘTRZNE.

W przykładach w tym temacie przedstawiono kilka sposobów łączenia danych przy użyciu Join klauzul i Group Join zapytania.

Tworzenie projektu i dodawanie przykładowych danych

Aby utworzyć projekt zawierający przykładowe dane i typy

  1. Aby uruchomić przykłady w tym temacie, otwórz program Visual Studio i dodaj nowy projekt aplikacji konsolowej Visual Basic. Kliknij dwukrotnie plik Module1.vb utworzony przez visual basic.

  2. Przykłady w tym temacie używają Person typów i Pet i danych z poniższego przykładu kodu. Skopiuj ten kod do domyślnego Module1 modułu utworzonego przez visual basic.

    Private _people As List(Of Person)
Private _pets As List(Of Pet)

Function GetPeople() As List(Of Person)
    If _people Is Nothing Then CreateLists()
    Return _people
End Function

Function GetPets(ByVal people As List(Of Person)) As List(Of Pet)
    If _pets Is Nothing Then CreateLists()
    Return _pets
End Function

Private Sub CreateLists()
    Dim pers As Person

    _people = New List(Of Person)
    _pets = New List(Of Pet)

    pers = New Person With {.FirstName = "Magnus", .LastName = "Hedlund"}
    _people.Add(pers)
    _pets.Add(New Pet With {.Name = "Daisy", .Owner = pers})

    pers = New Person With {.FirstName = "Terry", .LastName = "Adams"}
    _people.Add(pers)
    _pets.Add(New Pet With {.Name = "Barley", .Owner = pers})
    _pets.Add(New Pet With {.Name = "Boots", .Owner = pers})
    _pets.Add(New Pet With {.Name = "Blue Moon", .Owner = pers})

    pers = New Person With {.FirstName = "Charlotte", .LastName = "Weiss"}
    _people.Add(pers)
    _pets.Add(New Pet With {.Name = "Whiskers", .Owner = pers})

    ' Add a person with no pets for the sake of Join examples.
    _people.Add(New Person With {.FirstName = "Arlene", .LastName = "Huff"})

    pers = New Person With {.FirstName = "Don", .LastName = "Hall"}
    ' Do not add person to people list for the sake of Join examples.
    _pets.Add(New Pet With {.Name = "Spot", .Owner = pers})

    ' Add a pet with no owner for the sake of Join examples.
    _pets.Add(New Pet With {.Name = "Unknown",
                            .Owner = New Person With {.FirstName = String.Empty,
                                                      .LastName = String.Empty}})
End Sub

    Class Person
    Public Property FirstName As String
    Public Property LastName As String
End Class

Class Pet
    Public Property Name As String
    Public Property Owner As Person
End Class

Wykonywanie sprzężenia wewnętrznego przy użyciu klauzuli Join

SPRZĘŻENIE WEWNĘTRZNE łączy dane z dwóch kolekcji. Elementy, dla których są uwzględniane określone wartości klucza. Wszystkie elementy z dowolnej kolekcji, które nie mają pasującego elementu w innej kolekcji, są wykluczone.

W języku Visual Basic LINQ oferuje dwie opcje wykonywania sprzężenia wewnętrznego: niejawnego sprzężenia i jawnego sprzężenia.

Sprzężenie niejawne określa kolekcje do sprzężenia w klauzuli From i identyfikuje pasujące pola klucza w klauzuli Where . Program Visual Basic niejawnie łączy dwie kolekcje na podstawie określonych pól klucza.

Możesz określić jawne sprzężenie przy użyciu klauzuli Join , jeśli chcesz określić, które pola klucza mają być używane w sprzężeniu. W takim przypadku klauzula Where może być nadal używana do filtrowania wyników zapytania.

Aby wykonać sprzężenie wewnętrzne przy użyciu klauzuli Join

  1. Dodaj następujący kod do modułu Module1 w projekcie, aby zobaczyć przykłady zarówno niejawnego, jak i jawnego sprzężenia wewnętrznego.

    Sub InnerJoinExample()
    ' Create two lists.
    Dim people = GetPeople()
    Dim pets = GetPets(people)

    ' Implicit Join.
    Dim petOwners = From pers In people, pet In pets
                    Where pet.Owner Is pers
                    Select pers.FirstName, PetName = pet.Name

    ' Display grouped results.
    Dim output As New System.Text.StringBuilder
    For Each pers In petOwners
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output)

    ' Explicit Join.
    Dim petOwnersJoin = From pers In people
                        Join pet In pets
                        On pet.Owner Equals pers
                        Select pers.FirstName, PetName = pet.Name

    ' Display grouped results.
    output = New System.Text.StringBuilder()
    For Each pers In petOwnersJoin
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output)

    ' Both queries produce the following output:
    '
    ' Magnus:    Daisy
    ' Terry:     Barley
    ' Terry:     Boots
    ' Terry:     Blue Moon
    ' Charlotte: Whiskers
End Sub

Wykonywanie sprzężenia zewnętrznego po lewej stronie przy użyciu klauzuli dołączania grupy

LEWE SPRZĘŻENIA ZEWNĘTRZNE zawiera wszystkie elementy z kolekcji po lewej stronie sprzężenia i tylko pasujące wartości z kolekcji po prawej stronie sprzężenia. Wszystkie elementy z kolekcji po prawej stronie sprzężenia, które nie mają pasującego elementu w kolekcji po lewej stronie, są wykluczone z wyniku zapytania.

Klauzula Group Join wykonuje, w efekcie, LEWE SPRZĘŻENIA ZEWNĘTRZNE. Różnica między tym, co jest zwykle znane jako LEFT OUTER JOIN i co Group Join zwraca klauzula, jest to, że Group Join klauzula grupuje wyniki z prawej kolekcji sprzężenia dla każdego elementu w kolekcji po lewej stronie. W relacyjnej bazie danych funkcja LEFT OUTER JOIN zwraca niezgrupowany wynik, w którym każdy element w wyniku zapytania zawiera pasujące elementy z obu kolekcji w sprzężeniu. W takim przypadku elementy z lewej kolekcji sprzężenia są powtarzane dla każdego pasującego elementu z kolekcji po prawej stronie. Zobaczysz, jak wygląda to po zakończeniu następnej procedury.

Wyniki Group Join zapytania można pobrać jako niezgrupowany wynik, rozszerzając zapytanie w celu zwrócenia elementu dla każdego pogrupowanego wyniku zapytania. Aby to osiągnąć, należy upewnić się, że wykonujesz zapytanie względem DefaultIfEmpty metody pogrupowanej kolekcji. Dzięki temu elementy z lewej kolekcji sprzężenia są nadal uwzględniane w wyniku zapytania, nawet jeśli nie mają pasujących wyników z kolekcji po prawej stronie. Możesz dodać kod do zapytania, aby podać domyślną wartość wyniku, gdy nie ma pasującej wartości z kolekcji sprzężenia po prawej stronie.

Aby wykonać lewe sprzężenie zewnętrzne przy użyciu klauzuli Group Join

  1. Dodaj następujący kod do modułu Module1 w projekcie, aby wyświetlić przykłady zarówno zgrupowanego lewego sprzężenia zewnętrznego, jak i niezgrupowanego lewego sprzężenia zewnętrznego.

    Sub LeftOuterJoinExample()
    ' Create two lists.
    Dim people = GetPeople()
    Dim pets = GetPets(people)

    ' Grouped results.
    Dim petOwnersGrouped = From pers In people
                           Group Join pet In pets
                             On pers Equals pet.Owner
                           Into PetList = Group
                           Select pers.FirstName, pers.LastName,
                                  PetList

    ' Display grouped results.
    Dim output As New System.Text.StringBuilder
    For Each pers In petOwnersGrouped
        output.AppendFormat(pers.FirstName & ":" & vbCrLf)
        For Each pt In pers.PetList
            output.AppendFormat(vbTab & pt.Name & vbCrLf)
        Next
    Next

    Console.WriteLine(output)
    ' This code produces the following output:
    '
    ' Magnus:
    '     Daisy
    ' Terry:
    '     Barley
    '     Boots
    '     Blue Moon
    ' Charlotte:
    '     Whiskers
    ' Arlene:

    ' "Flat" results.
    Dim petOwners = From pers In people
                    Group Join pet In pets On pers Equals pet.Owner
                    Into PetList = Group
                    From pet In PetList.DefaultIfEmpty()
                    Select pers.FirstName, pers.LastName,
                           PetName =
                             If(pet Is Nothing, String.Empty, pet.Name)


    ' Display "flat" results.
    output = New System.Text.StringBuilder()
    For Each pers In petOwners
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output.ToString())
    ' This code produces the following output:
    '
    ' Magnus:	    Daisy
    ' Terry:	    Barley
    ' Terry:	    Boots
    ' Terry:	    Blue Moon
    ' Charlotte:	Whiskers
    ' Arlene:	  
End Sub

Wykonywanie sprzężenia przy użyciu klucza złożonego

Słowo kluczowe w klauzuli Join or Group Join służy And do identyfikowania wielu pól kluczy do użycia podczas dopasowywania wartości ze sprzężonych kolekcji. Słowo And kluczowe określa, że wszystkie określone pola klucza muszą być zgodne z elementami, które mają zostać połączone.

Aby wykonać sprzężenie przy użyciu klucza złożonego

  1. Dodaj następujący kod do modułu Module1 w projekcie, aby zobaczyć przykłady sprzężenia korzystającego z klucza złożonego.

    Sub CompositeKeyJoinExample()
    ' Create two lists.
    Dim people = GetPeople()
    Dim pets = GetPets(people)

    ' Implicit Join.
    Dim petOwners = From pers In people
                    Join pet In pets On
                      pet.Owner.FirstName Equals pers.FirstName And
                      pet.Owner.LastName Equals pers.LastName
                    Select pers.FirstName, PetName = pet.Name

    ' Display grouped results.
    Dim output As New System.Text.StringBuilder
    For Each pers In petOwners
        output.AppendFormat(
          pers.FirstName & ":" & vbTab & pers.PetName & vbCrLf)
    Next

    Console.WriteLine(output)
    ' This code produces the following output:
    '
    ' Magnus:    Daisy
    ' Terry:     Barley
    ' Terry:     Boots
    ' Terry:     Blue Moon
    ' Charlotte: Whiskers
End Sub

Uruchamianie kodu

Aby dodać kod do uruchamiania przykładów

  1. Zastąp element Sub Main w Module1 module w projekcie następującym kodem, aby uruchomić przykłady w tym temacie.

    Sub Main()
    InnerJoinExample()
    LeftOuterJoinExample()
    CompositeKeyJoinExample()

    Console.ReadLine()
End Sub

  2. Naciśnij klawisz F5, aby uruchomić przykłady.

Zobacz też