C# 自动夹具-相似性。复杂对象的比较

我试图将两个复杂对象与AutoFixture的相似性进行比较，但不幸的是没有成功。当比较嵌套对象（也使用类似的

）时，比较主对象的结果会出现错误，即子对象不匹配。我假设问题在于，相似度仅将语义比较器应用于主对象，而嵌套对象使用默认的相等实现进行比较，该实现检查引用匹配（可能是我的假设错误吗？）

这可以澄清我试图实现的目标：

public class ComplexMasterObject{
    public ChildFirst child1 {get;set;}
    public ChildSecond child2 {get;set;}
    public string SimpleProp {get;set;}
}

public class ChildFirst {
    public string SomeStringProp1 {get;set;}
    public int  SomeIntProp1 {get;set;}
}

public class ChildSecond {
    public string SomeStringProp1 {get;set;}
    public int  SomeIntProp1 {get;set;}
}

测试：

如何对包含嵌套复杂属性的复杂对象执行语义比较

提前感谢。
C#中的复杂结构对象相等（与类一起）在大多数情况下都很麻烦，因为类默认使用引用相等

不过，可以使用AutoFixture附带的包（但作为单独的NuGet包分发）执行复杂的结构对象相等

示例：
语义比较程序

[事实]
public void TestComplexClassEquality（）
{
//安排
var值=新的ComplexMasterObject
{
Child1=新的ChildFirst
{
SomeStringProp1=“1”，
SomeIntProp1=2
},
Child2=新的ChildSecond
{
SomeStringProp1=“3”，
SomeIntProp1=4
},
SimpleProp=“5”
};
var other=新的ComplexMasterObject
{
Child1=新的ChildFirst
{
SomeStringProp1=“1”，
SomeIntProp1=2
},
Child2=新的ChildSecond
{
SomeStringProp1=“3”，
SomeIntProp1=4
},
SimpleProp=“5”
};
萨特变种=
新语义比较(
新成员比较器(
新的AnyObjectComparer（）），
新成员比较器(
新的ChildFirstComparer（）），
新成员比较器(
新的ChildSecondComparer（））；
//表演
var实际值=总和等于（值，其他）；
//断言
断言。真（实际）；
}

示例：
相似性
及其
相似性
代理

[事实]
public void TestComplexClassEqualityResemblance（）
{
//安排
var值=新的ComplexMasterObject
{
Child1=新的ChildFirst
{
SomeStringProp1=“1”，
SomeIntProp1=2
},
Child2=新的ChildSecond
{
SomeStringProp1=“3”，
SomeIntProp1=4
},
SimpleProp=“5”
};
var other=新的ComplexMasterObject
{
Child1=新的ChildFirst
{
SomeStringProp1=“1”，
SomeIntProp1=2
},
Child2=新的ChildSecond
{
SomeStringProp1=“3”，
SomeIntProp1=4
},
SimpleProp=“5”
};
变量相似性=
新相似性(
价值
新语义比较(
新成员比较器(
新的AnyObjectComparer（）），
新成员比较器(
新的ChildFirstComparer（）），
新成员比较器(
新的ChildSecondComparer（））；
var-sut=相似性；
//表演
var实际值=总和等于（其他）；
//断言
断言。真（实际）；
}

对象定义

公共密封类AnyObjectComparer:IEqualityComparer
{
公共新布尔等于（对象x、对象y）
{
返回对象。等于（x，y）；
}
public int GetHashCode（对象obj）
{
返回obj.GetHashCode（）；
}
}
公共密封类ChildFirstComparer:IEqualityComparer
{
公共新布尔等于（对象x、对象y）
{
var值=x作为第一个孩子；
var other=y作为ChildFirst；
如果（值==null | |其他==null）
返回false；
返回值.SomeIntProp1==其他.SomeIntProp1
&&value.SomeStringProp1==other.SomeStringProp1；
}
public int GetHashCode（对象obj）
{
返回obj.GetHashCode（）；
}
}
公共密封类ChildSecondComparer:IEqualityComparer
{
公共新布尔等于（对象x、对象y）
{
var值=x，作为第二个值；
var other=y作为第二个变量；
如果（值==null | |其他==null）
返回false；
返回值.SomeIntProp1==其他.SomeIntProp1
&&value.SomeStringProp1==other.SomeStringProp1；
}
public int GetHashCode（对象obj）
{
返回obj.GetHashCode（）；
}
}
这是一个已知的问题：对于所有匹配的成员，相似性使用默认的
Equals
实现。我发现这个解决方案有两个主要问题：（1）我必须为我拥有的每种类型实现
IEqualityComparer
（而且有很多）。（2） 它不是很灵活，因为如果我向其中一个类型添加属性，我必须记住更新
IEqualityComparer
。我想我更愿意将这些对象序列化为JSON字符串并进行比较。谢谢你，我同意了。但是，考虑到当前的限制，没有更好的方法（据我所知，在C#中）。
public void TestLikeness_Success()
{
     var expected = new ComplexMasterObject {
         Child1 = new ChildFirst {
             SomeStringProp1 = "ChildFirst SomeStringProp1",
             SomeIntProp1 = 1
         },
         Child2 = new ChildSecond {
             SomeStringProp1 = "ChildSecond SomeStringProp1",
             SomeIntProp1 = 2
         },
         SimpleProp = "ComplexMasterObject SimpleProp"
     };

     var input = new ComplexMasterObject {
         Child1 = new ChildFirst {
             SomeStringProp1 = "ChildFirst SomeStringProp1",
             SomeIntProp1 = 1
         },
         Child2 = new ChildSecond {
             SomeStringProp1 = "ChildSecond SomeStringProp1",
             SomeIntProp1 = 2
         },
         SimpleProp = "ComplexMasterObject SimpleProp"
     };

     var child1Likeness = expected.Child1.AsSource().OfLikeness<ChildFirst>();
     var child2Likeness = expected.Child2.AsSource().OfLikeness<ChildSecond>();

     var masterLikeness = expected.AsSource().OfLikeness<ComplexMasterObject>();
     child1Likeness.ShouldEqual(input.Child1); //Passes
     child2Likeness.ShouldEqual(input.Child2); //Passes

     masterLikeness.ShouldEqual(input); 
     // The provided value `ComplexMasterObject` did not match the expected value `ComplexMasterObject`. The following members did not match:
  - Child1.
  - Child2.
}

var proxy = expected.AsSource().OfLikeness<ComplexMasterObject>().CreateProxy();
proxy.Equals(input); // returns false