C# 等待任务的最小起订量

因为我已经将我的WCF方法转换为异步，所以我的单元测试失败了，我无法找出正确的语法来让它们工作

Cllient代理类

 public interface IClientProxy
{
     Task DoSomething(CredentialDataList credentialData, string store);
}

  public class CredentialSync : ICredentialSync
{
    private ICredentialRepository _repository;

    private IClientProxy _client;

    public CredentialSync()
    {
        this._repository = new CredentialRepository();
        this._client = new ClientProxy();
    }

    public CredentialSync(ICredentialRepository repository, IClientProxy client)
    {
        this._repository = repository;
        this._client = client;
    }

   public async Task Synchronise(string payrollNumber)
    {
        try
        {
            if (string.IsNullOrEmpty(payrollNumber))
            {
                .... some code
              }
            else
            {
                CredentialDataList credentialData = new CredentialDataList();
                List<CredentialData> credentialList = new List<CredentialData>();

                // fetch the record from the database
                List<GetCredentialData_Result> data = this._repository.GetCredentialData(payrollNumber);
                var pinData = this._repository.GetCredentialPinData(payrollNumber);

                // get the stores for this employee
                var storeList = data.Where(a => a.StoreNumber != null)
                    .GroupBy(a => a.StoreNumber)
                    .Select(x => new Store { StoreNumber = x.Key.ToString() }).ToArray();

                var credential = this.ExtractCredentialData(data, pinData, payrollNumber);

                credentialList.Add(credential);
                credentialData.CredentialList = credentialList;

                foreach (var store in storeList)
                {       
                  //this line causes an Object reference not set to an instance of an object error
                   await  _client.DoSomething(credentialData, store.StoreNumber);

                }
            }
        }
        catch (Exception ex)
        {
            throw new FaultException<Exception>(ex);
        }
    }

 /// </summary>
[TestClass]
public class SynchTest
{

    private Mock<ICredentialRepository> _mockRepository;
    private Mock<IClientProxy> _mockService;

    [TestInitialize]
    public void Setup()
    {
       ... some setups for repository which work fine
    }

[TestMethod]      
    public async Task SynchroniseData_WithOneEmployee_CallsReplicateService()
    {
        this._mockService = new Mock<IClientProxy>();
        this._mockService.Setup(x=>x.DoSomething(It.IsAny<CredentialDataList>(), It.IsAny<string>()));
        // arrange
        string payrollNumber = "1";
        CredentialSync service = new CredentialSync(this._mockRepository.Object, this._mockService.Object);

        // act
        await service.Synchronise(payrollNumber);

        // assert                 
        this._mockService.VerifyAll();
    }

服务等级

 public interface IClientProxy
{
     Task DoSomething(CredentialDataList credentialData, string store);
}

  public class CredentialSync : ICredentialSync
{
    private ICredentialRepository _repository;

    private IClientProxy _client;

    public CredentialSync()
    {
        this._repository = new CredentialRepository();
        this._client = new ClientProxy();
    }

    public CredentialSync(ICredentialRepository repository, IClientProxy client)
    {
        this._repository = repository;
        this._client = client;
    }

   public async Task Synchronise(string payrollNumber)
    {
        try
        {
            if (string.IsNullOrEmpty(payrollNumber))
            {
                .... some code
              }
            else
            {
                CredentialDataList credentialData = new CredentialDataList();
                List<CredentialData> credentialList = new List<CredentialData>();

                // fetch the record from the database
                List<GetCredentialData_Result> data = this._repository.GetCredentialData(payrollNumber);
                var pinData = this._repository.GetCredentialPinData(payrollNumber);

                // get the stores for this employee
                var storeList = data.Where(a => a.StoreNumber != null)
                    .GroupBy(a => a.StoreNumber)
                    .Select(x => new Store { StoreNumber = x.Key.ToString() }).ToArray();

                var credential = this.ExtractCredentialData(data, pinData, payrollNumber);

                credentialList.Add(credential);
                credentialData.CredentialList = credentialList;

                foreach (var store in storeList)
                {       
                  //this line causes an Object reference not set to an instance of an object error
                   await  _client.DoSomething(credentialData, store.StoreNumber);

                }
            }
        }
        catch (Exception ex)
        {
            throw new FaultException<Exception>(ex);
        }
    }

 /// </summary>
[TestClass]
public class SynchTest
{

    private Mock<ICredentialRepository> _mockRepository;
    private Mock<IClientProxy> _mockService;

    [TestInitialize]
    public void Setup()
    {
       ... some setups for repository which work fine
    }

[TestMethod]      
    public async Task SynchroniseData_WithOneEmployee_CallsReplicateService()
    {
        this._mockService = new Mock<IClientProxy>();
        this._mockService.Setup(x=>x.DoSomething(It.IsAny<CredentialDataList>(), It.IsAny<string>()));
        // arrange
        string payrollNumber = "1";
        CredentialSync service = new CredentialSync(this._mockRepository.Object, this._mockService.Object);

        // act
        await service.Synchronise(payrollNumber);

        // assert                 
        this._mockService.VerifyAll();
    }

public-class-CredentialSync:ICredentialSync
{
私有ICredentialRepository_存储库；
私人IClientProxy客户端；
公共凭证同步（）
{
此._repository=new CredentialRepository（）；
这是。_client=new ClientProxy（）；
}
public CredentialSync（ICredentialRepository存储库，IClientProxy客户端）
{
这个。_repository=repository；
这个._client=client；
}
公共异步任务同步（字符串payrollNumber）
{
尝试
{
if（string.IsNullOrEmpty（payrollNumber））
{
……一些代码
}
其他的
{
CredentialDataList credentialData=新的CredentialDataList（）；
List credentialList=新列表（）；
//从数据库中获取记录
List data=this.\u repository.GetCredentialData（payrollNumber）；
var pinData=this.\u repository.GetCredentialPinData（payrollNumber）；
//获取此员工的店铺
var storeList=data.Where（a=>a.StoreNumber！=null）
.GroupBy（a=>a.StoreNumber）
.Select（x=>newstore{StoreNumber=x.Key.ToString（）}）.ToArray（）；
var凭证=此.ExtractCredentialData（数据、pinData、工资卷编号）；
添加（凭证）；
credentialData.credentialist=认证师；
foreach（存储列表中的var存储）
{       
//此行导致对象引用未设置为对象错误的实例
等待客户提交文件（凭证数据、商店、商店编号）；
}
}
}
捕获（例外情况除外）
{
抛出新的FaultException（ex）；
}
}

测试类

 public interface IClientProxy
{
     Task DoSomething(CredentialDataList credentialData, string store);
}

  public class CredentialSync : ICredentialSync
{
    private ICredentialRepository _repository;

    private IClientProxy _client;

    public CredentialSync()
    {
        this._repository = new CredentialRepository();
        this._client = new ClientProxy();
    }

    public CredentialSync(ICredentialRepository repository, IClientProxy client)
    {
        this._repository = repository;
        this._client = client;
    }

   public async Task Synchronise(string payrollNumber)
    {
        try
        {
            if (string.IsNullOrEmpty(payrollNumber))
            {
                .... some code
              }
            else
            {
                CredentialDataList credentialData = new CredentialDataList();
                List<CredentialData> credentialList = new List<CredentialData>();

                // fetch the record from the database
                List<GetCredentialData_Result> data = this._repository.GetCredentialData(payrollNumber);
                var pinData = this._repository.GetCredentialPinData(payrollNumber);

                // get the stores for this employee
                var storeList = data.Where(a => a.StoreNumber != null)
                    .GroupBy(a => a.StoreNumber)
                    .Select(x => new Store { StoreNumber = x.Key.ToString() }).ToArray();

                var credential = this.ExtractCredentialData(data, pinData, payrollNumber);

                credentialList.Add(credential);
                credentialData.CredentialList = credentialList;

                foreach (var store in storeList)
                {       
                  //this line causes an Object reference not set to an instance of an object error
                   await  _client.DoSomething(credentialData, store.StoreNumber);

                }
            }
        }
        catch (Exception ex)
        {
            throw new FaultException<Exception>(ex);
        }
    }

 /// </summary>
[TestClass]
public class SynchTest
{

    private Mock<ICredentialRepository> _mockRepository;
    private Mock<IClientProxy> _mockService;

    [TestInitialize]
    public void Setup()
    {
       ... some setups for repository which work fine
    }

[TestMethod]      
    public async Task SynchroniseData_WithOneEmployee_CallsReplicateService()
    {
        this._mockService = new Mock<IClientProxy>();
        this._mockService.Setup(x=>x.DoSomething(It.IsAny<CredentialDataList>(), It.IsAny<string>()));
        // arrange
        string payrollNumber = "1";
        CredentialSync service = new CredentialSync(this._mockRepository.Object, this._mockService.Object);

        // act
        await service.Synchronise(payrollNumber);

        // assert                 
        this._mockService.VerifyAll();
    }

//
[测试类]
公共类同步测试
{
私有模拟库；
私人模拟服务；
[测试初始化]
公共作废设置（）
{
…存储库的一些设置工作正常
}
[测试方法]
公共异步任务已与一名员工同步数据\u调用复制服务（）
{
此._mockService=new Mock（）；
这个.u mockService.Setup（x=>x.DoSomething（It.IsAny（），It.IsAny（））；
//安排
字符串payrollNumber=“1”；
CredentialSync服务=新的CredentialSync（this.\u mockRepository.Object，this.\u mockService.Object）；
//表演
等待服务。同步（工资卷编号）；
//断言
此._mockService.VerifyAll（）；
}

调用

ClientProxy.DoSomething

时出错：

对象引用未设置为对象的实例

参数都很好

如果我将我的

ClientProxy.DoSomething

方法转换为同步方法

---

（public void

DoSomething（…）

）代码工作正常，但我确实需要异步调用它

DoSomething

返回

null

，而不是返回

任务

，因此在等待时会出现异常。在构建模拟时，需要指定它应该返回

任务

在这种情况下，您似乎可以使用

task.FromResult

简单地返回已完成的任务，因此模拟设置应如下所示：

this._mockService.Setup(...).Returns(Task.FromResult(false));

this._mockService.Setup(...).Returns(Task.CompletedTask);

---

从.Net（4.6）的下一个版本开始，您可以像这样使用

Task.CompletedTask

：

this._mockService.Setup(...).Returns(Task.FromResult(false));

this._mockService.Setup(...).Returns(Task.CompletedTask);

---

我认为您需要从

DoSomething

mock返回

任务

this._mockService.Setup(x => x.DoSomething(It.IsAny<CredentialDataList>(), It.IsAny<string>()))
    .Returns(Task.FromResult<int>(0));

this.\u mockService.Setup（x=>x.DoSomething（It.IsAny（），It.IsAny（））
.返回（Task.FromResult（0））；
使用ReturnsAsync可以减少代码中的混乱程度

this.\u mockService.Setup（…）.ReturnsAsync（false）

通过这种方式，您可以删除
任务。在这种情况下，应该注意，false只是一个占位符，值false实际上被mock忽略，它只需要一个任务，任何任务就可以完成。它也可以很容易地成为“foo”而不是false…@mcse3010确实如此。我对4.6语法投了赞成票，非常简洁，并且表明了它的实际含义。或者我最喜欢的是
。返回（Task.Delay（0））；