C# FluentAssertions使用带有枚举的结构失败，但不使用类

我有一个嵌套的

类

，可以断言它们。
然后我将

class

更改为

struct

，测试失败

（如果我将

IEnumerable MyItems{get；set；}

更改为

ItemStruct MyItem{get；set；}

，两种情况下的比较都会成功。因此我想这与IEnumerable有关。）

使用FluentAssertions；
使用Microsoft.VisualStudio.TestTools.UnitTesting；
使用System.Collections.Generic；
命名空间CowsCannotReadLogs.FileHandling.UnitTest
{
[测试类]
公共类TestFluentAssertionStruct
{
公共结构数据结构
{
公共IEnumerable MyItems{get；set；}
}
//失败了。
[测试方法]
public void TestSimpleStruct（）
{
var data1=newdatastruct{MyItems=new[]{“A”}；
var data2=新数据结构{MyItems=new[]{“A”}；
data1.Should（）.beequivalento（data2）；
}
//失败了。
[测试方法]
public void TestSimpleStructWithComparingByValue（）
{
var data1=newdatastruct{MyItems=new[]{“A”}；
var data2=新数据结构{MyItems=new[]{“A”}；
data1.Should（）.beequivalento（data2，
options=>options.ComparingByValue（））；
}
公共类数据类
{
公共IEnumerable MyItems{get；set；}
}
//成功。
[测试方法]
public void TestSimpleClass（）
{
var data1=新数据类{MyItems=new[]{“A”}；
var data2=新数据类{MyItems=new[]{“A”}；
data1.Should（）.beequivalento（data2）；
}
}
}

在

struct

s上使用

BeEquivalentTo

时，默认情况下会根据值语义比较这两个实例。 要按其成员比较结构，可以在本地或全局覆盖默认行为

测试中的局部内部：

[TestMethod]
公开无效测试（）
{
subject.Should（）.BeEquivalentTo（应为，
opt=>opt.ComparingByMembers（））；
}

在全局范围内，例如

[AssemblyInitialize]

：

[AssemblyInitialize]
公共静态void AssemblyInitialize（TestContext上下文）
{
AssertionOptions.AssertEquivalencyUsing（opt=>opt.ComparingByMembers（））；
}

如果查看FluentAssertion的文档（“对象图比较”），您将看到方法

beequivalento

通过值语义比较两个实例，如果要比较的类型覆盖了

Obejct.Equal

，则检查每个实例的属性。这对于您的值类型是不正确的，因此它们将与值类型的默认相等运算符进行比较，如果您的结构只有其他结构属性，则此操作将成功，但如果您将引用类型（IEnumerable）作为其属性之一，则此操作将失败。我怀疑使用

ComparingByValue

可以解决这个问题。@IPValverde感谢您提供的信息。但它仍然不起作用。我更新了示例。请尝试改用

ComparingByMembers（）

。

using FluentAssertions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;

namespace CowsCannotReadLogs.FileHandling.UnitTest
{
    [TestClass]
    public class TestFluentAssertionStruct
    {
        public struct DataStruct
        {
            public IEnumerable<string> MyItems { get; set; }
        }

        // Fails.
        [TestMethod]
        public void TestSimpleStruct()
        {
            var data1 = new DataStruct { MyItems = new[] { "A" } };
            var data2 = new DataStruct { MyItems = new[] { "A" } };
            data1.Should().BeEquivalentTo(data2);
        }

        // Fails.
        [TestMethod]
        public void TestSimpleStructWithComparingByValue()
        {
            var data1 = new DataStruct { MyItems = new[] { "A" } };
            var data2 = new DataStruct { MyItems = new[] { "A" } };
            data1.Should().BeEquivalentTo(data2, 
                options => options.ComparingByValue<DataStruct>());
        }


        public class DataClass
        {
            public IEnumerable<string> MyItems { get; set; }
        }

        // Succeeds.
        [TestMethod]
        public void TestSimpleClass()
        {
            var data1 = new DataClass { MyItems = new[] { "A" } };
            var data2 = new DataClass { MyItems = new[] { "A" } };
            data1.Should().BeEquivalentTo(data2);
        }
    }
}