Linq查询合并2个列表

Question

我有2个列表，我需要合并来自A和B的连接值，但也包括来自A和B的与连接不匹配的值。

class TypeA 
{ 
    public string Key { get; set; } 
    public int ValueA { get; set; } 
} 

class TypeB 
{ 
    public string Key { get; set; } 
    public int ValueB { get; set; } 
} 

class TypeAB 
{ 
    public string Key { get; set; } 
    public int ValueA { get; set; } 
    public int ValueB { get; set; } 
} 

var listA = new List<TypeA> 
{ 
    new TypeA { Key = "one", Value = 1 }, 
    new TypeA { Key = "two", Value = 2 }, 
}; 

var listB = new List<TypeB> 
{ 
    new TypeB { Key = "two", Value = 2 }, 
    new TypeB { Key = "three", Value = 3 }, 
}; 

我想这些列表合并等于这个：

var listAB = new List<TypeAB> 
{ 
    new TypeAB { Key = "one", ValueA = 1, ValueB = null }, 
    new TypeAB { Key = "two", ValueA = 2, ValueB = 2 }, 
    new TypeAB { Key = "three", ValueA = null, ValueB = 3 }, 
}; 

什么是Linq的语句，将做到这一点？我一直在玩，不能完全到达那里。我可以通过在A到B和Union上进行左外连接来获得差不多的空间，但是我会得到重复的相交值。

更新

这里是我根据乔治的回答是什么：

var joined = 
    (from a in listA 
     join b in listB 
     on a.Key equals b.Key 
     into listBJoin 
     from b in listBJoin.DefaultIfEmpty(new TypeB()) 
     select new TypeAB 
     { 
     Key = a.Key, 
     ValueA = a.ValueA, 
     ValueB = b.ValueB, 
     }).Union(
     from b in listB 
     where !listA.Any(d => d.Key == b.Key) 
     select new TypeAB 
     { 
      Key = b.Key, 
      ValueB = b.ValueB, 
     } 
     ).ToList(); 

Answer 1

编辑：搞掂。这是马虎，但它应该工作。

listA //Start with lisA 
.Where(a=>!listB.Any(b=>a.Key == b.Key)) // Remove any that are duplicated in listB 
.Select(a => new TypeAB() { Key=a.Key, ValueA=a.Value}) // Map each A to an AB 
.Union(
    listB.Select(b => { 
     var correspondingA = listA.FirstOrDefault(a => a.Key == b.Key); //Is there an a that corresponds? 
    return new TypeAB() { Key=b.Key, 
     ValueB=b.Value, //Value B is easy 
     ValueA= correspondingA!=null ? (int?)correspondingA.Value : null //If there is an A than map its value 
    }; 
    }) 
) 

顺便说一句，如果你使用这个作为某种域操作，类型A和类型B的可能应该基于某种AorBIsAConceptThatHasMeaningInTheDomain基类。只要您发现自己将列表结合起来，这只是一个通用规则。如果不存在这样的概念，那么你可能不需要组合这些列表。另一方面，如果您将这作为映射的一部分（例如将域对象映射到UI），则可以使用匿名类型而不是TypeAB类来简化代码。 （或许不是，这只能靠个人喜好）

编辑编辑 下面是使用哈希

 var listAB = listA.Cast<object>().Union(listB.Cast<object>()).ToLookup(x => x is TypeA ? (x as TypeA).Key : (x as TypeB).Key) 
       .Select(kv => { 
        var a = kv.FirstOrDefault(x => x is TypeA) as TypeA; 
        var b = kv.FirstOrDefault(x => x is TypeB) as TypeB; 
        return new TypeAB() { 
         Key = kv.Key, 
         ValueA = a != null ? (int?)a.Value : null, 
         ValueB = b != null ? (int?)b.Value : null 
        }; 
       }).ToList(); 

Answer 2

正是这种情况下，在我们的项目中，我们使用延长稍微理智有趣的答案称为Merge的方法。

public static class Extensions 
{ 
    public static IEnumerable<TResult> Merge<TLeft, TRight, TKey, TResult>(
     this IEnumerable<TLeft> leftList, 
     IEnumerable<TRight> rightList, 
     Func<TLeft, TKey> leftKeySelector, 
     Func<TRight, TKey> rightKeySelector, 
     Func<TKey, IEnumerable<TLeft>, IEnumerable<TRight>, TResult> combiner) 
    { 
     var leftLookup = leftList.ToLookup(leftKeySelector); 
     var rightLookup = rightList.ToLookup(rightKeySelector); 

     var keys = leftLookup.Select(g => g.Key).Concat(rightLookup.Select(g => g.Key)).Distinct(); 
     return keys.Select(key => combiner(key, leftLookup[key], rightLookup[key]));   
    } 
} 

您可以使用合并这样

var listAB = listA.Merge(
    listB, 
    a => a.Key, 
    b => b.Key, 
    (key, aItems, bItems) => new TypeAB 
    { 
     Key = key, 
     ValueA = aItems.Select(a => (int?)a.Value).SingleOrDefault(), 
     ValueB = bItems.Select(b => (int?)b.Value).SingleOrDefault() 
    });