LEFT OUTER JOIN in LINQ

Question

Wie führt man eine linke äußere Verknüpfung in C# LINQ to objects ohne Verwendung von join-on-equals-into Klauseln? Gibt es eine Möglichkeit, dies zu tun mit where Klausel? Richtiges Problem: Für inner join ist einfach und ich habe eine Lösung wie diese

List<JoinPair> innerFinal = (from l in lefts from r in rights where l.Key == r.Key
                             select new JoinPair { LeftId = l.Id, RightId = r.Id})

aber für die linke äußere Verbindung brauche ich eine Lösung. Meine ist etwas wie dieses, aber es funktioniert nicht

List< JoinPair> leftFinal = (from l in lefts from r in rights
                             select new JoinPair { 
                                            LeftId = l.Id, 
                                            RightId = ((l.Key==r.Key) ? r.Id : 0
                                        })

donde JoinPair ist eine Klasse:

public class JoinPair { long leftId; long rightId; }

Answer 1

Wie in "Linke äußere Verknüpfungen durchführen" :

var q =
    from c in categories
    join p in products on c.Category equals p.Category into ps
    from p in ps.DefaultIfEmpty()
    select new { Category = c, ProductName = p == null ? "(No products)" : p.ProductName };

Answer 2

Wenn ein datenbankgestützter LINQ-Anbieter verwendet wird, kann eine wesentlich lesbarere linke äußere Verknüpfung als solche geschrieben werden:

from maintable in Repo.T_Whatever 
from xxx in Repo.T_ANY_TABLE.Where(join condition).DefaultIfEmpty()

Wenn Sie die DefaultIfEmpty() haben Sie eine innere Verbindung.

Nehmen Sie die akzeptierte Antwort:

  from c in categories
    join p in products on c equals p.Category into ps
    from p in ps.DefaultIfEmpty()

Diese Syntax ist sehr verwirrend, und es ist nicht klar, wie sie funktioniert, wenn man MEHRERE Tabellen links verknüpfen will.

Hinweis
Es ist zu beachten, dass from alias in Repo.whatever.Where(condition).DefaultIfEmpty() ist dasselbe wie ein outer-apply/left-join-lateral, das jeder (anständige) Datenbank-Optimierer perfekt in einen left-join übersetzen kann, solange Sie keine per-row-Werte einführen (aka ein tatsächliches outer apply). Tun Sie dies nicht in Linq-2-Objects (denn es gibt keine DB-Optimierer, wenn Sie Linq-to-Objects verwenden).

Ausführliches Beispiel

var query2 = (
    from users in Repo.T_User
    from mappings in Repo.T_User_Group
         .Where(mapping => mapping.USRGRP_USR == users.USR_ID)
         .DefaultIfEmpty() // <== makes join left join
    from groups in Repo.T_Group
         .Where(gruppe => gruppe.GRP_ID == mappings.USRGRP_GRP)
         .DefaultIfEmpty() // <== makes join left join

    // where users.USR_Name.Contains(keyword)
    // || mappings.USRGRP_USR.Equals(666)  
    // || mappings.USRGRP_USR == 666 
    // || groups.Name.Contains(keyword)

    select new
    {
         UserId = users.USR_ID
        ,UserName = users.USR_User
        ,UserGroupId = groups.ID
        ,GroupName = groups.Name
    }

);

var xy = (query2).ToList();

Bei Verwendung von LINQ 2 SQL lässt sich die folgende sehr gut lesbare SQL-Abfrage erstellen:

SELECT 
     users.USR_ID AS UserId 
    ,users.USR_User AS UserName 
    ,groups.ID AS UserGroupId 
    ,groups.Name AS GroupName 
FROM T_User AS users

LEFT JOIN T_User_Group AS mappings
   ON mappings.USRGRP_USR = users.USR_ID

LEFT JOIN T_Group AS groups
    ON groups.GRP_ID == mappings.USRGRP_GRP

Editar:

Siehe auch " SQL Server-Abfrage in Linq-Abfrage konvertieren " für ein komplexeres Beispiel.

Auch, wenn Sie es in Linq-2-Objekte (anstelle von Linq-2-SQL) tun, sollten Sie es die altmodische Art und Weise tun (weil LINQ to SQL dies korrekt auf Join-Operationen übersetzt, aber über Objekte erzwingt diese Methode einen vollständigen Scan, und nutzt nicht die Vorteile der Indexsuche, warum auch immer...):

    var query2 = (
    from users in Repo.T_Benutzer
    join mappings in Repo.T_Benutzer_Benutzergruppen on mappings.BEBG_BE equals users.BE_ID into tmpMapp
    join groups in Repo.T_Benutzergruppen on groups.ID equals mappings.BEBG_BG into tmpGroups
    from mappings in tmpMapp.DefaultIfEmpty()
    from groups in tmpGroups.DefaultIfEmpty()
    select new
    {
         UserId = users.BE_ID
        ,UserName = users.BE_User
        ,UserGroupId = mappings.BEBG_BG
        ,GroupName = groups.Name
    }

);

Answer 3

Lambda-Ausdruck verwenden

db.Categories    
  .GroupJoin(db.Products,
      Category => Category.CategoryId,
      Product => Product.CategoryId,
      (x, y) => new { Category = x, Products = y })
  .SelectMany(
      xy => xy.Products.DefaultIfEmpty(),
      (x, y) => new { Category = x.Category, Product = y })
  .Select(s => new
  {
      CategoryName = s.Category.Name,     
      ProductName = s.Product.Name   
  });

Answer 4

Jetzt als Erweiterungsmethode:

public static class LinqExt
{
    public static IEnumerable<TResult> LeftOuterJoin<TLeft, TRight, TKey, TResult>(this IEnumerable<TLeft> left, IEnumerable<TRight> right, Func<TLeft, TKey> leftKey, Func<TRight, TKey> rightKey,
        Func<TLeft, TRight, TResult> result)
    {
        return left.GroupJoin(right, leftKey, rightKey, (l, r) => new { l, r })
             .SelectMany(
                 o => o.r.DefaultIfEmpty(),
                 (l, r) => new { lft= l.l, rght = r })
             .Select(o => result.Invoke(o.lft, o.rght));
    }
}

Verwenden Sie es so, wie Sie normalerweise join verwenden würden:

var contents = list.LeftOuterJoin(list2, 
             l => l.country, 
             r => r.name,
            (l, r) => new { count = l.Count(), l.country, l.reason, r.people })

Ich hoffe, das spart Ihnen etwas Zeit.

Answer 5

Schauen Sie sich das an Beispiel . Diese Abfrage sollte funktionieren:

var leftFinal = from left in lefts
                join right in rights on left equals right.Left into leftRights
                from leftRight in leftRights.DefaultIfEmpty()
                select new { LeftId = left.Id, RightId = left.Key==leftRight.Key ? leftRight.Id : 0 };