0

如果我有一个使用管道的应用程序，该管道具有许多要foreach在所有阶段上执行的阶段并调用：

CanExecute
Execute

界面是这样的：

public interface IService
{
    bool CanExecute(IContext subject);

    IContext Execute(IContext subject);
}

它基本上接受一个上下文并返回一个它变得更丰富的上下文。

在其中一个阶段Execute方法中，我需要调用服务，并且想要执行异步操作。所以现在Execute方法需要更改为例如

Task<IContext> ExecuteAsync(IContext subject);

用于await调用服务。

所有其他阶段都没有异步代码，但现在需要更改，因为最佳实践是“一路异步”。

引入异步代码时必须进行这些更改是否正常？

4

2 回答 2

0

引入异步代码时必须进行这些更改是否正常？

当您更改任何方法的签名时，必须进行更改是正常的。如果您想重命名它并更改返回类型，那么是的，调用该方法的任何地方都必须更改。

改变它们的最好方法是使它们也异步，一直到链上。

于 2019-11-05T16:27:41.020 回答
0

C# 8 提供了多种方法来避免修改同步服务。C# 7 也可以使用模式匹配语句来处理这个问题。

默认实现成员

接口版本控制是默认接口成员的主要用例之一。它们可用于避免在接口更改时更改现有类。您可以添加一个默认实现，ExecuteAsync以将结果Execute作为 ValueTask 返回。

假设您有这些接口：

public interface IContext{}

public interface IService
{
    public bool CanExecute(IContext subject);

    public IContext Execute(IContext subject);       
}

public class ServiceA:IService
{
    public bool CanExecute(IContext subject)=>true;
    public IContext Execute(IContext subject){return subject;}
}

要在不修改同步服务的情况下创建异步服务，您可以向 IService 添加默认实现并在新服务中覆盖它：

public interface IService
{
    public bool CanExecute(IContext subject);

    public IContext Execute(IContext subject);

    public ValueTask<IContext> ExecuteAsync(IContext subject)=>new ValueTask<IContext>(Execute(subject));

}

public class ServiceB:IService
{
    public bool CanExecute(IContext subject)=>true;
    public IContext Execute(IContext subject)=>ExecuteAsync(subject).Result;

    public async ValueTask<IContext> ExecuteAsync(IContext subject)
    {
        await Task.Yield();
        return subject;
    }
}

ServiceB.Execute仍然需要一个身体，而有意义的一件事是呼叫ExecuteAsync()和阻止，就像看起来一样丑陋。另一种可能性是抛出 ifExecute被调用：

public IContext Execute(IContext subject)=>throw new InvalidOperationException("This is an async service");

模式匹配

另一种选择是为异步服务创建第二个接口：

public interface IService
{
    public bool CanExecute(IContext subject);

    public IContext Execute(IContext subject);        

}

public interface IServiceAsync:IService
{        
    public ValueTask<IContext> ExecuteAsync(IContext subject);    
}

两种服务实现都将保持不变。管道代码将根据服务的类型进行更改以进行不同的调用：

async Task Main()
{
    IService[] pipeline=new[]{(IService)new ServiceA(),new ServiceB()};
    IContext ctx=new Context();
    foreach(var svc in pipeline)
    {
        if (svc.CanExecute(ctx))
        {
            var result=svc switch { IServiceAsync a=>await a.ExecuteAsync(ctx),
                                    IService b => b.Execute(ctx)};        
            ctx=result;
        }
    }
}

模式匹配表达式根据当前服务的类型调用不同的分支。对一个类型进行 Natch 会产生一个强类型实例（a 或 b），可用于调用适当的方法。

开关表达式是详尽的 - 如果编译器无法验证所有选项是否与模式匹配，编译器将生成警告。

C# 7

C# 7 没有 switch 表达式，因此需要更详细的模式匹配 switch 语句：

if (svc.CanExecute(ctx))
{
    switch (svc)
    {
        case IServiceAsync a:
            ctx=await a.ExecuteAsync(ctx);                    
            break;                    
        case IService b :
            ctx=b.Execute(ctx);        
            break;
        default:
            throw new InvalidOperationException("Unknown service type!");
    }
}

Switch语句并不详尽，因此我们需要添加该default部分以在运行时捕获错误。

于 2019-11-05T17:03:59.803 回答