为什么使用“包含”时 FluentAssertions 中的嵌套类会被忽略？

Question

为了说明问题，请考虑以下三个类：

class Orange
{
    public String color { get; set; }
}
class Foo
{
    public Int32 size { get; set; }
    public Orange orange { get; set; }
}
class Bar
{
    public Int32 size { get; set; }
    public Orange orange { get; set; }
}

如果我创建 Foo 和 Bar 的实例，并将它们的 Orange 实例设置为不同，然后进行断言（不使用“包含”），则断言按预期工作；它找到了“red”和“bff”之间的区别：

Foo foo = new Foo() { size = 3 };
foo.orange = new Orange() {color = "red" }; 

Bar bar = new Bar() { size = 3 };
bar.orange = new Orange() { color = "bff" };

foo.ShouldBeEquivalentTo(bar);  // assertion fails, as expected

但是，如果我做同样的断言，同时通过“包含”明确告诉 FluentAssertions 要比较什么，断言不会捕捉到 Orange 的差异：

foo.ShouldBeEquivalentTo(bar, options => options
    .Including(o => o.size)
    .Including(o => o.orange)
    );   // assertion does not fail, why?

Answer 1

您可以使用ComparingByValue

foo.ShouldBeEquivalentTo(bar, options => options
    .Including(o => o.size)
    .Including(o => o.orange)
    .ComparingByValue<Orange>());

然后它失败了。

您已包含 orange 用于比较对象的属性，并且比较对象是基于它们的属性，并且您未包含要比较的 orange 的任何属性，因此假定 foo.orange 等于 bar.orange。

添加 CompareByValue<Orange> 可以根据 Equals 方法比较 Orange 实例。所以默认会做参考比较。

你应该为Orange覆盖Equals

class Orange
{
    public String color { get; set; }

    public override bool Equals(object obj)
    {
        var orange = obj as Orange;
        return Equals(orange);
    }

    protected bool Equals(Orange other)
    {
        return other != null && 
            string.Equals(color, other.color);
    }

    public override int GetHashCode()
    {
        return color?.GetHashCode() ?? 0;
    }
}

现在您可以使用这种方法比较偶数列表。

var foo = new Foo() { size = 3 };
var o1 = new Orange { color = "a" };
var o2 = new Orange { color = "a" };
var o3 = new Orange { color = "b" };
var o4 = new Orange { color = "b" };
foo.orange = new List<Orange>() { o1, o3 };

Bar bar = new Bar() { size = 3 };
bar.orange = new List<Orange>() { o1, o4 };

foo.ShouldBeEquivalentTo(bar);

foo.ShouldBeEquivalentTo(bar, options => options
    .Including(x => x.size)
    .Including(x => x.orange)
    .ComparingByValue<Orange>());