C# 正在验证集合是否已通过

我正在尝试验证是否已将复杂集合传递到方法中

我似乎想不出如何编写lambda来测试

以下是我尝试做的一个简化版本：

var parameters = new List<NotificationParameter>()
{
    new NotificationParameter()
    {
        Key = "photoShootId",
        Value = 1,
    },
};

message.Verify(m => m.Load(It.Is<List<NotificationParameter>>(
        p => // ??? Ensure that 'p' and 'parameters' have
             //     the same elements and values for 'Key' and 'Value'
    )
));

var参数=新列表（）
{
新建NotificationParameter（）
{
Key=“photoShootId”，
值=1，
},
};
message.Verify（m=>m.Load（It.Is(
p=>/？？？确保“p”和“参数”具有
//“键”和“值”的元素和值相同
)
));

只需将

参数

传递到

验证

就无法通过测试，因此我想针对

键

和

值

属性进行测试

---

上面的

p

属于

List

类型，您可以使用

.All

在每个元素上执行表达式，如果All返回true，则返回true，因此对于您的特定情况，我们可以将条件写为

message.Verify(m => m.Load(It.Is<List<NotificationParameter>>(
   pList => pList.All(p => parameters.Any(pTest => p.Key == pTest.Key &&  p.Value == pTest.Value))
    )
));

message.Verify（m=>m.Load（It.Is(
pList=>pList.All（p=>parameters.Any（pTest=>p.Key==pTest.Key&&p.Value==pTest.Value））
)
));

另一种方法是使用IEqualityComparer&SequenceEqual

乙二醇

类通知参数比较器：IEqualityComparer
{
公共布尔等于（NotificationParameter x，NotificationParameter y）
{
如果（x==null | | y==null）
返回false；
返回x.Key==y.Key&&x.Value==y.Value
}
public int GetHashCode（NotificationParameter参数）
{
if（Object.ReferenceEquals（parameter，null））返回0；
int hashKey=parameter.Key==null？0:parameter.Key.GetHashCode（）；
int hashValue=parameter.Value.GetHashCode（）；
返回hashKey^hashValue；
}
}

然后用它作为

message.Verify(m => m.Load(It.Is<List<NotificationParameter>>(
    pList => pList.SequenceEqual(parameters, new NotificationParameterComparer())
    )
));

message.Verify（m=>m.Load（It.Is(
pList=>pList.SequenceEqual（参数，新NotificationParameterComparer（））
)
));

您可以使用

.All

在每个元素上执行一个表达式，如果All返回true，则返回true，因此对于您的特定情况，我们可以将条件写为

message.Verify(m => m.Load(It.Is<List<NotificationParameter>>(
   pList => pList.All(p => parameters.Any(pTest => p.Key == pTest.Key &&  p.Value == pTest.Value))
    )
));

message.Verify（m=>m.Load（It.Is(
pList=>pList.All（p=>parameters.Any（pTest=>p.Key==pTest.Key&&p.Value==pTest.Value））
)
));

另一种方法是使用IEqualityComparer&SequenceEqual

乙二醇

类通知参数比较器：IEqualityComparer
{
公共布尔等于（NotificationParameter x，NotificationParameter y）
{
如果（x==null | | y==null）
返回false；
返回x.Key==y.Key&&x.Value==y.Value
}
public int GetHashCode（NotificationParameter参数）
{
if（Object.ReferenceEquals（parameter，null））返回0；
int hashKey=parameter.Key==null？0:parameter.Key.GetHashCode（）；
int hashValue=parameter.Value.GetHashCode（）；
返回hashKey^hashValue；
}
}

然后用它作为

message.Verify(m => m.Load(It.Is<List<NotificationParameter>>(
    pList => pList.SequenceEqual(parameters, new NotificationParameterComparer())
    )
));

message.Verify（m=>m.Load（It.Is(
pList=>pList.SequenceEqual（参数，新NotificationParameterComparer（））
)
));

要匹配列表的内容，可以使用SequenceEquals（）和IEqualityComparer

公共类通知参数{
公共通知参数（字符串键，int值）{
钥匙=钥匙；
价值=价值；
}
公共字符串密钥{get；set；}
公共int值{get；set；}
}
公共接口设备{
空隙荷载（IEnumerable parameters）；
}
公共类ClientClass{
私人只读设备服务；
公共客户端类（iSeries服务）{
_服务=服务；
}
公共无效运行（IEnumerable参数）{
_服务负荷（参数）；
}
}
公共类通知比较程序：IEqualityComparer{
公共布尔等于（NotificationParameter x，NotificationParameter y）{
返回等于（x键，y键）
&&x.值等于（y.值）；
}
public int GetHashCode（NotificationParameter obj）{
返回obj.Value.GetHashCode（）^obj.Key.GetHashCode（）；
}
}
私有只读静态NotificationComparer Comparer=新NotificationComparer（）；
[测试方法]
public void VerifyLoadCompareValues（）验证{
var参数=新列表{
新的NotificationParameter（“A”，1），
新的通知参数（“B”，2），
新的通知参数（“C”，3），
};
var预期值=新列表{
新的NotificationParameter（“A”，1），
新的通知参数（“B”，2），
新的通知参数（“C”，3），
};
var mockService=new Mock（）；
var client=newclientclass（mockService.Object）；
client.Run（参数）；
mockService.Verify（mk=>mk.Load（It.Is（It=>It.SequenceEqual（预期，Comparer）））；
}

如果顺序不同，则可以使用助手方法进行排序，然后进行比较

[TestMethod]
public void VerifyLoadCompareDifferentOrder() {
    var parameters = new List<NotificationParameter> {
        new NotificationParameter("A", 1),
        new NotificationParameter("B", 2),
        new NotificationParameter("C", 3),
    };


    var expected = new List<NotificationParameter> {
        new NotificationParameter("B", 2),
        new NotificationParameter("C", 3),
        new NotificationParameter("A", 1),
    };


    var mockService = new Mock<IService>();
    var client = new ClientClass(mockService.Object);

    client.Run(parameters);

    mockService.Verify(mk => mk.Load(It.Is<IEnumerable<NotificationParameter>>(it => AreSame(expected, it))));

}


private static bool AreSame(
    IEnumerable<NotificationParameter> expected,
    IEnumerable<NotificationParameter> actual
) {
    var ret = expected.OrderBy(e => e.Key).SequenceEqual(actual.OrderBy(a => a.Key), Comparer);
    return ret;
}

[TestMethod]
public void VerifyLoadCompareDifferentor（）验证{
var参数=新列表{
新的NotificationParameter（“A”，1），
新的通知参数（“B”，2），
新的通知参数（“C”，3），
};
var预期值=新列表{
新的通知参数（“B”，2），
新的通知参数（“C”，3），
新的NotificationParameter（“A”，1），
};
var mockService=new Mock（）；
var client=newclientclass（mockService.Object）；
client.Run（参数）；
验证（mk=>mk.Load（It.Is（It=>arame（预期，It）））；
}
私有静态布尔值(
我期待着，
IEnumerable实际值
) {
var ret=expected.OrderBy（e=>e.Key）.SequenceEqual（actual.OrderBy（a=>a.Key），Comparer）；
返回ret；
}

要匹配列表的内容，可以使用SequenceEquals（）和IEqualityComparer

公共类通知参数{
公共通知参数（字符串键，int值）{
钥匙=钥匙；
价值=价值；
}
公共字符串密钥{get；set；}
公共INTV