使用反射在字典上调用Enumerable.Except（IEnumerable）

Question

I'm trying to use reflection to compare properties of objects that are the same type.

The problem is that with reference types <T> == <T> won't do So I try to use reflection to compare values of IEnumerable for this I try to invoke Enumerable.Except(T)

It works on List but won't work for Dictionaries :

Unable to cast object of type 'd__57 1[System.Collections.Generic.KeyValuePair 2[System.String,System.String]]' to type 'System.Collections.Generic.IEnumerable`1[System.Object]'.

The issue is with this code :

var typeKeyValuePair = typeof(KeyValuePair<,>);                      
                   Type[] typeArgs = { args[0], args[1] };

                    exceptMethods = typeof(Enumerable)
                        .GetMethods(BindingFlags.Static | BindingFlags.Public)
                        .FirstOrDefault(mi => mi.Name == "Except")
                        ?.MakeGenericMethod(typeKeyValuePair.MakeGenericType(typeArgs));

Full code for the info

 public static List<Variance> DetailedCompare<T>(this T val1, T val2)
    {
        List<Variance> variances = new List<Variance>();

        PropertyInfo[] propertyInfo = val1.GetType().GetProperties();
        foreach (PropertyInfo p in propertyInfo)
        {
            Variance v = new Variance();
            v.Prop = p.Name;
            v.valA = p.GetValue(val1);
            v.valB = p.GetValue(val2);

            switch (v.valA)
            {
                case null when v.valB == null:
                    continue;
                case null:
                    variances.Add(v);
                    continue;
            }

            if (v.valA.Equals(v.valB)) continue;


            if (typeof(IEnumerable).IsAssignableFrom(p.PropertyType))
            {
                //string
                if (p.PropertyType == typeof(string))
                {
                    variances.Add(v);
                    continue;
                }

                var args = p.PropertyType.GetGenericArguments();
                MethodInfo exceptMethods = null;

                if (args.Length == 2) //dictionaries
                {
                    variances.Add(v); // add to difference while not able to compare
                    /*
                   var typeKeyValuePair = typeof(KeyValuePair<,>);                      
                   Type[] typeArgs = { args[0], args[1] };

                    exceptMethods = typeof(Enumerable)
                        .GetMethods(BindingFlags.Static | BindingFlags.Public)
                        .FirstOrDefault(mi => mi.Name == "Except")
                        ?.MakeGenericMethod(typeKeyValuePair.MakeGenericType(typeArgs));*/
                }

                else if (args.Length == 1)//lists
                {
                    exceptMethods = typeof(Enumerable)
                        .GetMethods(BindingFlags.Static | BindingFlags.Public)
                        .FirstOrDefault(mi => mi.Name == "Except")
                        ?.MakeGenericMethod(p.PropertyType.GetGenericArguments().FirstOrDefault());
                }

                else//not 
                {
                    variances.Add(v);
                }

                if (exceptMethods != null)
                {
                    try
                    {
                        var res1 = (IEnumerable<object>)exceptMethods.Invoke(v.valA, new[] { v.valA, v.valB });
                        var res2 = (IEnumerable<object>)exceptMethods.Invoke(v.valB, new[] { v.valB, v.valA });
                        if (res1.Any() != res2.Any()) variances.Add(v);
                    }
                    catch (Exception ex)
                    {

                    }

                    /* if (v.valA.Except(v.valB).Any() || v.valB.Except(v.valA).Any())
                    {
                        variances.Add(v);
                    }*/
                }
            }
        }
        return variances;
    }
}

class Variance
{
    public string Prop { get; set; }
    public object valA { get; set; }
    public object valB { get; set; }
}

Answer 1

I think you might consider casting to the generic IEnumerable, and then boxing it to objects with the .OfType overloading function. The complete code would look like this:

    void TestFunction()
    {


        var v1 = new { yes = "asdf", no = "as", ar = new List<int>() { 1, 2, 3 }, dict = new Dictionary<object, object>() { { 1, 1 }, { 2, 2 } } };
        var v2 = new { yes = "asdf", no = "fd", ar = new List<int>() { 1, 2, 3 }, dict = new Dictionary<object, object>() { { 1, 1 }, { 2, 2 } } };

        var differences = DetailedCompare(v1, v2);

    }

    public static List<Variance> DetailedCompare<T>(T val1, T val2)
    {
        List<Variance> variances = new List<Variance>();

        PropertyInfo[] proppertyInfo = val1.GetType().GetProperties();
        foreach (PropertyInfo p in proppertyInfo)
        {
            Variance v = new Variance();
            v.Prop = p.Name;
            v.valA = p.GetValue(val1);
            v.valB = p.GetValue(val2);

            switch (v.valA)
            {
                case null when v.valB == null:
                    continue;
                case null:
                    variances.Add(v);
                    continue;
            }

            if (v.valA.Equals(v.valB)) continue;


            if (typeof(IEnumerable).IsAssignableFrom(p.PropertyType))
            {
                //string
                if (p.PropertyType == typeof(string))
                {
                    variances.Add(v);
                    continue;

                }


                var args = p.PropertyType.GetGenericArguments();
                MethodInfo exceptMethods = null;

                if (args.Length == 2) //dictionaries
                {
                    //variances.Add(v); // add to difference while not able to compare

                    var typeKeyValuePair = typeof(KeyValuePair<,>);
                    Type[] typeArgs = { args[0], args[1] };

                    exceptMethods = typeof(Enumerable)
                        .GetMethods(BindingFlags.Static | BindingFlags.Public)
                        .FirstOrDefault(mi => mi.Name == "Except")
                        ?.MakeGenericMethod(typeKeyValuePair.MakeGenericType(typeArgs));
                }

                else if (args.Length == 1)//lists
                {
                    exceptMethods = typeof(Enumerable)
                        .GetMethods(BindingFlags.Static | BindingFlags.Public)
                        .FirstOrDefault(mi => mi.Name == "Except")
                        ?.MakeGenericMethod(p.PropertyType.GetGenericArguments().FirstOrDefault());
                }

                else//not 
                {
                    variances.Add(v);
                }




                if (exceptMethods != null)
                {
                    try
                    {
                        var res1 = (IEnumerable)exceptMethods.Invoke(v.valA, new[] { v.valA, v.valB });
                        var res2 = (IEnumerable)exceptMethods.Invoke(v.valB, new[] { v.valB, v.valA });
                        // TODO: maybe implement better comparisson 
                        if (res1.OfType<object>().Any() != res2.OfType<object>().Any()) variances.Add(v);

                    }
                    catch (Exception ex)
                    {

                    }


                    /* if (v.valA.Except(v.valB).Any() || v.valB.Except(v.valA).Any())
                    {
                        variances.Add(v);
                    }*/


                }


            }

        }
        return variances;
    }

    public class Variance
    {
        public string Prop { get; set; }
        public object valA { get; set; }
        public object valB { get; set; }

        public override string ToString() => $" Property {Prop} is either {valA} resp. {valB}";
    }