Como: Executar associações interna (guia de programação translation from VPE for Csharp)
Em termos de banco de dados relacional, um interna unir produz um conjunto de resultados no qual cada elemento da primeira coleção aparece uma vez para cada elemento correspondente na segunda coleção.Se um elemento na primeira coleção não tiver nenhum elemento correspondente, ele não aparecerá no conjunto de resultados.The Join método, que é chamado pela join cláusula translation from VPE for Csharp ou o Join cláusula no Visual Basic, implementa um interno unir.
Este tópico mostra como executar quatro variações de um interno unir:
Um simples interno unir que correlaciona os elementos de duas fontes de dados com base em uma chave simples.
Um interno unir que correlaciona os elementos de duas fontes de dados com base em um composição chave.Uma chave composta, que é uma chave que consiste em mais de um valor, permite que você correlacione os elementos com base em mais de uma propriedade.
A unir de vários na qual as operações de unir sucessivos são acrescentadas a uns aos outros.
Uma junção interna que é implementada usando uma unir de agrupar.
Exemplo
Exemplo simples de unir de chave
O exemplo a seguir cria duas coleções que contêm objetos de dois tipos definidos pelo usuário, Person e Pet. A consulta usa o join cláusula translation from VPE for Csharp ou o Join cláusula no Visual Basic para fazer a correspondência Person objetos com Pet os objetos cujas Owner é o Person. The select cláusula translation from VPE for Csharp ou o Select cláusula no Visual Basic define como os objetos resultantes aparecerá. Neste exemplo, os objetos resultantes são tipos anônimo que consistem em nome do proprietário e o nome do bicho de estimação.
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
Observe que o Person objeto cujos LastNameé "Huff" não aparece no resultado definido porque não há nenhum Pet objeto que tem Pet.Owner igual a Person.
Chave composta unir exemplo
Em vez de correlacionar os elementos com base em uma única propriedade, você pode usar uma chave composta para comparar com base nas propriedades de vários elementos.Para fazer isso, especifique a função de seletor de chave de cada coleção para retornar um tipo anônimo é composto de propriedades que você deseja comparar.Se você rotular as propriedades, precisam ter a mesma etiqueta da chave de cada tipo anônimo.As propriedades também devem aparecer na mesma ordem.
O exemplo a seguir usa uma lista de Employee objetos e uma lista de Student objetos para determinar quais funcionários estão também aos alunos. Esses tipos têm um FirstName e um LastName propriedade do tipo String. As funções que cria as chaves de unir a partir de elementos da lista de cada retornam um tipo anônimo, que consiste o FirstName e LastName Propriedades de cada elemento. O unir operação compara essas chaves compostas igualdade e retorna pares de objetos de cada lista onde o nome e o sobrenome correspondem ao.
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
Exemplo de múltiplos unir
Qualquer número de operações de unir pode ser anexado a si para realizar uma unir vários.Cada join cláusula translation from VPE for Csharp ou Join cláusula no Visual Basic correlaciona uma fonte de dados especificado com os resultados da unir anterior.
O exemplo a seguir cria três coleções: uma lista de Person uma lista de objetos Cat objetos e uma lista de Dog objetos.
O primeiro join cláusula translation from VPE for Csharp ou Join corresponde a cláusula em Visual Basic pessoas e gatos com base em um Person correspondência de objeto Cat.Owner. Ele retorna uma sequência de tipos anônimo que contêm o Person objeto e Cat.Name.
O segundo join cláusula translation from VPE for Csharp ou Join cláusula no Visual Basic correlaciona os tipos anônimo retornados pela primeira unir com Dog objetos na lista fornecida de cães, com base em uma chave composta que consiste o Owner propriedade do tipo Persone a primeira letra do nome do animal. Ele retorna uma sequência de tipos anônimo que contêm o Cat.Name e Dog.Name Propriedades de cada emparelhar correspondente. Como esta é uma junção interna, somente os objetos da primeira fonte de dados que têm uma correspondência na segunda fonte de dados são retornados.
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".
Junção interna usando agrupado exemplo unir
O exemplo a seguir mostra como implementar uma junção interna, usando uma unir de agrupar.
In query1, a lista de Person objetos é o agrupar associado à lista de Pet objetos com base na Person correspondência de Pet.Owner propriedade. A unir de agrupar cria uma coleção dos grupos de intermediários, onde cada agrupar consiste em um Person objeto e uma sequência de correspondentes Pet objetos.
Adicionando um segundo from (cláusulaFrom cláusula in Visual Basic) à consulta, essa sequência de seqüências é combinada (ou achatada) em uma sequência mais longa. O tipo dos elementos da sequência final é especificado pelo select (cláusulaSelect cláusula in Visual Basic). Neste exemplo, que tipo é um tipo anônimo, que consiste o Person.FirstName e Pet.Name Propriedades de cada emparelhar correspondente.
O resultado de query1 é equivalente ao conjunto de resultados deve ter sido obtido usando o join cláusula WHERE sem a into cláusula translation from VPE for Csharp, ou o Join cláusula in Visual Basic para executar uma junção interna. The query2 variável demonstra essa consulta equivalente.
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
Compilando o código
Criar um novo projeto Console aplicativo em Visual Studio.
Adicione uma referência a sistema.Core.dll se ele já não é referenciado.
Incluir o System.Linq espaço para nome.
Copie e cole o código do exemplo no arquivo programa.cs, abaixo de Main método. Adicionar uma linha de código para o Main método para chamar o método que você colou no.
Execute o programa.
Consulte também
Tarefas
Como: Executar associações agrupadas (guia de programação translation from VPE for Csharp)
Como: Executar associações externas (guia de programação translation from VPE for Csharp) à esquerda
Conceitos
Referência
Tipos anônimo (guia de programação translation from VPE for Csharp)