规范模式异步

时间:2017-08-14 14:27:42

标签: c# design-patterns async-await domain-driven-design specification-pattern

我正在尝试将Specification pattern应用于我的验证逻辑。但我在异步验证方面遇到了一些问题。

假设我有一个需要验证的实体AddRequest(有2个字符串属性FileName和Content)。

我需要创建3个验证器:

  1. 验证FileName是否包含无效字符

  2. 验证内容是否正确

  3. 异步验证数据库中是否存在带FileName的文件。在这种情况下,我应该有Task<bool> IsSatisfiedByAsync

  4. 之类的东西

    但我如何实施IsSatisfiedByIsSatisfiedByAsync?我应该创建2个接口,例如ISpecificationIAsyncSpecification,还是可以在一个接口中创建?

    我的ISpecification版本(我只需要And)

        public interface ISpecification
        {
            bool IsSatisfiedBy(object candidate);
            ISpecification And(ISpecification other);
        }
    

    AndSpecification

    public class AndSpecification : CompositeSpecification 
    {
        private ISpecification leftCondition;
        private ISpecification rightCondition;
    
        public AndSpecification(ISpecification left, ISpecification right) 
        {
            leftCondition = left;
            rightCondition = right;
        }
    
        public override bool IsSatisfiedBy(object o) 
        {
            return leftCondition.IsSatisfiedBy(o) && rightCondition.IsSatisfiedBy(o);
        }
    }
    

    要验证文件是否存在,我应该使用:

     await _fileStorage.FileExistsAsync(addRequest.FileName);
    

    如果我真的需要这样做,我如何为该检查编写IsSatisfiedBy

    例如,我的FileName

    的验证器(1)
    public class FileNameSpecification : CompositeSpecification 
    {
        private static readonly char[] _invalidEndingCharacters = { '.', '/' };
    
        public override bool IsSatisfiedBy(object o) 
        {
            var request = (AddRequest)o;
            if (string.IsNullOrEmpty(request.FileName))
            {
                return false;
            }
            if (request.FileName.Length > 1024)
            {
                return false;
            }
            if (request.FileName.Contains('\\') || _invalidEndingCharacters.Contains(request.FileName.Last()))
            {
                return false;
            }
    
            return true
        }
    }
    

    我需要创建FileExistsSpecification并使用如下:

    var validations = new FileNameSpecification().And(new FileExistsSpecification());
    if(validations.IsSatisfiedBy(addRequest)) 
    { ... }
    

    但是,如果我需要异步,我该如何创建FileExistsSpecification

3 个答案:

答案 0 :(得分:3)

  

但是如何实现IsSatisfiedBy和IsSatisfiedByAsync呢?我应该创建2个接口,如ISpecification和IAsyncSpecification,还是可以在一个接口中创建?

您可以定义同步和异步接口,但任何通用复合实现都必须只实现异步版本。

由于asynchronous methods on interfaces mean "this might be asynchronous",而同步方法意味着“此必须是同步的”,我将使用异步接口,因此:

public interface ISpecification
{
  Task<bool> IsSatisfiedByAsync(object candidate);
}

如果您的许多规范是同步的,您可以帮助使用基类:

public abstract class SynchronousSpecificationBase : ISpecification
{
  public virtual Task<bool> IsSatisfiedByAsync(object candidate)
  {
    return Task.FromResult(IsSatisfiedBy(candidate));
  }
  protected abstract bool IsSatisfiedBy(object candidate);
}

复合材料将是:

public class AndSpecification : ISpecification 
{
  ...

  public async Task<bool> IsSatisfiedByAsync(object o) 
  {
    return await leftCondition.IsSatisfiedByAsync(o) && await rightCondition.IsSatisfiedByAsync(o);
  }
}

public static class SpecificationExtensions
{
  public static ISpecification And(ISpeicification @this, ISpecification other) =>
      new AndSpecification(@this, other);
}

以及个别规格:

public class FileExistsSpecification : ISpecification
{
  public async Task<bool> IsSatisfiedByAsync(object o)
  {
    return await _fileStorage.FileExistsAsync(addRequest.FileName);
  }
}

public class FileNameSpecification : SynchronousSpecification 
{
  private static readonly char[] _invalidEndingCharacters = { '.', '/' };

  public override bool IsSatisfiedBy(object o) 
  {
    var request = (AddRequest)o;
    if (string.IsNullOrEmpty(request.FileName))
      return false;
    if (request.FileName.Length > 1024)
      return false;
    if (request.FileName.Contains('\\') || _invalidEndingCharacters.Contains(request.FileName.Last()))
      return false;
    return true;
  }
}

用法:

var validations = new FileNameSpecification().And(new FileExistsSpecification());
if (await validations.IsSatisfiedByAsync(addRequest))
{ ... }

答案 1 :(得分:-1)

我不知道为什么你需要以同步驱动模式进行异步操作。

想象一下,如果第一个结果是false,并且您有两个或更多异步检查,那么性能就会浪费。

如果您想知道如何同步获取异步请求,可以尝试使用以下内容:

public class FileExistsSpecification : CompositeSpecification
{
    public override bool IsSatisfiedBy(object o)
    {
        var addRequest = (AddRequest)o
        Task<bool> fileExistsResult = _fileStorage.FileExistsAsync(addRequest.FileName);
        fileExistsResult.Wait();

        return fileExistsResult.Result;
    }
}

您还应该使用泛型方法。

答案 2 :(得分:-1)

我认为你的主要目标是确保代码在评估复合规范时尽快完成,在执行子规范时,一个或多个可能需要一段时间,是吗?调用模式实现之外的代码总是可以异步调用规范;在那一点上,你并不是真的关心它。

那么,鉴于此,如何为您的ISpecification提供额外的财产?

public interface ISpecification 
{
    bool IsAsynchronous { get; }
    bool IsSatisfiedBy(object o);
}

然后,对于非复合同步或异步类型规范,硬编码IsAsynchronous的返回值。但在复合材料中,以儿童为基础,即:

public class AndSpecification : ISpecification
{
    private ISpecification left;
    private ISpecification right;

    public AndSpecification(ISpecification _left, ISpecification _right) 
    {
        if (_left == null || _right == null) throw new ArgumentNullException();        
        left = _left;
        right = _right;
    }

    public bool IsAsynchronous { get { return left.IsAsynchronous || right.IsAsynchronous; }

    public override bool IsSatisfiedBy(object o) 
    {
        if (!this.IsAsynchronous)            
            return leftCondition.IsSatisfiedBy(o) && rightCondition.IsSatisfiedBy(o);

        Parallel.Invoke(
            () => {
                if (!left.IsSatisfiedBy(o)) return false;
            },
            () => {
                if (!right.IsSatisfiedBy(o)) return false;
            }
        );

        return true;
    }
}

但是更进一步,你不想浪费性能。因此,当有一个同步和一个异步时,为什么不首先评估快速,同步的孩子呢?这是基本概念的更接近完成的版本:

public class AndSpecification : ISpecification
{
    private ISpecification left;
    private ISpecification right;

    public AndSpecification(ISpecification _left, ISpecification _right) 
    {
        if (_left == null || _right == null) throw new ArgumentNullException();        
        left = _left;
        right = _right;
    }

    public bool IsAsynchronous { get { return left.IsAsynchronous || right.IsAsynchronous; }

    public override bool IsSatisfiedBy(object o) 
    {
        if (!left.IsAsynchronous) 
        {
            if (!right.IsAsynchronous) 
            {
                return left.IsSatisfiedBy(o) && right.IsSatisfiedBy(o);
            }
            else
            {
                if (!left.IsSatisfiedBy(o)) return false;
                return right.IsSatisfiedBy(o);
            } 
        }
        else if (!right.IsAsynchronous) 
        {
            if (!right.IsSatisfiedBy(o)) return false;
            return left.IsSatisfiedBy(o);
        }
        else
        {
            Parallel.Invoke(
                () => {
                    if (!left.IsSatisfiedBy(o)) return false;
                },
                () => {
                    if (!right.IsSatisfiedBy(o)) return false;
                }
            );

            return true;
        }
    }
}