How to compare list of X to list of Y in C# by using generics?

Question

I have 2 classes, X and Y. Both classes have same similar property like below.

class X
{
    public string T1 { get; set; }
    public string T2 { get; set; }
    public string T3 { get; set; }
}

class Y
{
    public string T1 { get; set; }
    public string T2 { get; set; }
    public string T3 { get; set; }

    public string O1 { get; set; }
}

I've couple hundreds classes similar to X and Y; similar structure, and I decide to create generic class for this problem.

I have list of X and Y and I want to compare them by T1; only 1 property, to find out which element exist on both list, which element exist only on X and only on Y.

How can I do this?

Answer 1

If you want a reusable answer, not specific to class X and class Y, you'll need reflection. Take a look at Type.GetProperty and PropertyInfo.GetGetMethod.

EDIT: I seem to be getting downvotes from people who aren't familiar with reflection, so I'll add some example source code:

static class PropertyGetter<X>
{
  private static readonly Dictionary<string, Converter<X, object>> cached;

  public Converter<X, object> this[string propertyName]
  {
    get {
      Converter<X, object> result;
      lock (this) if (!cached.TryGetValue(propertyName, out result)) {
        PropertyInfo pi = typeof(X).GetProperty(propertyName, true);
        if (pi == null) throw new ArgumentException("Type " + typeof(X).Name + " has no property named " + propertyName, propertyName);
         MethodInfo getter = pi.GetGetMethod();
         if (getter == null) throw new ArgumentException("Type " + typeof(X).Name + " has a property named " + propertyName + " but it is not readable", propertyName);
         result = (Converter<X, object>)Delegate.CreateDelegate(typeof (Converter<X, object>), getter);
         cached.Add(propertyName, result);
       }
       return result;
     }
  }
}

public class Pair<S,T>
{
   public readonly S first;
   public readonly T second;
   public Pair(S s, T t) { first = s; second = t; }
}

List<Pair<X, Y>> FindCommonEntries<X, Y>(IEnumerable<X> listA, IEnumerable<Y> listB, string propertyNameA, string propertyNameB, out List<X> onlyA, out List<Y> onlyB)
{
    return FindCommonEntries<X,Y>(listA, listB, PropertyGetter<X>[propertyName], PropertyGetter<Y>[propertyName], out onlyA, out onlyB);
}

List<Pair<X, Y>> FindCommonEntries<X, Y>(IEnumerable<X> listA, IEnumerable<Y> listB, Converter<X, object> getA, Converter<Y, object> getB, out List<X> onlyA, out List<Y> onlyB)
{
    Dictionary<object, Pair<List<X>, bool>> mapA = new Dictionary<object, X>();
    foreach (X x in listA) {
      Pair<List<X>,bool> set;
      object key = getA(x);
      if (!mapA.TryGetValue(key, out set))
        mapA.Add(key, set = new Pair<List<X>, bool>(new List<X>(), false));
      set.first.Add(x);
    }

    onlyB = new List<Y>();
    List<Pair<X, Y>> common = new List<Pair<X, Y>>();
    foreach (Y y in listB) {
      Pair<List<X>,bool> match;
      if (mapA.TryGetValue(getB(y), out match)) {
        foreach (X x in match.first) common.Add(x, y);
        match.second = true;
      }
      else
        onlyB.Add(y);
    }

    onlyA = new List<X>();
    foreach (Pair<List<X>, bool> set in mapA.Values) {
      if (!set.second) onlyA.AddRange(set.first);
    }

    return common;
}

EDIT: Added lists of elements without any match.

EDIT: Separated reflection code, so it can be avoided by passing in a lambda.

EDIT: Use Converter delegate type instead of Func, since it's available in .NET 2.0 and actually describes the usage better.

EDIT: Cached property getter delegates to avoid paying the reflection overhead for each list, only for each list type.

EDIT: Added Pair<S,T> class to get rid of the final dependency on .NET > 2.0.

NOTE: A lot of the complexity of this answer deals with the possibility that entries in the specified property are non-unique. I return a Cartesian product of matches, yet without calculating the Cartesian product of both entire lists. Things could be simplified a lot if uniqueness of the key property is assumed.

Answer 2

The best thing to do is to first create an interface that contains T1 only. Then you inherit each class like X and Y from this interface. Now you can easily create your generic classes or any helper classes based on this interface.

Alternatively, you may use reflection, or if you use C# 4.0, you can use dynamic. Classic reflection is way to slow for (large) lists, so unless you cache your method calls, you shouldn't take that approach. C# 4.0 however, provided method caching through the DLR, which is sufficiently fast in most cases.

Alternatively (2): when you want to do this "right" and you want to compare the lists using standard mechanisms like LINQ, you should implement IComparable. You can combinee that with generics to create type-safety.

// the interface, inherit from IComparable
public interface IX : IComparable<IX>
{
    string T1 { get; set; }
}

// create one base class
class XBase : IX
{
    public string T1 { get; set; }
    public int CompareTo(IX obj)
    {
        return this.T1.equals(obj.T1);
    }
}

// inherit all others from base class
class X : XBase
{
    public string T2 { get; set; }
    public string T3 { get; set; }
}

class Y : XBase
{
    public string T2 { get; set; }
    public string T3 { get; set; }

    public strign O1 { get; set; }
}

There are many other ways. The last method above has the advantage of only once writing the logic for T1 and CompareTo, which saves from clutter and creates clarity in your code.

Answer 3

I had a really hard time understanding the question. But I read it as "how can I find a diff between lists of these two objects based on their T1 value." However, like I said, this is a total guess as to what the actual question is.

Using linq here is a good start for you:

IEnumerable<string> intersectionT1s = listX.Select(x => x.T1).Intersect(listY.Select(y => y.T1);
IEnumerable<X> intersection = listX.Where(x => intersectionT1s.Contains(x.T1));
IEnumerable<X> onlyOnX = listX.Where(x => !listY.Any(y => y.T1 == x.T1));

I'll leave onlyOnY as an exercise for the reader.

Here is a generic intersection method which you can use:

public static class ExtensionMethods
{
    public static IEnumerable<TLeft> IntersectionOn<TLeft, TRight, TField>(this IEnumerable<TLeft> left,
        IEnumerable<TRight> right, Func<TLeft, TField> leftSelector, Func<TRight, TField> rightSelector)
    {
        var intersectionFields = left.Select(leftSelector).Intersect(right.Select(rightSelector));
        return left.Where(x => intersectionFields.Contains(leftSelector(x)));
    }
}

and the usage:

IEnumerable<X> intersection = listX.IntersectionOn(listY, x => x.T1, y => y.T1);

Answer 4

var elementInBoth = (from x in ListOfClassX
                     join y in ListOfClassY on x.T1 equals y.T1
                     select x).ToList();

var elementsOnlyInListOfClassX = ListOfClassX.Except(elementsInBoth);

now you can do a left join, or just two-step it. I prefer two-steps as it's more clear.

var elementsToRemoveFromListOfClassY = (from x in ListOfClassX
                                        join y in ListOfClass Y on x.T1 equals y.T1
                                        select y).ToList();

var elementsOnlyInListOfClassY = ListOfClassY.Except(elementsToRemoveFromListOfClassY);

Answer 5

_{second answer by me, posted as a new answer because it is quite different than my previous, and both have their value}

If we combine the suggestions made in this thread by Ben Voigt, Abel (me), Roman, tster and Mike M., and include my suggestion for caching, we come to the following:

I assume, for the following code, that changing the classes is not an option. I also follow the OP's request of using generics. The code is rudimentary, but should work with minor enhancements. The code is tested and works.

The problem to solve is not the generics, but the reflection, which is, simply put, too slow for this scenario, which is why I show you in the second code block how you can apply manual caching of delegates and how to find the method of a gettor.

Here's how you can apply it, which is pretty straightforward. It works with any class that has a property "T1", but you can use it with any type of member:

// this is how you use the Comparisons class:
List<A> aList = new List<A>();
List<B> bList = new List<B>();
aList.Add(new A("first3"));
aList.Add(new A("duplicate4"));
aList.Add(new A("duplicate1"));
aList.Add(new A("first2"));
bList.Add(new B("second3"));
bList.Add(new B("duplicate4"));
bList.Add(new B("duplicate1"));
bList.Add(new B("second2"));


// get all elements that are in both lists (duplicate1 and duplicate4)
var listDuplicates = Comparisons.GetDuplicatesFromList1(aList, bList);

// remove duplicates (keep "first3" and "first2")
var withoutDuplicates = aList.Except(listDuplicates).ToList();

Below is the actual code. I commented the harder parts. It's not the easiest type of code you'll encounter and to understand or apply it, you need knowledge of reflection, delegates and method invocation techniques.

// all logic goes into this class
public static class Comparisons
{
    // note: static, so don't use in multi-threading environments!
    // must use Delegate as type here, Func<XX, string> would not work, as we cannot possibly know what XX is
    // up front. This is not a problem, as Delegate is the parent of all Func<> and Action<>
    static Dictionary<Type, Delegate> methodLookup = new Dictionary<Type, Delegate>();

    private static Func<T, string> EnsureMethod<T>(T obj)
        where T : class, new()
    {
        Type type = obj.GetType();

        if(!methodLookup.ContainsKey(type))
        {
            // The tricky bit. We cannot use GetProperty here, because we later need a method
            // and we cannot use GetMethod, because it cannot find special methods (hidden gettors)
            MemberInfo[] members = type.GetMember("get_T1");
            if(members == null || members.Length > 1)
                throw new InvalidOperationException("Object must have one 'T1' gettor property");

            MethodInfo property = members[0] as MethodInfo;

            if(property == null)
                throw new InvalidOperationException("Object must have 'T1' property");


            // creating a delegate is the best way to speed up method invocation
            // this type of delegate is called an "open instance delegate", which is like
            // a static delegate with first parameter as the object to invoke on
            Func<T, string> propertyGettor = (Func<T, string>) Delegate.CreateDelegate(typeof(Func<T, string>), null, property);
            methodLookup.Add(type, propertyGettor);
        }

        // must cast here
        return (Func<T, string>)methodLookup[obj.GetType()];

    }

    // I use a generic extension method here. This is frowned upon by some language purists
    // you can always use a utility helper method, which is the alternative
    public static string GetPropertyT1<T>(this T obj)
        where T : class, new()
    {
        // do something with obj1 being null, this is the BCL default
        if (obj == null)
            throw new ArgumentNullException("Extension method object cannot be null for GetT1 method");

        // if the property is not found, an error is raised, so the following is safe:
        // only the first invocation for each type (class) of object is relatively slow
        Func<T, string> delegateObj1 = EnsureMethod(obj);


        // this now is lightning fast: it invokes the method on the instance of obj
        return delegateObj1.Invoke(obj);
    }

    // The actual method that does something, it will return all elements in list1
    // that are also found in list2, replace this with whatever logic you need
    public static IList<U> GetDuplicatesFromList1<U, V>(IEnumerable<U> list1, IEnumerable<V> list2)
        where U: class, new()
        where V: class, new()
    {
        var elementsList1InBoth = from x in list1
                                  join y in list2 on x.GetPropertyT1() equals y.GetPropertyT1()
                                  select x;

        return elementsList1InBoth.ToList();
    }


}


// your original classes as A and B, with no inheritance chain or other relations
public class A
{
    public A(){}
    public A(string value) { this.T1 = value; }
    public string T1 { get; set; }
}
public class B
{
    public B(){}
    public B(string value) { this.T1 = value; }
    public string T1 { get; set; }
    public string Tx { get; set; }
}