领域设计模式的考虑

Question

我已经想出了下面的模式，我想在我的领域内使用。我的问题与其说是答案，不如说是意见。

用例：

每个域服务执行一个名为submit的操作，一个submit接受一个请求，它使用需求(验证和获取数据)，然后给出一个响应。

 public interface IDomainService<T, Y, X> 
    where Y : Resources.IBaseRequest
    where T : Resources.IBaseResponse
    where X : Resources.IBaseRequirements
{

    T Submit(Y request);

    X Requirements(Y request);
}

在上面的代码中，IBaseRequest、IBaseResponse和IBaseRequirements的定义不那么重要，因为它们主要具有共同的属性，但是通常，确定对象是请求、响应还是需求是很重要的。

调整服务的请求、响应和要求的示例。

 public interface IAdjustmentRequest : IBaseRequest
{
    AdjustmentType AdjustmentType { get; set; }

    decimal AdjustmentQty { get; set; }

    string TrackingEntityBarcode { get; set; }
}

public interface IAdjustmentRequirements : IBaseRequirements
{
    DomainEntities.TrackingEntity TrackingEntity { get; set; }
}

public interface IAdjustmentResponse : IBaseResponse
{
    DomainEntities.TrackingEntity TrackingEntity { get; set; }
}

在这个阶段，您可以看到每个对象所代表的内容，我认为这对我来说很重要，因为我需要澄清域，而不是创建非常具体和定义的服务接口。

实际的实现将接受请求，验证输入参数，获取数据(实体)并构建需求对象。在完成验证之后，或者如果满足了需求，您可以采取行动或持久化需求并构建您的响应。

在这个阶段，我想提到的是，如果我看我选择的单词，我会情不自禁地想，也许我错过了一些旧的设计模式(我的领域术语有点生疏)，但我指的是请求、响应和需求。

好的，让我继续展示一个已实现的服务。注意，我拿出了一些方法，但我想展示它的核心。

  public class AdjustmentService : DomainBaseService<IAdjustmentResponse, IAdjustmentRequest, IAdjustmentRequirements>
{
    protected internal override IAdjustmentRequirements TransactionRequirements(IAdjustmentRequest request)
    {
        Resources.AdjustmentRequirements response = new Resources.AdjustmentRequirements(request);
        try
        {
            //user
            base.RequestUser(request, ref response);

            //inventory
            response.TrackingEntity = this.ValidateTrackingEntity(request.TrackingEntityBarcode);

            //validate qty
            if (request.AdjustmentType == Interface.AdjustmentType.QtyDecrease)
                if (request.AdjustmentQty > response.TrackingEntity.Qty)
                    throw new Exception(ExceptionInsufficientOnhand);

            response.Valid = true;
            return response;
        }
        catch (Exception ex)
        {
            response.ErrorMessages = ex.Message;
            response.Valid = false;
            return response;
        }
    }
    protected internal override IAdjustmentResponse CommitTransaction(IAdjustmentRequirements request)
    {
        try
        {
            Resources.AdjustmentResponse response = new Resources.AdjustmentResponse()
            {
                Transactions = new List<Transaction>(),
                User = request.User
            };

            switch (request.AdjustmentType)
            {
                case Granite.DomainModel.Interface.AdjustmentType.QtyIncrease:
                    request.TrackingEntity.Qty += request.AdjustmentQty;
                    break;
                case Granite.DomainModel.Interface.AdjustmentType.QtyDecrease:
                    request.TrackingEntity.Qty -= request.AdjustmentQty;
                    break;
            }

            Transaction transaction = this.BuildProcessTransaction(request, request.TrackingEntity);

            response.Transactions.Add(transaction);
            response.TrackingEntity = request.TrackingEntity;

            Repository.Session.SaveOrUpdate(transaction);
            Repository.Session.SaveOrUpdate(request.TrackingEntity);

            response.ResponseMessage = string.Format("Adjusted {0} by {1}", request.TrackingEntityBarcode, request.AdjustmentQty);
            return response;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
    }



}

这两个方法在责任方面显然是分开的；一个执行所有的验证，如果通过验证，另一个执行持久性。

我想提到的是，调整是我处理的简单服务之一，值得注意的是，我的请求和响应映射到来自UI的模型、来自web的输入和我想要显示的响应。

总之，我要求的是建议，不是明确的答案或意见，也是采取这样一种方法的好处和失败之处。

Answer 1

我认为你的方法很好。但是，我要从下面的代码中提到两点：

try
{
  //user
  base.RequestUser(request, ref response);

  //inventory
  response.TrackingEntity = this.ValidateTrackingEntity(request.TrackingEntityBarcode);

  //validate qty
  if (request.AdjustmentType == Interface.AdjustmentType.QtyDecrease)
    if (request.AdjustmentQty > response.TrackingEntity.Qty)
      throw new Exception(ExceptionInsufficientOnhand);

  response.Valid = true;
  return response;
}
catch (Exception ex)
{
  response.ErrorMessages = ex.Message;
  response.Valid = false;
  return response;
}

1. 在检查股票是否可用时，会抛出一个异常(相当严重)(如果不够)，而当一个异常被捕获时，一个响应将被发回，而不会引发异常。在这种情况下，我将为两者发送一个响应，或者至少交换它们(抛出捕获的异常，用消息发送响应，说明库存不足)。
2. 最好使用依赖项注入来实现AdjustmentResponse和AdjustmentRequirements等的硬编码实现。这将允许两种情况:备用实现和来自接口的小实现的单元测试。