给定两个相同的匿名类型对象:

{msg:"hello"} //anonType1
{msg:"hello"} //anonType2

并假设它们没有解析为同一类型(例如，它们可能在不同的程序集中定义)

anonType1.Equals(anonType2); //false

此外，假设在编译时，我无法获取一个结构(例如 anonType1)，因为 API 仅公开 object

所以，为了比较它们，我想到了以下技巧:

1. 使用反射获取anonType1上的msg属性进行比较。
2. 将 anonType1 转换为 dynamic 类型并在动态成员上引用 .msg 以进行比较
3. 比较每个对象上 .GetHashCode() 的结果。

我的问题是:使用选项 3 安全吗？ IE。假设 .GetHashcode() 实现将始终返回相同结构的相同值，但在 .NET 框架的当前和所有 future 版本中不同的匿名类型是否明智？

最佳答案

有趣的问题。该规范定义了 Equals 和 GetHashcode(请注意规范中的拼写错误!)方法将对相同类型的实例起作用，但未定义实现。碰巧的是，当前的 MS C# 编译器使用魔数(Magic Number)实现了这一点，例如 -1134271262 的种子和 -1521134295 的乘数。但那不是规范的一部分。从理论上讲，这可能会在 C# 编译器版本之间发生根本性的变化，并且它仍然会满足它的需要。因此，如果 2 个程序集不是由同一个编译器编译的，则无法保证。事实上，编译器在每次编译时都想出一个新的种子值是“有效的”(但不太可能)。

就个人而言，我会考虑使用 IL 或 Expression 技术来执行此操作。使用 Expression 可以很容易地按名称比较形状相似的对象。

有关信息，我还查看了 mcs(Mono 编译器)如何实现 GetHashCode，它是不同的 ;它不使用种子和乘数，而是使用种子、异或、乘数、移位和加法的组合。所以微软和Mono编译的同一个类型会有非常不同的GetHashCode。

static class Program {
    static void Main() {
        var obj = new { A = "abc", B = 123 };
        System.Console.WriteLine(obj.GetHashCode());
    }
}

• 单声道:-2077468848
• 微软:-617335881

基本上，我认为您不能保证这一点。

怎么样:

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
class Foo
{
    public string A { get; set; }
    public int B; // note a field!
    static void Main()
    {
        var obj1 = new { A = "abc", B = 123 };
        var obj2 = new Foo { A = "abc", B = 123 };
        Console.WriteLine(MemberwiseComparer.AreEquivalent(obj1, obj2)); // True

        obj1 = new { A = "abc", B = 123 };
        obj2 = new Foo { A = "abc", B = 456 };
        Console.WriteLine(MemberwiseComparer.AreEquivalent(obj1, obj2)); // False

        obj1 = new { A = "def", B = 123 };
        obj2 = new Foo { A = "abc", B = 456 };
        Console.WriteLine(MemberwiseComparer.AreEquivalent(obj1, obj2)); // False
    }

}

public static class MemberwiseComparer
{
    public static bool AreEquivalent(object x, object y)
    {
        // deal with nulls...
        if (x == null) return y == null;
        if (y == null) return false;
        return AreEquivalentImpl((dynamic)x, (dynamic)y);
    }
    private static bool AreEquivalentImpl<TX, TY>(TX x, TY y)
    {
        return AreEquivalentCache<TX, TY>.Eval(x, y);
    }
    static class AreEquivalentCache<TX, TY>
    {
        static AreEquivalentCache()
        {
            const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
            var xMembers = typeof(TX).GetProperties(flags).Select(p => p.Name)
                .Concat(typeof(TX).GetFields(flags).Select(f => f.Name));
            var yMembers = typeof(TY).GetProperties(flags).Select(p => p.Name)
                .Concat(typeof(TY).GetFields(flags).Select(f => f.Name));
            var members = xMembers.Intersect(yMembers);

            Expression body = null;
            ParameterExpression x = Expression.Parameter(typeof(TX), "x"),
                                y = Expression.Parameter(typeof(TY), "y");
            foreach (var member in members)
            {
                var thisTest = Expression.Equal(
                    Expression.PropertyOrField(x, member),
                    Expression.PropertyOrField(y, member));
                body = body == null ? thisTest
                    : Expression.AndAlso(body, thisTest);
            }
            if (body == null) body = Expression.Constant(true);
            func = Expression.Lambda<Func<TX, TY, bool>>(body, x, y).Compile();
        }
        private static readonly Func<TX, TY, bool> func;
        public static bool Eval(TX x, TY y)
        {
            return func(x, y);
        }
    }
}

关于c# - 使用 GetHashCode 比较相同的匿名类型是否安全？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16517392/