C# 嘲弄一名代表”；包装纸；使用最小起订量

本质上，我有一个用于“安全”调用委托的类。“安全”本质上意味着，如果某个成员已经被释放，那么调用将被跳过。此类的代码：

    public class SafeOperationInvoker<TResponse> : IOperationInvoker<TResponse>
    where TResponse : class
    {
    private readonly IDisposableResource _callbackOwner;
    private readonly IOperationInvoker<TResponse> _next;

    public SafeOperationInvoker(IDisposableResource callbackOwner, IOperationInvoker<TResponse> next)
    {
        _callbackOwner = callbackOwner;
        _next = next;
    }

    public void Invoke(Action<TResponse> completedCallback)
    {
        //wrap the callback 
        _next.Invoke(response => SafeOperationCompleted(response, completedCallback));
    }

    private void SafeOperationCompleted(TResponse response, Action<TResponse> completedCallback)
    {
        //only invoke the callback if not disposed
        if (_callbackOwner != null && _callbackOwner.IsDisposed)
        {
            return;
        }
        completedCallback(response);
    }
}

public-class-SafeOperationInvoker:IOperationInvoker
在哪里响应：类
{
私有只读IDispSablerResource\u callbackOwner；
私有只读IOperationInvoker\u next；
公共安全运营Voker（IDisPosableSource callbackOwner，IOperationVoker next）
{
_callbackOwner=callbackOwner；
_下一个=下一个；
}
公共void调用（Action completedCallback）
{
//包装回调
_Invoke（response=>SafeOperationCompleted（response，completedCallback））；
}
私有void安全操作已完成（t响应响应，操作已完成回调）
{
//仅在未释放时调用回调
if（_callbackOwner！=null&&u callbackOwner.IsDisposed）
{
回来
}
完成回调（响应）；
}
}

我想要的是测试SafeOperationCompleted方法——如果callbackOwner被释放，completedCallback不会启动（反之亦然）

我手工制作了一个赝品，使我的测试功能正确：

private class FakeOperationInvoker : IOperationInvoker<string>
{
    public void Invoke(Action<string> completedCallback)
    {
        completedCallback("hi");
    }
}

private-class-FakeOperationInvoker:IOperationInvoker
{
公共void调用（Action completedCallback）
{
完成回调（“hi”）；
}
}

测试：

[TestMethod]
public void SafeOperationCompleted_OriginalCallback_Invoked()
{
    int called = 0;

    var mockOwner = new Mock<IDisposableResource>();
    mockOwner.Setup(m => m.IsDisposed).Returns(false);
    var invoker = new SafeOperationInvoker<string>(mockOwner.Object, new FakeOperationInvoker());
    invoker.Invoke((o) => {  called++;});
    Assert.AreEqual(1, called, "Original callback should have been called");
}

[TestMethod]
public void安全操作已完成\u OriginalCallback\u已调用（）
{
int=0；
var mockOwner=new Mock（）；
mockOwner.Setup（m=>m.IsDisposed）。返回（false）；
var invoker=new-SafeOperationInvoker（mockOwner.Object，new-FakeOperationInvoker（））；
invoker.Invoke（（o）=>{called++；}）；
AreEqual（1，称为“应该调用原始回调”）；
}

我想做的是使用moq创建一个模拟，其行为方式与FakeOperationVoker的行为方式相同。我怎样才能做到这一点呢？

你就不能做到：

var operationInvoker = new Mock<IOperationInvoker<string>>();
operationInvoker.Setup(oi => oi.Invoke(It.IsAny<Action<string>>())
                .Callback((Action<string>> callback) => callback("hi"));

var operationInvoker=new Mock（）；
operationInvoker.Setup（oi=>oi.Invoke（It.IsAny（））
.回调（（操作>回调）=>回调（“hi”）；

你就不能这样做：

var operationInvoker = new Mock<IOperationInvoker<string>>();
operationInvoker.Setup(oi => oi.Invoke(It.IsAny<Action<string>>())
                .Callback((Action<string>> callback) => callback("hi"));

var operationInvoker=new Mock（）；
operationInvoker.Setup（oi=>oi.Invoke（It.IsAny（））
.回调（（操作>回调）=>回调（“hi”）；