join düğümü (C# Referansı)

Nesne modelinde join doğrudan ilişkisi olmayan farklı kaynak dizilerindeki öğeleri ilişkilendirmek için yan tümcesini kullanın. Tek gereksinim, her kaynaktaki öğelerin eşitlik için karşılaştırabileceğiniz bir değer paylaşmasıdır. Örneğin, bir gıda dağıtımcısının belirli bir ürünün tedarikçilerinin listesi ve alıcıların listesi olabilir. Bir yan tümceyi kullanarak join bu ürünün belirtilen bölgede bulunan tedarikçilerinin ve alıcılarının listesini oluşturabilirsiniz.

C# dili başvuru belgesi, C# dilinin en son yayımlanan sürümünü gösterir. Ayrıca, yaklaşan dil sürümü için genel önizlemelerdeki özelliklere yönelik ilk belgeleri içerir.

Belgelerde ilk olarak dilin son üç sürümünde veya geçerli genel önizlemelerde sunulan tüm özellikler tanımlanır.

Tavsiye

Bir özelliğin C# dilinde ilk tanıtıldığı zamanları bulmak için C# dil sürümü geçmişi makalesine bakın.

Bir join cümlesi, giriş olarak iki kaynak dizisini alır. Her dizideki öğeler, diğer dizideki karşılık gelen bir özellikle karşılaştırabileceğiniz bir özellik olmalıdır veya içermelidir. join yan tümcesi, belirtilen anahtarları eşitlik için karşılaştırmak için özel equals anahtar sözcüğünü kullanır. Yan tümcesinin join gerçekleştirdiği tüm birleşimler eş birleşimlerdir. Yan join tümcesinin çıkışının şekli, gerçekleştirdiğiniz belirli birleştirme türüne bağlıdır. Aşağıdaki listede en yaygın üç birleştirme türü gösterilmektedir:

• İç birleşim
• Gruba katılma
• Sol dışa birleşim

İç birleşim

Aşağıdaki örnekte basit bir iç birleşim gösterilmektedir. Bu sorgu düz bir "ürün adı / kategori" çiftleri dizisi oluşturur. Aynı kategori dizesi birden çok öğede görünür. öğesinden categories eşleşen bir öğe yoksa products, bu kategori sonuçlarda görünmez.

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 bkz. İç birleşimleri gerçekleştirme.

Gruba katılma

Bir join ifadeyle into tümceye grup birleştirme denir.

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, sol kaynak dizisindeki öğeleri sağ taraftaki kaynak dizisindeki bir veya daha fazla eşleşen öğeyle ilişkilendiren hiyerarşik bir sonuç dizisi oluşturur. Grup birleştirmenin ilişkisel terimlerde eşdeğeri yoktur; temelde bir nesne dizileri dizisidir.

Sağ kaynak dizisindeki hiçbir öğe sol kaynaktaki bir öğeyle eşleşmiyorsa yan tümcesi join bu öğe için boş bir dizi oluşturur. Bu nedenle, sonuç dizisinin gruplar halinde düzenlenmesi dışında, grup birleştirme işlemi hala temel olarak bir iç-eşbirleşimdir.

Yalnızca bir grup katılımının sonuçlarını seçerseniz öğelere erişebilirsiniz, ancak bunların eşleşip eşleşmediğini belirleyemezsiniz. Bu nedenle, önceki örnekte gösterildiği gibi grup birleştirmenin sonuçlarını anahtar adı da olan yeni bir türe seçmek genellikle daha yararlıdır.

Ayrıca, bir grup birleştirme işleminin sonucunu başka bir alt sorgunun oluşturucu olarak da kullanabilirsiniz:

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 bkz. Gruplandırılmış birleştirmeleri gerçekleştirme.

Sol dışa birleşim

Sol dış birleşimde sorgu, doğru sırada eşleşen öğe olmasa bile sol kaynak dizisindeki tüm öğeleri döndürür. LINQ'te bir sol dış birleşim gerçekleştirmek için, sol taraftaki bir öğenin eşleşmesi olmadığında üretilecek varsayılan bir sağ taraf öğesini belirtmek amacıyla bir grup birleşimiyle birlikte DefaultIfEmpty yöntemini kullanın. Herhangi bir başvuru türü için varsayılan değer olarak kullanabilir null veya kullanıcı tanımlı bir varsayılan tür belirtebilirsiniz. Aşağıdaki örnekte, kullanıcı tanımlı bir varsayılan tür gösterilir:

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 bkz. Sol dış birleştirmeleri gerçekleştirin.

equals işleci

Bir join tümcesi bir eşit birleşim gerçekleştirir. Başka bir deyişle, eşleşmeleri yalnızca iki anahtarın eşitliğine dayandırabilirsiniz. "büyüktür" veya "eşit değildir" gibi diğer karşılaştırma türleri desteklenmez. Tüm birleşimlerin eş birleşimler olduğunu açıkça belirtmek için join yan tümcesi, equals anahtar kelimesini == işleci yerine kullanır. Anahtar kelime equals sadece bir join yan tümcede kullanılabilir ve bazı önemli açılardan == işleçten farklılık gösterir. Dizeleri karşılaştırırken, equals değere göre karşılaştırmak için aşırı yüklenmiştir ve işleç == başvuru eşitliğini kullanır. Karşılaştırmanın her iki tarafı da aynı dize değişkenlerine equals sahip olduğunda ve == aynı sonuca ulaştığında: true. Bunun nedeni, bir program iki veya daha fazla eşdeğer dize değişkeni bildirdiğinde derleyicinin tümünü aynı konumda depolamasıdır. Bu, stajyerlik olarak bilinir. Bir diğer önemli fark null karşılaştırmadır: null equals null işleç ile equals false olarak değerlendirilir, bunu true olarak değerlendiren == işleci yerine. Son olarak, kapsam belirleme davranışı farklıdır: equals ile, sol anahtar dış kaynak sırasını, sağ anahtar ise iç kaynak sırasını kullanır. Dış kaynak yalnızca equals'nin sol tarafında ve iç kaynak dizisi yalnızca sağ tarafında kapsamdadır.

Eşit olmayan bağlantılar

Sorgunuza bağımsız olarak yeni diziler eklemek için birden fazla from yan tümcesi kullanarak denk olmayan birleştirmeler, çapraz birleştirmeler ve diğer özel birleştirme işlemlerini gerçekleştirebilirsiniz. Daha fazla bilgi için bkz. Özel birleştirme işlemleri gerçekleştirme.

Nesne koleksiyonları ile ilişkisel tablolar üzerindeki birleşimler kıyaslaması

LINQ sorgu ifadesinde, nesne koleksiyonlarında birleştirme işlemleri gerçekleştirirsiniz. Nesne koleksiyonlarını iki ilişkisel tabloyla aynı şekilde birleştiremezsiniz. LINQ'de yalnızca iki kaynak dizisinin ilişkisi olmadığında açık join yan tümcelere ihtiyacınız vardır. LINQ to SQL ile çalışırken, nesne modeli yabancı anahtar tablolarını birincil tablonun özellikleri olarak temsil eder. Örneğin, Northwind veritabanında Customer tablosunun Orders tablosuyla yabancı anahtar ilişkisi vardır. Tabloları nesne modeliyle eşlediğinizde, Customer sınıfının bu Müşteri ile ilişkili koleksiyonunu Orders içeren bir Orders özelliği vardır. Aslında birleştirme sizin için zaten yapılmıştır.

LINQ ile SQL bağlamında ilgili tablolar arasında sorgulama hakkında daha fazla bilgi için bkz . Nasıl yapılır: Veritabanı İlişkilerini Eşleme.

Bileşik anahtarlar

Bileşik anahtar kullanarak birden çok değerin eşitliğini test edebilirsiniz. Daha fazla bilgi için bkz. Bileşik anahtarları kullanarak birleştirme. Bileşik anahtarları yan group tümcesinde de kullanabilirsiniz.

Örnek

Aşağıdaki örnek, aynı eşleşen anahtarları kullanarak aynı veri kaynaklarında iç birleşim, grup birleştirme ve sol dış birleşim sonuçlarını karşılaştırır. Konsol ekranındaki sonuçları netleştirmek için bu örneklere bazı ek kodlar eklenir.

class JoinDemonstration
{
    #region Data

    class Product
    {
        public required string Name { get; init; }
        public required int CategoryID { get; init; }
    }

    class Category
    {
        public required string Name { get; init; }
        public required int ID { get; init; }
    }

    // Specify the first data source.
    List<Category> categories =
    [
        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 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();
    }

    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: {innerJoinQuery.Count()} items in 1 group.");
        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: {totalItems} items in {groupJoinQuery.Count()} unnamed groups");
        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: {totalItems} items in {groupJoinQuery2.Count()} named groups");
        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($"   {item.ProductName}:{item.Category}");
        }

        Console.WriteLine($"GroupJoin3: {totalItems} items in 1 group");
        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: {totalItems} items in {leftOuterQuery.Count()} groups");
        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: {leftOuterQuery2.Count()} items in 1 group");
        // 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: {totalItems} items in 1 group");
    }
}
/*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çıklamalar

Tarafından join takip into edilen bir yan tümcesi bir Join yöntem çağrısına çevrilir. Ardından join gelen bir yan tümce bir intoGroupJoin yöntem çağrısına çevrilir.

Ayrıca bkz.

• Sorgu Anahtar Sözcükleri (LINQ)
• Dil ile Tümleşik Sorgu (LINQ)
• Birleştirme İşlemleri
• grup maddesi
• Sol dış birleşim gerçekleştir
• İç birleşimler gerçekleştir
• Gruplandırılmış birleştirmeler gerçekleştirme
• Birleştirme yan tümcesinin sonuçlarını sıralayın
• Bileşik anahtarları kullanarak birleştirme
• Visual Studio için uyumlu veritabanı sistemleri