Làm thế nào để thực hiện Inner Join (C#)

Trong điều kiện cơ sở dữ liệu quan hệ, một bên tham gia sản xuất một tập kết quả, trong đó mỗi phần tử của các bộ sưu tập đầu tiên xuất hiện một lần cho tất cả các yếu tố phù hợp trong bộ sưu tập thứ hai. Nếu một thành phần trong bộ sưu tập đầu tiên không có các yếu tố phù hợp, nó không xuất hiện trong tập kết quả. Các phương pháp tham gia, được gọi là do tham gia điều khoản trong C#, thực hiện một nội tâm tham gia.

Chủ đề này cho bạn thấy làm thế nào để thực hiện bốn biến thể của một bên tham gia:

Một đơn giản bên tham gia có tương quan các yếu tố từ hai nguồn dữ liệu dựa trên một khóa đơn giản.

Một trong những yếu tố tham gia có tương quan từ hai nguồn dữ liệu dựa trên một khóa composite. Một chính tổng hợp, mà là một chính mà bao gồm nhiều hơn một giá trị, cho phép bạn tương quan các yếu tố dựa trên nhiều hơn một tài sản.

Một đa tham gia, trong đó tiếp tham gia các hoạt động được nối với nhau.

Một trong tham gia được thực hiện bằng cách sử dụng một nhóm tham gia.

Ví dụ về Simple Key Join :

Ví dụ sau tạo ra hai bộ sưu tập có chứa các đối tượng của hai kiểu người dùng định nghĩa, người và vật nuôi. Truy vấn này sử dụng mệnh đề join trong C# để phù hợp với nhân vật với các đối tượng mà chủ Pet là người. Các mệnh đề select trong C# định nghĩa cách sẽ xem xét các kết quả đối tượng. Trong ví dụ này, các kết quả đối tượng là loại vô danh đó bao gồm tên của chủ sở hữu và tên của vật nuôi.

class Person
{
       public string FirstName { get; set; }
       public string LastName { get; set; }
}
class Pet
{
       public string Name { get; set; }
       public Person Owner { get; set; }
}
///
/// Simple inner join.
///
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í dụ về Composite Key Join :
Ví dụ sau đây sử dụng một danh sách các đối tượng lao động và danh sách các đối tượng sinh viên để xác định các nhân viên cũng được học sinh. Cả hai loại có FirstName và sở hữu một LastName kiểu String. Các chức năng đó tạo ra các khoá kết nối từ các yếu tố của mỗi danh sách trả về một kiểu nặc danh mà bao gồm các tài sản FirstName và LastName của mỗi phần tử. Các hoạt động tham gia so sánh các tổ hợp phím bình đẳng và trả về cặp của các đối tượng từ danh sách mỗi nơi cả hai cái tên đầu tiên và tên những trận đấu cuối cùng.
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; }
}
///
/// Performs a join operation using a composite key.
///
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
Ví dụ về Multiple Join :
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".
Inner Join bằng cách sử dụng Grouped Join
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