Porady: wykonanie sprzężeń wewnętrznych (Przewodnik programowania w języku C#)
Pod względem relacyjnej bazy danych sprzężenia wewnętrznego tworzy zestaw wyników, w którym każdy element pierwszy zbiór pojawia się jeden raz dla każdego pasującego elementu w kolekcji drugiego.Jeśli element w kolekcji pierwszy nie ma pasujących elementów, nie pojawiają się w zestawie wyników.Join Metodę, która jest wywoływana przez join w C# klauzuli implementuje sprzężenie wewnętrzne.
W tym temacie opisano, jak wykonać cztery odmiany sprzężenia wewnętrznego:
Proste sprzężenia wewnętrznego jest całkowicie skorelowany elementów z dwóch źródeł danych opartą na kluczu proste.
Sprzężenie wewnętrzne, odpowiadająca elementów z dwóch źródeł na podstawie kompozytowe klucza.Klucz złożony, który jest klucz, który składa się z więcej niż jedną wartość, pozwala skorelować elementów na podstawie więcej niż jednej właściwości.
A sprzężenie wiele w którym sprzężenia kolejnych operacji są dołączane do siebie.
Sprzężenie wewnętrzne jest implementowane za pomocą sprzężenia grupy.
Przykład
Prosty przykład sprzężenia klucza
Poniższy przykład tworzy dwie kolekcje, które zawierają obiekty dwa typy zdefiniowane przez użytkownika, Person i Pet.W kwerendzie użyto join w C# odpowiadać klauzuli Person obiekty z Pet obiektów, których Owner jest to, że Person.select Klauzuli w C# definiuje wygląd obiektów wynikowy.W tym przykładzie obiekty wynikowe są typy anonimowe, które składają się z nazwy pierwszego właściciela i nazwy pet.
class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}
/// <summary>
/// Simple inner join.
/// </summary>
public static void InnerJoinExample()
{
Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };
Person rui = new Person { FirstName = "Rui", LastName = "Raposo" };
Pet barley = new Pet { Name = "Barley", Owner = terry };
Pet boots = new Pet { Name = "Boots", Owner = terry };
Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
Pet bluemoon = new Pet { Name = "Blue Moon", Owner = rui };
Pet daisy = new Pet { Name = "Daisy", Owner = magnus };
// Create two lists.
List<Person> people = new List<Person> { magnus, terry, charlotte, arlene, rui };
List<Pet> pets = new List<Pet> { barley, boots, whiskers, bluemoon, daisy };
// Create a collection of person-pet pairs. Each element in the collection
// is an anonymous type containing both the person's name and their pet's name.
var query = from person in people
join pet in pets on person equals pet.Owner
select new { OwnerName = person.FirstName, PetName = pet.Name };
foreach (var ownerAndPet in query)
{
Console.WriteLine("\"{0}\" is owned by {1}", ownerAndPet.PetName, ownerAndPet.OwnerName);
}
}
// This code produces the following output:
//
// "Daisy" is owned by Magnus
// "Barley" is owned by Terry
// "Boots" is owned by Terry
// "Whiskers" is owned by Charlotte
// "Blue Moon" is owned by Rui
Należy zauważyć, że Person obiekt, którego LastName jest "Huff" nie są wyświetlane w zestawie, ponieważ nie ma wyników nie Pet obiektu, który ma Pet.Owner równą Person.
Przykład sprzężenia klucz złożony
Zamiast korelowanie elementów na podstawie tylko jednej właściwości, można użyć klucza złożonego do porównania na podstawie właściwości wielu elementów.Aby to zrobić, należy określić funkcję selektor klucza dla każdej kolekcji zwracany typ anonimowy, który składa się z właściwości, które chcesz porównać.Jeśli użytkownik etykiety właściwości, muszą mieć tę samą etykietę w polu Typ anonimowy każdego klucza.Właściwości muszą również są wyświetlane w takiej samej kolejności.
W poniższym przykładzie użyto listy z Employee obiektów i lista Student określają, w których pracownicy są również studentów obiekty.Oba typy mają FirstName i LastName właściwość typu String.Funkcje, które tworzenia kluczy sprzężenia z każdej listy elementów zwracają typ anonimowy, który składa się z FirstName i LastName właściwości każdego elementu.Operacja join porównuje te klucze projekt wstępny dla równości i zwraca pary obiektów z każdej listy, w których odpowiadają zarówno imię i nazwisko.
class Employee
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int EmployeeID { get; set; }
}
class Student
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int StudentID { get; set; }
}
/// <summary>
/// Performs a join operation using a composite key.
/// </summary>
public static void CompositeKeyJoinExample()
{
// Create a list of employees.
List<Employee> employees = new List<Employee> {
new Employee { FirstName = "Terry", LastName = "Adams", EmployeeID = 522459 },
new Employee { FirstName = "Charlotte", LastName = "Weiss", EmployeeID = 204467 },
new Employee { FirstName = "Magnus", LastName = "Hedland", EmployeeID = 866200 },
new Employee { FirstName = "Vernette", LastName = "Price", EmployeeID = 437139 } };
// Create a list of students.
List<Student> students = new List<Student> {
new Student { FirstName = "Vernette", LastName = "Price", StudentID = 9562 },
new Student { FirstName = "Terry", LastName = "Earls", StudentID = 9870 },
new Student { FirstName = "Terry", LastName = "Adams", StudentID = 9913 } };
// Join the two data sources based on a composite key consisting of first and last name,
// to determine which employees are also students.
IEnumerable<string> query = from employee in employees
join student in students
on new { employee.FirstName, employee.LastName }
equals new { student.FirstName, student.LastName }
select employee.FirstName + " " + employee.LastName;
Console.WriteLine("The following people are both employees and students:");
foreach (string name in query)
Console.WriteLine(name);
}
// This code produces the following output:
//
// The following people are both employees and students:
// Terry Adams
// Vernette Price
Przykład sprzężenia wielu
Dowolną liczbę operacji join może być dołączona do innych do wykonywania wielu sprzężenia.Każdy join klauzuli w C# jest całkowicie skorelowany określonego źródła danych z wyników poprzednich sprzężenia.
Poniższy przykład tworzy trzy zbiory: Lista Person obiektów, wykaz Cat obiektów i lista Dog obiektów.
Pierwszy join klauzuli w C# pasuje do osób i kotów, oparte na Person dopasowania obiektu Cat.Owner.Zwraca ona sekwencji typy anonimowe, które zawierają Person obiektu i Cat.Name.
Drugi join klauzuli w C# jest całkowicie skorelowany anonimowe typy zwracane przez pierwszy sprzężenia z Dog obiektów na podanej liście psów, na podstawie złożonych klucz, który składa się z Owner właściwość typu Personoraz pierwszej litery nazwy zwierzęcia.Zwraca ona sekwencji typy anonimowe, które zawierają Cat.Name i Dog.Name z każdej pary pasujących właściwości.Ponieważ jest sprzężenie wewnętrzne, zwracane są tylko te obiekty z pierwszego źródła danych, które mają odpowiedniki w drugiego źródła danych.
class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}
class Cat : Pet
{ }
class Dog : Pet
{ }
public static void MultipleJoinExample()
{
Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };
Person rui = new Person { FirstName = "Rui", LastName = "Raposo" };
Person phyllis = new Person { FirstName = "Phyllis", LastName = "Harris" };
Cat barley = new Cat { Name = "Barley", Owner = terry };
Cat boots = new Cat { Name = "Boots", Owner = terry };
Cat whiskers = new Cat { Name = "Whiskers", Owner = charlotte };
Cat bluemoon = new Cat { Name = "Blue Moon", Owner = rui };
Cat daisy = new Cat { Name = "Daisy", Owner = magnus };
Dog fourwheeldrive = new Dog { Name = "Four Wheel Drive", Owner = phyllis };
Dog duke = new Dog { Name = "Duke", Owner = magnus };
Dog denim = new Dog { Name = "Denim", Owner = terry };
Dog wiley = new Dog { Name = "Wiley", Owner = charlotte };
Dog snoopy = new Dog { Name = "Snoopy", Owner = rui };
Dog snickers = new Dog { Name = "Snickers", Owner = arlene };
// Create three lists.
List<Person> people =
new List<Person> { magnus, terry, charlotte, arlene, rui, phyllis };
List<Cat> cats =
new List<Cat> { barley, boots, whiskers, bluemoon, daisy };
List<Dog> dogs =
new List<Dog> { fourwheeldrive, duke, denim, wiley, snoopy, snickers };
// The first join matches Person and Cat.Owner from the list of people and
// cats, based on a common Person. The second join matches dogs whose names start
// with the same letter as the cats that have the same owner.
var query = from person in people
join cat in cats on person equals cat.Owner
join dog in dogs on
new { Owner = person, Letter = cat.Name.Substring(0, 1) }
equals new { dog.Owner, Letter = dog.Name.Substring(0, 1) }
select new { CatName = cat.Name, DogName = dog.Name };
foreach (var obj in query)
{
Console.WriteLine(
"The cat \"{0}\" shares a house, and the first letter of their name, with \"{1}\".",
obj.CatName, obj.DogName);
}
}
// This code produces the following output:
//
// The cat "Daisy" shares a house, and the first letter of their name, with "Duke".
// The cat "Whiskers" shares a house, and the first letter of their name, with "Wiley".
Sprzężenie wewnętrzne przy użyciu zgrupowane przykład Join
Poniższy przykład pokazuje, jak zaimplementować sprzężenie wewnętrzne za pomocą sprzężenia grupy.
W query1, listy z Person obiektów jest przyłączony grupy do listy Pet obiektów na podstawie Person pasujące Pet.Owner właściwości.Sprzężenie grupy tworzy kolekcji grup pośredniego, gdzie każda grupa składa się z Person obiektu i sekwencja pasujących Pet obiektów.
Przez dodanie drugiej from klauzula kwerendy tej sekwencji sekwencji jest połączone (lub spłaszczone) w jednej sekwencji dłużej.Typ elementów sekwencji końcowy jest określany przez select klauzuli.W tym przykładzie, że typem jest typ anonimowy, który składa się z Person.FirstName i Pet.Name właściwości dla każdej pary pasujących.
Wynik query1 jest odpowiednikiem w zestawie wyników, które byłyby uzyskane za pomocą join bez into klauzuli do wykonywania sprzężenie wewnętrzne.query2 Zmienna demonstruje tę kwerendę równoważne.
class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}
/// <summary>
/// Performs an inner join by using GroupJoin().
/// </summary>
public static void InnerGroupJoinExample()
{
Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };
Pet barley = new Pet { Name = "Barley", Owner = terry };
Pet boots = new Pet { Name = "Boots", Owner = terry };
Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
Pet bluemoon = new Pet { Name = "Blue Moon", Owner = terry };
Pet daisy = new Pet { Name = "Daisy", Owner = magnus };
// Create two lists.
List<Person> people = new List<Person> { magnus, terry, charlotte, arlene };
List<Pet> pets = new List<Pet> { barley, boots, whiskers, bluemoon, daisy };
var query1 = from person in people
join pet in pets on person equals pet.Owner into gj
from subpet in gj
select new { OwnerName = person.FirstName, PetName = subpet.Name };
Console.WriteLine("Inner join using GroupJoin():");
foreach (var v in query1)
{
Console.WriteLine("{0} - {1}", v.OwnerName, v.PetName);
}
var query2 = from person in people
join pet in pets on person equals pet.Owner
select new { OwnerName = person.FirstName, PetName = pet.Name };
Console.WriteLine("\nThe equivalent operation using Join():");
foreach (var v in query2)
Console.WriteLine("{0} - {1}", v.OwnerName, v.PetName);
}
// This code produces the following output:
//
// Inner join using GroupJoin():
// Magnus - Daisy
// Terry - Barley
// Terry - Boots
// Terry - Blue Moon
// Charlotte - Whiskers
//
// The equivalent operation using Join():
// Magnus - Daisy
// Terry - Barley
// Terry - Boots
// Terry - Blue Moon
// Charlotte - Whiskers
Kompilowanie kodu
Utwórz nowy projekt aplikacji konsoli w Visual Studio.
Dodaj odwołanie do System.Core.dll, jeśli nie jest wywoływany.
Zawiera System.Linq obszaru nazw.
Skopiuj i Wklej kod z przykładu do pliku plik program.cs poniżej Main metody.Dodawanie linii kodu do Main metodę w celu wywołania metody wklejane w.
Uruchom program.
Zobacz też
Zadania
Porady: wykonanie sprzężeń grupowanych (Przewodnik programowania w języku C#)
Porady: wykonanie lewych sprzężeń zewnętrznych (Przewodnik programowania w języku C#)
How to: Join Two Collections (C#) (LINQ to XML)
Informacje
Typy anonimowe (Przewodnik programowania w języku C#)