C# 如何模拟（等待）系统.Threading.Tasks.Task<；emresponse>；在c中#

我是C#的新手，一直试图模拟类型为

System.Threading.Tasks.Task

的对象，但未能成功。谁能帮我嘲笑一下吗

public class PEProcessor : IPEProcessor
{
    public PEProcessor(IService service)
    {
        _proxy = service;
        _emUpdate = new EMUpdate(service);
    }


    public void CreateAddress(string modelName, string version, string name, MType mType, Address address, EMRequest request)
    {
        var response = _proxy.EMCreateAsync(request); // should return object of type (awaitable) System.Threading.Tasks.Task<EMCResponse>
        address.Id = Convert.ToInt32(response.Result.CM[0].Code);
    }

}

公共类PEProcessor:IPEProcessor
{
公共处理器（iSeries设备服务）
{
_代理=服务；
_emUpdate=新的emUpdate（服务）；
}
public void CreateAddress（字符串模型名、字符串版本、字符串名称、MType MType、地址、EMRequest请求）
{
var response=_proxy.EMCreateAsync（request）；//应返回System.Threading.Tasks.Task类型（可等待）的对象
address.Id=Convert.ToInt32（response.Result.CM[0].Code）；
}
}

我嘲笑如下

[Fact]
public void RequestIsVerifiable()
{

    //Arrange
    var wcfMock = new Mock<IService>();

    // wcfMock.Setup(x => x.EMCreateAsync(It.IsAny<EMCreateRequest>())).ReturnAsync(??);

    //Act
    var peProcessor = new PEProcessor(wcfMock.Object);
    peProcessor.CreateAddress(MoqData.ModelName, MoqData.version, MoqData.name,
        MoqData.MType, MoqData.AddressesList(), MoqData.EMRequest);

    //Assert
    wcfMock.Verify(service => service.EMCreateAsync(It.IsAny<EMCreateRequest>()), Times.AtLeastOnce);
}

[事实]
public void RequestIsVerifiable（）
{
//安排
var wcfMock=new Mock（）；
//Setup（x=>x.EMCreateAsync（It.IsAny（））.ReturnAsync（？）；
//表演
var peProcessor=新的peProcessor（wcfMock.Object）；
peProcessor.CreateAddress（MoqData.ModelName、MoqData.version、MoqData.name、，
MoqData.MType、MoqData.AddressesList（）、MoqData.EMRequest）；
//断言
Verify（service=>service.EMCreateAsync（It.IsAny（）），Times.atlestOnce）；
}

---

提前谢谢

如果您只想延迟某个结果或执行，以模拟某个操作正在异步完成，您可以使用：

await Task.Delay(5000);//5000 means 5 seconds.

或者，如果您希望稍后执行该任务，则可以执行以下操作

var obj = SomeFunctionAsync().AsTask(); // this will return u a IAsyncOperation object.
//some lines of code.
var result = await obj; //and this line will actually execute the method asyncronosly and return u the required value (if any).

---

然后，您需要设置mock以返回预期结果，以便可以按预期执行测试

var response = new EMCResponse {
    //populate
};

wcfMock
    .Setup(x => x.EMCreateAsync(It.IsAny<EMCreateRequest>()))
    .ReturnAsync(response);

var响应=新的响应{
//填充
};
wcfMock
.Setup（x=>x.EMCreateAsync（It.IsAny（）））
.ReturnAsync（响应）；

也就是说，如果有可能将代码重构为始终异步的，并且不必进行阻塞调用

public class PEProcessor : IPEProcessor {
    public PEProcessor(IService service) {
        _proxy = service;
        _emUpdate = new EMUpdate(service);
    }    

    public async Task CreateAddress(string modelName, string version, string name, MType mType, Address address, EMRequest request) {
        var response = await _proxy.EMCreateAsync(request); // should return object of type (awaitable) System.Threading.Tasks.Task<EMCResponse>
        address.Id = Convert.ToInt32(response.CM[0].Code);
    }
}

公共类PEProcessor:IPEProcessor{
公共处理器（iSeries设备服务）{
_代理=服务；
_emUpdate=新的emUpdate（服务）；
}    
公共异步任务CreateAddress（字符串模型名、字符串版本、字符串名称、MType MType、地址地址、EMRequest）{
var response=await _proxy.EMCreateAsync（request）；//应返回类型为（awaitable）System.Threading.Tasks.Task的对象
address.Id=Convert.ToInt32（response.CM[0].Code）；
}
}

可按如下方式执行此操作：

[Fact]
public async Task RequestIsVerifiable() {

    //Arrange
    var wcfMock = new Mock<IService>();

    var response = new EMCResponse {
        //populate
    };

    wcfMock
        .Setup(x => x.EMCreateAsync(It.IsAny<EMCreateRequest>()))
        .ReturnAsync(response);

    var peProcessor = new PEProcessor(wcfMock.Object);

    //Act        
    await peProcessor.CreateAddress(MoqData.ModelName, MoqData.version, MoqData.name,
        MoqData.MType, MoqData.AddressesList(), MoqData.EMRequest);

    //Assert
    wcfMock.Verify(service => service.EMCreateAsync(It.IsAny<EMCreateRequest>()), Times.AtLeastOnce);
}

[事实]
公共异步任务请求可验证（）{
//安排
var wcfMock=new Mock（）；
var响应=新的EMR响应{
//填充
};
wcfMock
.Setup（x=>x.EMCreateAsync（It.IsAny（）））
.ReturnAsync（响应）；
var peProcessor=新的peProcessor（wcfMock.Object）；
//表演
等待peProcessor.CreateAddress（MoqData.ModelName、MoqData.version、MoqData.name、，
MoqData.MType、MoqData.AddressesList（）、MoqData.EMRequest）；
//断言
Verify（service=>service.EMCreateAsync（It.IsAny（）），Times.atlestOnce）；
}

您希望任务的表现如何？如果您想立即完成，可以使用

Task.FromResult（…）

。似乎没有必要在此处模拟任务；您只需模拟任务的结果-任务本身可以预先完成。我希望

response.result.CM[0]。code

值存在，但我得到的

response.result

本身为空。所以我只是想用数据来停止通话。但是我不知道该怎么办！！但我没有得到我所期望的数据。我不能模拟调用以返回某个对象吗？类似于

when（）.thenReturn（）

的内容，如

Java

中的内容。