Udostępnij za pomocą

Jak: Łączyć dane z LINQ za pomocą sprzężeń (Visual Basic)

Język Visual Basic udostępnia klauzule zapytań Join i Group Join, 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ą klauzulę Join jako wewnętrzne połączenie, a klauzulę Group Join jako skutecznie lewe zewnętrzne połączenie.

Przykłady w tym temacie przedstawiają kilka sposobów łączenia danych przy użyciu klauzul Join i Group Join zapytań.

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ą typów Person i danych Pet 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

Wykonaj sprzężenie wewnętrzne przy użyciu klauzuli JOIN

JOIN WEWNĘTRZNY łączy dane z dwóch zbiorów. Elementy, dla których wartości kluczy się zgadzają, są uwzględnione. 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ć wyraźne połączenie, używając klauzuli Join, jeśli chcesz precyzyjnie wskazać kluczowe pola do użycia w połączeniu. 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 zewnętrznego połączenia lewostronnego przy użyciu klauzuli łączenia grupowego

Lewostronne sprzężenie zewnętrzne obejmuje wszystkie elementy z kolekcji po lewej stronie sprzężenia oraz 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 w efekcie wykonuje LEWE POŁĄCZENIE ZEWNĘTRZNE. Różnica między tym, co jest zwykle znane jako LEFT OUTER JOIN, a tym, co jest zwracane przez klauzulę Group Join, polega na tym, że klauzula Group Join grupuje wyniki z prawej kolekcji sprzężenia dla każdego elementu w lewej kolekcji. W relacyjnej bazie danych operacja LEFT OUTER JOIN zwraca niezgrupowany wynik, w którym każdy element w wyniku zapytania zawiera dopasowane elementy z obu zbiorów w połączeniu. 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ć w formie niezgrupowanego wyniku, rozszerzając zapytanie, aby zwrócić element dla każdego wyniku pogrupowanego zapytania. Aby to osiągnąć, należy upewnić się, że przeprowadzasz zapytanie na DefaultIfEmpty metodzie 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 swojego zapytania, aby ustawić domyślną wartość wyniku, gdy nie ma pasującej wartości z kolekcji sprzężenia po prawej stronie.

Aby wykonać operację Left Outer Join 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

Możesz użyć słowa kluczowego And w klauzuli Join lub Group Join do identyfikowania wielu pól kluczy do użycia podczas dopasowywania wartości z łączonych 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ć łączenie 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 F5, aby uruchomić przykłady.

Zobacz także

  • Last updated on