为什么将 2 个 .NET 框架类相互比较会导致堆栈溢出异常?

Question

>问题

我目前正在创建一个应用程序。在这个应用程序中，我正在使用序列化 Func。这不知何故使我的应用程序崩溃，无一例外。

无一例外地崩溃让我对 wtf 感到好奇，所以我做了一些深入研究，经过一些挖掘，终于发现在 Newtonsoft.Json 中的某个地方发生了List.Contains，然后对 2 个属性执行相等检查。

显然，在此等于检查中会导致无限循环，从而导致堆栈溢出异常。

仅使用 C# 重现问题

Expression<Func<string, int>> expr = (t) => t.Length;
Func<string, int> exprCompiled = expr.Compile();
var aa = exprCompiled.Method.Module;
var bb = exprCompiled.Method.Module.Assembly;
//This code results in either an infinite loop or a Stackoverflow Exception
var tempresult = aa.Equals(bb);
Console.WriteLine("This code is never executed");

重现Newtonsoft.json的问题

Expression<Func<string, int>> expr = (t) => t.Length;
Func<string, int> exprCompiled = expr.Compile();
//This code results in either an infinite loop or a Stackoverflow Exception
var res = JsonConvert.SerializeObject(exprCompiled);
Console.WriteLine("This code is never executed");

实际基础问题

对.NET 框架的工作原理进行更多挖掘，我认为问题在于InternalAssemblyBuilder内部类和InternalModuleBuilder内部类的实现。它们都有一个 Equals 方法重写，如下所示：

public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (obj is InternalAssemblyBuilder)
{
return this == obj;
}
return obj.Equals(this);
}

我认为应该是这样的：

public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (obj is InternalAssemblyBuilder)
{
return this == obj;
}
return base.Equals(this); //changed obj to base
}

Answer 1

正如您问题的实际潜在问题以及 NineBerry 在评论中所述，Microsoft 的InternalAssemblyBuilder.Equals(object)和InternalModuleBuilder.Equals(object)的实现似乎被破坏了。 具体来说，在检查类型为InternalAssemblyBuilder的对象和类型InternalModuleBuilder的对象之间的相等性的情况下，将发生无限递归。

若要解决此问题，可以在JsonSerializer.SettingsEqualityComparer上设置自定义IEqualityComparer，以替换这些类型的合理实现Equals()。 下面是一个使用引用相等的示例：

public class CustomJsonEqualityComparer : IEqualityComparer
{
public static readonly CustomJsonEqualityComparer Instance = new CustomJsonEqualityComparer();
// Use ImmutableHashSet in later .net versions
static readonly HashSet<string> naughtyTypes = new HashSet<string>
{
"System.Reflection.Emit.InternalAssemblyBuilder",
"System.Reflection.Emit.InternalModuleBuilder"
};
static readonly IEqualityComparer baseComparer = EqualityComparer<object>.Default;
static bool HasBrokenEquals(Type type)
{
return naughtyTypes.Contains(type.FullName);
}
#region IEqualityComparer Members
public bool Equals(object x, object y)
{
// Check reference equality
if ((object)x == y)
return true;
// Check null
else if ((object)x == null || (object)y == null)
return false;
var xType = x.GetType();
if (xType != y.GetType())
// Types should be identical.
// Note this check alone might be sufficient to fix the problem.
return false;
if (xType.IsClass && !xType.IsPrimitive) // IsPrimitive check for performance
{
if (HasBrokenEquals(xType))
{
// These naughty types should ONLY be compared via reference equality -- which we have already done.
// So return false
return false;
}
}
return baseComparer.Equals(x, y);
}
public int GetHashCode(object obj)
{
return baseComparer.GetHashCode(obj);
}
#endregion
}

然后，您将按如下方式使用它：

var settings = new JsonSerializerSettings
{
EqualityComparer = CustomJsonEqualityComparer.Instance,
};
var json = JsonConvert.SerializeObject(exprCompiled, settings);

笔记：

• 您可能需要调整CustomJsonEqualityComparer.HasBrokenEquals()如果其他System.Reflection.Emit类型具有类似的破坏Equals()实现。

• 确保两个传入对象具有相同的GetType()System.Type值可能就足够了，因为到目前为止发现的损坏的Equals()方法仅在比较两种不同类型的情况下溢出堆栈，并且两者都具有相同的错误。

• 虽然我能够重现无限递归并验证它是否已使用某些模型对象修复，但我无法确认 Json.NET 实际上可以序列化您的Func<string, int> exprCompiled。