Postupy: Provádění vnitřních spojení (Průvodce programováním v C#)
V relační databázi podmínky vnitřní spojení vytvoří sadu výsledků, ve které každý prvek kolekce první, zobrazí se jednou pro každý odpovídající prvek druhá kolekce.Pokud je prvek v první kolekci žádné vyhovující prvky, nezobrazí se v sadě výsledků.Join Metodu, která je volána join klauzule v jazyce C# implementuje vnitřní spojení.
Toto téma popisuje, jak provést čtyři varianty vnitřní spojení:
Jednoduchý vnitřní spojení, které koreluje prvky ze dvou zdrojů dat na základě jednoduchého klíče.
Na základě vnitřního spojení, které koreluje prvky z dva zdroje dat složený klíč.Složený klíč, který je klíč, který se skládá z více než jednu hodnotu, umožňuje sladit prvky založené na více než jednu vlastnost.
A více spojení spojení, které po sobě jdoucích operací jsou připojeny navzájem.
Vnitřní spojení, které je implementováno pomocí skupiny spojení.
Příklad
Jednoduchý příklad spojení klíč
Následující příklad vytvoří dvě kolekce, které obsahují objekty dva typy definované uživatelem Person a Pet.Používá dotaz join v jazyce C# odpovídající klauzule Person objekty s Pet objekty, jejichž Owner je Person.select Klauzule v jazyce C# definuje vzhled výsledné objekty.Výsledné objekty v tomto příkladu jsou anonymní typy, které jsou tvořeny jméno vlastníka a pet jméno.
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
Všimněte si, že Person objektu, jehož LastName je "Huff" výsledek, protože je nezobrazí žádné Pet objekt, který má Pet.Owner rovnající se Person.
Příklad spojení složený klíč
Namísto korelace prvků na základě právě jednu vlastnost, můžete porovnat prvky založené na více vlastností složený klíč.To provedete určete funkce Výběr klíče pro jednotlivé kolekce vrátit anonymní typ, který se skládá z vlastnosti, kterou chcete porovnat.Pokud vytvoříte popisek vlastnosti, musí mít stejný popisek v anonymní typ každého klíče.Vlastnosti, musí se také zobrazí ve stejném pořadí.
Následující příklad používá seznam Employee objekty a seznam Student objekty určit zaměstnance, pro které jsou také studentů.Oba tyto typy mají FirstName a LastName vlastnost typu String.Funkce, které vytvořit spojení klíče z každého seznamu prvky vrací anonymní typ, který se skládá z FirstName a LastName vlastnosti každého prvku.Operace join porovná tyto složeného klíče pro rovnost a vrátí dvojice objektů z každého seznamu, kde odpovídají křestní jméno a příjmení.
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
Příklad více spojení
Navzájem provádět více spojení lze připojit libovolný počet operací spojení.Každý join klauzule v jazyce C# zadaný zdroj dat koreluje s výsledky předchozí spojení.
Následující příklad vytvoří tři kolekce: seznam Person objektů, seznam Cat objekty a seznam Dog objektů.
První join klauzule v jazyce C# odpovídá osoby a na základě kočky Person objekt odpovídající Cat.Owner.Vrátí pořadí anonymní typy, které obsahují Person objektu a Cat.Name.
Druhý join klauzule v jazyce C# koreluje anonymní typy vrácených první spojení s Dog objekty v zadaný seznam psů, založené na složený klíč, který se skládá z Owner vlastnost typu Persona první písmeno názvu zvířete.Vrátí pořadí anonymní typy, které obsahují Cat.Name a Dog.Name z každé dvojice odpovídající vlastnosti.Toto je vnitřní spojení, jsou vráceny pouze ty objekty z prvního zdroje dat se shodnou druhého datového zdroje.
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".
Vnitřní spojení pomocí seskupeny příklad spojení
Následující příklad ukazuje, jak implementovat pomocí spojení skupiny vnitřní spojení.
V query1, seznam Person objektů je skupina připojen k seznamu Pet objekty na základě Person odpovídající Pet.Owner vlastnost.Spojení skupiny vytvoří kolekci zprostředkující skupin, kde každá skupina se skládá z Person objektu a odpovídající sekvenci Pet objektů.
Přidáním druhé from klauzule dotazu tuto sekvenci sekvence je kombinované (nebo sloučí) do jedné delší sekvence.Typ prvků konečné pořadí je určeno select klauzule.V tomto příkladu je anonymní typ, který se skládá z typu Person.FirstName a Pet.Name vlastnosti pro každý pár.
V důsledku query1 je ekvivalentní sadu výsledků, které by byly získány pomocí join bez klauzule into klauzule provádět vnitřní spojení.query2 Proměnné ukazuje ekvivalentní dotaz.
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
Probíhá kompilace kódu
Vytvořit nový projekt aplikace konzoly v Visual Studio.
Přidáte odkaz na System.Core.dll, pokud není odkaz.
Zahrnout System.Linq oboru názvů.
Zkopírujte a vložte kód z příkladu do souboru program.cs níže Main metoda.Přidání řádku kódu Main volat metodu vložené do metody.
Spusťte program.
Viz také
Úkoly
Postupy: Provádění seskupených spojení (Průvodce programováním v C#)
Postupy: Provedení levých vnějších spojení (Průvodce programováním v C#)
How to: Join Two Collections (C#) (LINQ to XML)
Referenční dokumentace
Anonymní typy (Průvodce programováním v C#)