join tümcesi (C# Başvurusu)join clause (C# Reference)

join Yan tümcesi, nesne modelinde hiçbir doğrudan ilişkisi olan farklı kaynak dizilerinden öğelerini ilişkilendirmek için kullanışlıdır.The join clause is useful for associating elements from different source sequences that have no direct relationship in the object model. Her kaynak öğeleri eşitlik için karşılaştırılması gereken bazı değeri paylaşmak tek gereksinim olmasıdır.The only requirement is that the elements in each source share some value that can be compared for equality. Örneğin, bir yiyecek dağıtımcısı, belirli bir ürünü tedarikçileri listesini ve alıcıların listesi sahip olabilir.For example, a food distributor might have a list of suppliers of a certain product, and a list of buyers. A join yan tümcesi, örneğin, üreticiler listesini oluşturmak için kullanılabilir ve tüm aynı olan alıcılar bu ürünün belirtilen bölge.A join clause can be used, for example, to create a list of the suppliers and buyers of that product who are all in the same specified region.

A join yan tümcesi, iki kaynak dizileri girdi alır.A join clause takes two source sequences as input. Her bir dizideki öğelerin olması veya diğer dizisindeki karşılık gelen bir özellik için karşılaştırılabilir bir özelliği içerir.The elements in each sequence must either be or contain a property that can be compared to a corresponding property in the other sequence. join Yan tümcesi, özel kullanarak eşitlik için belirtilen anahtarları karşılaştırır equals anahtar sözcüğü.The join clause compares the specified keys for equality by using the special equals keyword. Tarafından gerçekleştirilen tüm birleştirmeler join yan tümcesi olan equijoins.All joins performed by the join clause are equijoins. Çıkışı şeklini bir join yan tümcesi yapmakta olduğunuz birleştirme belirli türüne göre değişir.The shape of the output of a join clause depends on the specific type of join you are performing. En yaygın üç birleşim türleri şunlardır:The following are three most common join types:

  • İç birleştirmeInner join

  • Grup birleştirmeGroup join

  • Sol dış birleştirmeLeft outer join

İç birleştirmeInner join

Aşağıdaki örnek, basit bir iç equijoin gösterir.The following example shows a simple inner equijoin. Bu sorgu düz dizisi üretir "ürün adı / kategorisi" çiftleri.This query produces a flat sequence of "product name / category" pairs. Aynı kategori dize birden çok öğe görünür.The same category string will appear in multiple elements. Bir öğeyi, categories eşleşen yok products, bu kategoriye sonuçlarında görünmez.If an element from categories has no matching products, that category will not appear in the results.

var innerJoinQuery =
    from category in categories
    join prod in products on category.ID equals prod.CategoryID
    select new { ProductName = prod.Name, Category = category.Name }; //produces flat sequence

Daha fazla bilgi için iç birleştirmeler gerçekleştirme.For more information, see Perform inner joins.

Grup birleştirmeGroup join

A join yan tümcesiyle birlikte bir into ifadesi, bir grup birleştirme çağrılır.A join clause with an into expression is called a group join.

var innerGroupJoinQuery =
    from category in categories
    join prod in products on category.ID equals prod.CategoryID into prodGroup
    select new { CategoryName = category.Name, Products = prodGroup };

Grup birleştirme sağ tarafındaki kaynak dizideki eşleşen öğelerin bir veya daha fazla sol kaynak dizisinin öğelerini ilişkilendirir bir hiyerarşik bir sonuç dizisi üretir.A group join produces a hierarchical result sequence, which associates elements in the left source sequence with one or more matching elements in the right side source sequence. Grup birleştirme eşdeğeri ilişkisel koşullarını vardır. Bu temelde bir nesne dizisidir.A group join has no equivalent in relational terms; it is essentially a sequence of object arrays.

Öğenin sol kaynakta, eşleştirilecek öğe için doğru kaynak sırasından bulunursa join yan tümcesi, o öğe için boş bir dizi üretir.If no elements from the right source sequence are found to match an element in the left source, the join clause will produce an empty array for that item. Sonuç dizisi gruplar halinde düzenlenir. Bu nedenle, group JOIN hala temelde iç-equijoin olmasıdır.Therefore, the group join is still basically an inner-equijoin except that the result sequence is organized into groups.

Grup birleştirme sonuçlarını seçmeniz yeterlidir, öğelere erişebilirsiniz, ancak bunlar üzerinde eşleşen anahtar tanımlayamaz.If you just select the results of a group join, you can access the items, but you cannot identify the key that they match on. Bu nedenle, önceki örnekte gösterildiği gibi anahtar adı olan yeni bir türe group JOIN sonuçlarını seçin genel olarak daha yararlı olur.Therefore, it is generally more useful to select the results of the group join into a new type that also has the key name, as shown in the previous example.

Ayrıca, bir grup birleştirme sonucu başka bir alt sorgu oluşturucu olarak kullanabilirsiniz:You can also, of course, use the result of a group join as the generator of another subquery:

var innerGroupJoinQuery2 =
    from category in categories
    join prod in products on category.ID equals prod.CategoryID into prodGroup
    from prod2 in prodGroup
    where prod2.UnitPrice > 2.50M
    select prod2;

Daha fazla bilgi için gruplandırılmış birleştirmeler gerçekleştirme.For more information, see Perform grouped joins.

Sol dış birleştirmeLeft outer join

Eşleşen bir öğe doğru sırada olsa bile bir sol dış birleştirme, soldaki kaynak dizisindeki tüm öğeleri, döndürülür.In a left outer join, all the elements in the left source sequence are returned, even if no matching elements are in the right sequence. Bir sol dış birleştirme gerçekleştirmek için LINQLINQ, kullanın DefaultIfEmpty sol taraftaki öğesi herhangi bir eşleşme varsa üretmek için bir varsayılan sağ taraftaki öğesi belirtmek için bir grup birleştirme birlikte yöntemi.To perform a left outer join in LINQLINQ, use the DefaultIfEmpty method in combination with a group join to specify a default right-side element to produce if a left-side element has no matches. Kullanabileceğiniz null olarak herhangi bir referans için varsayılan değer türü veya bir kullanıcı tanımlı tür belirtebilirsiniz.You can use null as the default value for any reference type, or you can specify a user-defined default type. Aşağıdaki örnekte, bir kullanıcı tarafından tanımlanan varsayılan türü gösterilmiştir:In the following example, a user-defined default type is shown:

var leftOuterJoinQuery =
    from category in categories
    join prod in products on category.ID equals prod.CategoryID into prodGroup
    from item in prodGroup.DefaultIfEmpty(new Product { Name = String.Empty, CategoryID = 0 })
    select new { CatName = category.Name, ProdName = item.Name };

Daha fazla bilgi için sol dış birleştirmeler gerçekleştirme.For more information, see Perform left outer joins.

Eşittir işleciThe equals operator

A join yan tümcesi equijoin gerçekleştirir.A join clause performs an equijoin. Diğer bir deyişle, iki anahtar eşitlik yalnızca temel eşleşmeleri ile kullanabilirsiniz.In other words, you can only base matches on the equality of two keys. Karşılaştırma "büyük" veya "eşit değildir" gibi diğer türleri desteklenmez.Other types of comparisons such as "greater than" or "not equals" are not supported. Tüm birleştirmeler equijoins, olduğunu netleştirmek için join yan tümcesi kullanan equals anahtar sözcüğü yerine == işleci.To make clear that all joins are equijoins, the join clause uses the equals keyword instead of the == operator. equals Anahtar sözcüğü yalnızca kullanılabilir bir join yan tümcesi ve farklıdır == önemli bir şekilde işleci.The equals keyword can only be used in a join clause and it differs from the == operator in one important way. İle equalssol ok tuşu dış kaynak dizisini tüketir ve sağ ok tuşu iç kaynak kullanır.With equals, the left key consumes the outer source sequence, and the right key consumes the inner source. Yalnızca sol tarafındaki kapsamda dış kaynağıdır equals ve iç kaynak yalnızca işlecin sağ tarafındaki kapsamda sırasıdır.The outer source is only in scope on the left side of equals and the inner source sequence is only in scope on the right side.

Olmayan equijoinsNon-equijoins

Çapraz birleştirme ve diğer özel birleştirme işlemleri olmayan-equijoins, birden çok kullanarak gerçekleştirebileceğiniz from yeni dizileri bağımsız olarak bir sorguya tanıtmak amacıyla yan tümceler.You can perform non-equijoins, cross joins, and other custom join operations by using multiple from clauses to introduce new sequences independently into a query. Daha fazla bilgi için özel birleştirme işlemleri gerçekleştirme.For more information, see Perform custom join operations.

Nesnesi koleksiyonlar ilişkisel tabloları ve birleşimlerJoins on object collections vs. relational tables

İçinde bir LINQLINQ sorgu ifadesinde, birleştirme işlemleri, nesne koleksiyonları üzerinde gerçekleştirilir.In a LINQLINQ query expression, join operations are performed on object collections. Nesne koleksiyonları "iki ilişkisel tabloları tam olarak aynı şekilde katılamaz".Object collections cannot be "joined" in exactly the same way as two relational tables. İçinde LINQLINQ, açık join yan tümceleri, yalnızca iki kaynak dizileri tarafından herhangi bir ilişki bağlanmayan gereklidir.In LINQLINQ, explicit join clauses are only required when two source sequences are not tied by any relationship. İle çalışırken LINQ - SQLLINQ to SQL, yabancı anahtar tabloları nesne modelinde birincil tablo özellikleri olarak temsil edilir.When working with LINQ - SQLLINQ to SQL, foreign key tables are represented in the object model as properties of the primary table. Örneğin, Northwind veritabanında yabancı anahtar ilişkisi Siparişler tablosu ile müşteri tablosu vardır.For example, in the Northwind database, the Customer table has a foreign key relationship with the Orders table. Tablolar için nesne modeli eşlediğinizde, müşteri sınıfı bu müşteriyle ilgili Siparişler topluluğu içeren bir sipariş özelliğine sahiptir.When you map the tables to the object model, the Customer class has an Orders property that contains the collection of Orders associated with that Customer. Aslında, birleştirme zaten sizin için yapılmıştır.In effect, the join has already been done for you.

Bağlamında ilgili tablolar üzerinden sorgulama hakkında daha fazla bilgi için LINQ - SQLLINQ to SQL, bkz: nasıl yapılır: Veritabanı ilişkileri eşleme.For more information about querying across related tables in the context of LINQ - SQLLINQ to SQL, see How to: Map Database Relationships.

Bileşik anahtarlarComposite keys

Bir bileşik anahtarı kullanılarak birden çok değer eşitliği test edebilirsiniz.You can test for equality of multiple values by using a composite key. Daha fazla bilgi için bileşik anahtarlar kullanarak birleştirme.For more information, see Join by using composite keys. Bileşik anahtarlar da kullanılabilir bir group yan tümcesi.Composite keys can be also used in a group clause.

ÖrnekExample

Aşağıdaki örnek, aynı eşleşen anahtarlar kullanılarak bir iç birleştirme, bir grup katma ve aynı veri kaynaklarında bir sol dış birleştirme sonuçlarının karşılaştırır.The following example compares the results of an inner join, a group join, and a left outer join on the same data sources by using the same matching keys. Bazı ek bir kod sonuçları konsol açıklamak için bu örnekleri eklenir.Some extra code is added to these examples to clarify the results in the console display.

   class JoinDemonstration
   {
       #region Data

       class Product
       {
           public string Name { get; set; }
           public int CategoryID { get; set; }
       }

       class Category
       {
           public string Name { get; set; }
           public int ID { get; set; }
       }

       // Specify the first data source.
       List<Category> categories = new List<Category>()
       { 
           new Category {Name="Beverages", ID=001},
           new Category {Name="Condiments", ID=002},
           new Category {Name="Vegetables", ID=003},
           new Category {Name="Grains", ID=004},
           new Category {Name="Fruit", ID=005}            
       };

       // Specify the second data source.
       List<Product> products = new List<Product>()
      {
         new Product {Name="Cola",  CategoryID=001},
         new Product {Name="Tea",  CategoryID=001},
         new Product {Name="Mustard", CategoryID=002},
         new Product {Name="Pickles", CategoryID=002},
         new Product {Name="Carrots", CategoryID=003},
         new Product {Name="Bok Choy", CategoryID=003},
         new Product {Name="Peaches", CategoryID=005},
         new Product {Name="Melons", CategoryID=005},
       };
       #endregion


       static void Main(string[] args)
       {
           JoinDemonstration app = new JoinDemonstration();

           app.InnerJoin();
           app.GroupJoin();
           app.GroupInnerJoin();
           app.GroupJoin3();
           app.LeftOuterJoin();
           app.LeftOuterJoin2();

           // Keep the console window open in debug mode.
           Console.WriteLine("Press any key to exit.");
           Console.ReadKey();
       }

       void InnerJoin()
       {
           // Create the query that selects 
           // a property from each element.
           var innerJoinQuery =
              from category in categories
              join prod in products on category.ID equals prod.CategoryID
              select new { Category = category.ID, Product = prod.Name };

           Console.WriteLine("InnerJoin:");
           // Execute the query. Access results 
           // with a simple foreach statement.
           foreach (var item in innerJoinQuery)
           {
               Console.WriteLine("{0,-10}{1}", item.Product, item.Category);
           }
           Console.WriteLine("InnerJoin: {0} items in 1 group.", innerJoinQuery.Count());
           Console.WriteLine(System.Environment.NewLine);

       }

       void GroupJoin()
       {
           // This is a demonstration query to show the output
           // of a "raw" group join. A more typical group join
           // is shown in the GroupInnerJoin method.
           var groupJoinQuery =
              from category in categories
              join prod in products on category.ID equals prod.CategoryID into prodGroup
              select prodGroup;

           // Store the count of total items (for demonstration only).
           int totalItems = 0;

           Console.WriteLine("Simple GroupJoin:");

           // A nested foreach statement is required to access group items.
           foreach (var prodGrouping in groupJoinQuery)
           {
               Console.WriteLine("Group:");
               foreach (var item in prodGrouping)
               {
                   totalItems++;
                   Console.WriteLine("   {0,-10}{1}", item.Name, item.CategoryID);
               }
           }
           Console.WriteLine("Unshaped GroupJoin: {0} items in {1} unnamed groups", totalItems, groupJoinQuery.Count());
           Console.WriteLine(System.Environment.NewLine);
       }

       void GroupInnerJoin()
       {
           var groupJoinQuery2 =
               from category in categories
               orderby category.ID
               join prod in products on category.ID equals prod.CategoryID into prodGroup
               select new
               {
                   Category = category.Name,
                   Products = from prod2 in prodGroup
                              orderby prod2.Name
                              select prod2
               };

           //Console.WriteLine("GroupInnerJoin:");
           int totalItems = 0;

           Console.WriteLine("GroupInnerJoin:");
           foreach (var productGroup in groupJoinQuery2)
           {
               Console.WriteLine(productGroup.Category);
               foreach (var prodItem in productGroup.Products)
               {
                   totalItems++;
                   Console.WriteLine("  {0,-10} {1}", prodItem.Name, prodItem.CategoryID);
               }
           }
           Console.WriteLine("GroupInnerJoin: {0} items in {1} named groups", totalItems, groupJoinQuery2.Count());
           Console.WriteLine(System.Environment.NewLine);
       }

       void GroupJoin3()
       {

           var groupJoinQuery3 =
               from category in categories
               join product in products on category.ID equals product.CategoryID into prodGroup
               from prod in prodGroup
               orderby prod.CategoryID
               select new { Category = prod.CategoryID, ProductName = prod.Name };

           //Console.WriteLine("GroupInnerJoin:");
           int totalItems = 0;

           Console.WriteLine("GroupJoin3:");
           foreach (var item in groupJoinQuery3)
           {
               totalItems++;
               Console.WriteLine("   {0}:{1}", item.ProductName, item.Category);
           }

           Console.WriteLine("GroupJoin3: {0} items in 1 group", totalItems);
           Console.WriteLine(System.Environment.NewLine);
       }

       void LeftOuterJoin()
       {
           // Create the query.
           var leftOuterQuery =
              from category in categories
              join prod in products on category.ID equals prod.CategoryID into prodGroup
              select prodGroup.DefaultIfEmpty(new Product() { Name = "Nothing!", CategoryID = category.ID });

           // Store the count of total items (for demonstration only).
           int totalItems = 0;

           Console.WriteLine("Left Outer Join:");

           // A nested foreach statement  is required to access group items
           foreach (var prodGrouping in leftOuterQuery)
           {
               Console.WriteLine("Group:");
               foreach (var item in prodGrouping)
               {
                   totalItems++;
                   Console.WriteLine("  {0,-10}{1}", item.Name, item.CategoryID);
               }
           }
           Console.WriteLine("LeftOuterJoin: {0} items in {1} groups", totalItems, leftOuterQuery.Count());
           Console.WriteLine(System.Environment.NewLine);
       }

       void LeftOuterJoin2()
       {
           // Create the query.
           var leftOuterQuery2 =
              from category in categories
              join prod in products on category.ID equals prod.CategoryID into prodGroup
              from item in prodGroup.DefaultIfEmpty()
              select new { Name = item == null ? "Nothing!" : item.Name, CategoryID = category.ID };

           Console.WriteLine("LeftOuterJoin2: {0} items in 1 group", leftOuterQuery2.Count());
           // Store the count of total items
           int totalItems = 0;

           Console.WriteLine("Left Outer Join 2:");

           // Groups have been flattened.
           foreach (var item in leftOuterQuery2)
           {
               totalItems++;
               Console.WriteLine("{0,-10}{1}", item.Name, item.CategoryID);
           }
           Console.WriteLine("LeftOuterJoin2: {0} items in 1 group", totalItems);
       }
   }
   /*Output:

   InnerJoin:
   Cola      1
   Tea       1
   Mustard   2
   Pickles   2
   Carrots   3
   Bok Choy  3
   Peaches   5
   Melons    5
   InnerJoin: 8 items in 1 group.


   Unshaped GroupJoin:
   Group:
       Cola      1
       Tea       1
   Group:
       Mustard   2
       Pickles   2
   Group:
       Carrots   3
       Bok Choy  3
   Group:
   Group:
       Peaches   5
       Melons    5
   Unshaped GroupJoin: 8 items in 5 unnamed groups


   GroupInnerJoin:
   Beverages
       Cola       1
       Tea        1
   Condiments
       Mustard    2
       Pickles    2
   Vegetables
       Bok Choy   3
       Carrots    3
   Grains
   Fruit
       Melons     5
       Peaches    5
   GroupInnerJoin: 8 items in 5 named groups


   GroupJoin3:
       Cola:1
       Tea:1
       Mustard:2
       Pickles:2
       Carrots:3
       Bok Choy:3
       Peaches:5
       Melons:5
   GroupJoin3: 8 items in 1 group


   Left Outer Join:
   Group:
       Cola      1
       Tea       1
   Group:
       Mustard   2
       Pickles   2
   Group:
       Carrots   3
       Bok Choy  3
   Group:
       Nothing!  4
   Group:
       Peaches   5
       Melons    5
   LeftOuterJoin: 9 items in 5 groups


   LeftOuterJoin2: 9 items in 1 group
   Left Outer Join 2:
   Cola      1
   Tea       1
   Mustard   2
   Pickles   2
   Carrots   3
   Bok Choy  3
   Nothing!  4
   Peaches   5
   Melons    5
   LeftOuterJoin2: 9 items in 1 group
   Press any key to exit.
   */

AçıklamalarRemarks

A join tarafından izlenmiyor yan tümcesi into erişimcisine bir Join yöntem çağrısı.A join clause that is not followed by into is translated into a Join method call. A join takip yan tümcesi into çevrildiğinde bir GroupJoin yöntem çağrısı.A join clause that is followed by into is translated to a GroupJoin method call.

Ayrıca bkz.See also