如何在Linq中完成一个完整的外连接？

Question

我已经继承了一个没有精确设计的数据库，我需要处理一些数据。让我举之类的话的一种较为常见的比喻我必须做的：

比方说，我们有一个Student表，所有他参加了类的StudentClass表记录保存和存储所有的教师StudentTeacher表谁教这个学生。是的，我知道这是一个愚蠢的设计，将老师存储在班级表上会更有意义 - 但这正是我们正在处理的内容。

我现在想要清理数据，我想找到学生有老师但没有班级，或班级但没有老师的所有地方。 SQL因此：

select * 
from StudentClass sc 
full outer join StudentTeacher st on st.StudentID = sc.StudentID 
where st.id is null or sc.id is null 

你在Linq怎么做？

Answer 1

我认为有回答在这里，这是不是我所希望的优雅，但它应该做的伎俩：

var studentIDs = StudentClasses.Select(sc => sc.StudentID) 
    .Union(StudentTeachers.Select(st => st.StudentID); 
    //.Distinct(); -- Distinct not necessary after Union 
var q = 
    from id in studentIDs 
    join sc in StudentClasses on id equals sc.StudentID into jsc 
    from sc in jsc.DefaultIfEmpty() 
    join st in StudentTeachers on id equals st.StudentID into jst 
    from st in jst.DefaultIfEmpty() 
    where st == null^sc == null 
    select new { sc, st }; 

你可以这两个语句可能挤入一个，但我想你” d牺牲代码清晰度。

Answer 2

一个开始......

var q = from sc in StudentClass 
      join st in StudentTeachers on sc.StudentID equals st.StudentID into g 
      from st in g.DefaultIfEmpty() 
      select new {StudentID = sc.StudentID, StudentIDParent = st == null ? "(no StudentTeacher)" : st.StudentID...........}; 

也http://www.linqpad.net/中查看样本 好工具，

Answer 3

对于给定的2个集一个和b，所需的完整外部联接玩可能如下：

a.Union(b).Except(a.Intersect(b)); 

如果和B不相同类型的，则2个独立左外联接是必需的：

var studentsWithoutTeachers = 
    from sc in studentClasses 
    join st in studentTeachers on sc.StudentId equals st.StudentId into g 
    from st in g.DefaultIfEmpty() 
    where st == null 
    select sc; 
var teachersWithoutStudents = 
    from st in studentTeachers 
    join sc in studentClasses on st.StudentId equals sc.StudentId into g 
    from sc in g.DefaultIfEmpty() 
    where sc == null 
    select st; 

这里是使用的毗连（）一个行选项：

(from l in left 
join r in right on l.Id equals r.Id into g 
from r in g.DefaultIfEmpty() 
where r == null 
select new {l, r}) 
    .Concat(
    from r in right 
    join sc in left on r.Id equals sc.Id into g 
    from l in g.DefaultIfEmpty() 
    where l == null 
    select new {l, r}); 

Answer 4

扩展方法：

public static IEnumerable<TResult> FullOuterJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter,TKey> outerKeySelector, Func<TInner,TKey> innerKeySelector, Func<TOuter,TInner,TResult> resultSelector) 
       where TInner : class 
       where TOuter : class 
      { 
       var innerLookup = inner.ToLookup(innerKeySelector); 
       var outerLookup = outer.ToLookup(outerKeySelector); 

       var innerJoinItems = inner 
        .Where(innerItem => !outerLookup.Contains(innerKeySelector(innerItem))) 
        .Select(innerItem => resultSelector(null, innerItem)); 

       return outer 
        .SelectMany(outerItem => 
         { 
          var innerItems = innerLookup[outerKeySelector(outerItem)]; 

          return innerItems.Any() ? innerItems : new TInner[] { null }; 
         }, resultSelector) 
        .Concat(innerJoinItems); 
      } 

测试：

[Test] 
public void CanDoFullOuterJoin() 
{ 
    var list1 = new[] {"A", "B"}; 
    var list2 = new[] { "B", "C" }; 

    list1.FullOuterJoin(list2, x => x, x => x, (x1, x2) => (x1 ?? "") + (x2 ?? "")) 
     .ShouldCollectionEqual(new [] { "A", "BB", "C"}); 
} 

Answer 5

基于沙乌尔的答案，但有一点精简：

var q = 
    from id in studentIDs 
    join sc in StudentClasses on id equals sc.StudentID into jsc 
    join st in StudentTeachers on id equals st.StudentID into jst 
    where jst.Any()^jsc.Any() //exclusive OR, so one must be empty 

    //this will return the group with the student's teachers, and an empty group 
    // for the student's classes - 
    // or group of classes, and empty group of teachers 
    select new { classes = jsc, teachers = jst }; 

    //or, if you know that the non-empty group will always have only one element: 
    select new { class = jsc.DefaultIfEmpty(), teacher = jst.DefaultIfEmpty() }; 

注意，对于全外连接，这也可以工作。删除where子句并使用上面的第一个select，而不是第二个。