如何合并两个列表？

Question

I have two lists (ObservableCollections) of following class:

public class Data
{
    public string Key { get; set; }
    public string Value { get; set; }
}

One representing old objects ( listA ) and second representing updated ones ( listB ). I want to merge new data from listB to listA without breaking any references. More precisely I want to do the following:

• Remove from listA all objects that do not exist in listB (objects are compared by Key property)
• Add to listA all objects from listB that do not exist in listA
• Update Value property for all objects in listA that are present in both lists

Can you propose some efficient way to do that? My solution is big and seems very ineffective.

Update: Current solution is:

public void MergeInstanceList(List<Instance> instances)
{
    var dicOld = Instances.ToDictionary(a => a.Ip);
    var dicNew = instances.ToDictionary(a => a.Ip);
    var forUpdate = instances.Intersect(Instances, new Comparer()).ToList();
    Instances.Where(a => !dicNew.Keys.Contains(a.Ip)).ToList().ForEach(a => Instances.Remove(a));
    instances.Where(a => !dicOld.Keys.Contains(a.Ip)).ToList().ForEach(a => Instances.Add(a));
    forUpdate.ForEach(a => dicOld[a.Ip].Name = a.Name);
}
public class Comparer : IEqualityComparer<Instance>
{

    public bool Equals(Instance x, Instance y)
    {
        return x.Ip == y.Ip;
    }

    public int GetHashCode(Instance obj)
    {
        return obj.Ip.GetHashCode();
    }
}

Answer 1

var listA = ...;
var listB = ...;

var itemsToRemove = new HashSet<Data>(listA.Except(listB));
var itemsToAdd = listB.Except(listA);
var itemsToUpdate = listA.Join(listB, a => listA.Key, b => listB.Key, 
            (a, b) => new
            {
                First = a,
                Second = b
            });

listA.AddRange(itemsToAdd);
listA.RemoveAll(item => itemsToRemove.Contains);
foreach(var pair in itemsToUpdate)
{
  //set properties in First to be that of second
}

As is mentioned in another answer, you will need to create a custom comparer and pass it into the two Except methods for them to work properly, or you will need to override the Equals and GetHashCode methods to be based off of just Key .

Answer 2

With following EqualityComparer ,

public class DataEqualityComparer : IEqualityComparer<Data>
{
    public bool Equals(Data x, Data y)
    {
        return x != null && y != null && x.Key == y.Key;
    }

    public int GetHashCode(Data obj)
    {
        return obj.Key.GetHashCode();
    }
}

You can find out elements like following:

DataEqualityComparer comparer = new DataEqualityComparer();

var InListAButNotInListB = listA.Except(listB, comparer);
var InListBButNotInListA = listB.Except(listA, comparer);

var InListAThatAreAlsoInListB = listA.Intersect(listB, comparer).OrderBy(item => item.Key);
var InListBThatAreAlsoInListA = listB.Intersect(listA, comparer).OrderBy(item => item.Key);

var InBothLists = InListAButNotInListB.Zip(InListBButNotInListA, (fromListA, fromListB) => new { FromListA = fromListA, FromListB = fromListB });

Answer 3

Assuming Key is unique, and that replacing the listA ObservableCollection instance is forbidden...

Dictionary<string, Data> aItems = listA.ToDictionary(x => x.Key);
Dictionary<string, Data> bItems = listB.ToDictionary(x => x.Key);

foreach(Data a in aItems.Values)
{
  if (!bItems.ContainsKey(a.Key))
  {
    listA.Remove(a); //O(n)  :(
  }
  else
  {
    a.Value = bItems[a.Key].Value;
  }
}

foreach(Data b in bItems.Values)
{
  if (!aItems.ContainsKey(b.Key)
  {
    listA.Add(b);
  }
}

The dictionaries give O(1) lookups between the collections, and provide a copy to enumerate over (so we don't get the "can't modify collections that are being enumerated" exception). This should be O(n) as long as nothing is removed. The worst case is O(n^2) if everything is removed.

If the listA ObservableCollection instance isn't required to hold the answer, it's better to create a listC instance and add everything that should be there (Remove is so bad).

Answer 4

System.Linq.Enumerable doesn't have a Full Outer join method, but we can build our own.

//eager full outer joiner for in-memory collections.
public class FullOuterJoiner<TLeft, TRight, TKey>
{
  public List<TLeft> LeftOnly {get;set;}
  public List<TRight> RightOnly {get;set;}
  public List<Tuple<TLeft, TRight>> Matches {get;set;}

  public FullOuterJoiner(
    IEnumerable<TLeft> leftSource, IEnumerable<TRight> rightSource,
    Func<TLeft, TKey> leftKeySelector, Func<TRight, TKey> rightKeySelector
  )
  {
    LeftOnly = new List<TLeft>();
    RightOnly = new List<TRight>();
    Matches = List<Tuple<TLeft, TRight>>();

    ILookup<TKey, TLeft> leftLookup = leftSource.ToLookup(leftKeySelector);
    ILookup<TKey, TRight> rightLookup = rightSource.ToLookup(rightKeySelector);

    foreach(IGrouping<TKey, TLeft> leftGroup in leftLookup)
    {
      IGrouping<TKey, TRight> rightGroup = rightLookup[leftGroup.Key];
      if (!rightGroup.Any()) //no match, items only in left
      {
        LeftOnly.AddRange(leftGroup);
      }
      else  //matches found, generate tuples
      {
        IEnumerable<Tuple<TLeft, TRight>> matchedTuples =
          from leftItem in leftGroup
          from rightItem in rightGroup
          select Tuple.Create<TLeft, TRight>(leftItem, rightItem);

        Matches.AddRange(matchedTuples);
      }
    }
    foreach(IGrouping<TKey, TRight> rightGroup in rightLookup)
    {
      IGrouping<TKey, TLeft> leftGroup = leftLookup[rightGroup.Key];
      if (!leftGroup.Any()) //no match, items only in right
      {
        RightOnly.AddRange(rightGroup);
      }
    }
  }
}

For this question, it can be used this way:

ObservableCollection<Data> listA = GetListA();
ObservableCollection<Data> listB = GetListB();

FullOuterJoiner<Data, Data, string> joiner =
  new FullOuterJoiner(listA, listB, a => a.Key, b => b.Key);

foreach(Data a in joiner.LeftOnly)
{
  listA.Remove(a);  // O(n), sigh
}
foreach(Data b in joiner.RightOnly)
{
  listA.Add(b);
}
foreach(Tuple<Data, Data> tup in joiner.Matched)
{
  tup.Item1.Value = tup.Item2.Value;
}