Question

我使用的方法类似于此ASP.NET MVC tutorial中的方法，您将控制器的ModelState集合周围的包装器传递给验证类，以便控制器可以访问错误信息。

这是一个熟练的例子：

interface IProductValidator {
   void Validate(Product item);
}

class ProductValidator {
   // constructor
   public ProductValidator(ModelStateWrapper validationDictionary) { }
}

interface IProductService {
   void AddProduct();
}

public class ProductService : IProductService {
   // constructor
   public ProductService(IProductValidator validator) { }
}

使用Castle Windsor容器进行IoC / DI，如何创建IProductService？通常情况下，我会：

MvcApplication.IocContainer.Resolve<IProductService>()

但是无法将Controller的ModelState属性的值注入到ProductValidator的构造函数中。我可以使用构造函数参数来连接它，但这看起来真的很难看。

Answer 1

我假设您希望传入的模型状态自动将任何错误注入模型中？恕我直言，ModelState应该保持原样，并将验证错误带到它。以下是我如何处理错误的例子。我不是说这是最好的方式或唯一的方法，但它是一种方法，您的验证层不必知道谁或什么消耗验证错误。

首先，在我的poco中，我使用System.ComponentModel.DataAnnotations作为验证规则。例如，这是我的帐户类。

public class Account : CoreObjectBase<Account>
{
    public virtual int AccountId { get; set; }

    [Required(ErrorMessage = "Email address is required.")]
    public virtual string EmailAddress { get; set; }

    [Required(ErrorMessage = "A password is required.")]
    public virtual string Password { get; set; }
}

因为我希望能够自己启动验证（在MVC之外自己进行验证），我必须实现自己的验证器。

public class Validator<T> where T : CoreObjectBase<T>
{
    public ValidationResponse Validate(T entity)
    {
        var validationResults = new List<ValidationResult>();
        var context = new ValidationContext(entity, null, null);
        var isValid = Validator.TryValidateObject(entity, context, validationResults);

        return new ValidationResponse(validationResults.ToArray());
    }
}

这是我传回的ValidationResult

[Serializable]
public class ValidationResponse
{
    public IList<ValidationResult> Violations { get; private set; }

    public IList<ErrorInfo> Errors { get; private set; }

    public bool HasViolations
    {
        get { return Violations.Count > 0; }
    }

    public ValidationResponse(params ValidationResult[] violations)
    {
        Violations = new List<ValidationResult>(violations);

        var errors = from v in Violations
                     from n in v.MemberNames
                     select new ErrorInfo(n, v.ErrorMessage);

        Errors = errors.ToList();
    }

}

ErrorInfo是一个非常基本的类，包含有关我的错误的信息

[Serializable]
public class ErrorInfo
{
    public string ErrorMessage { get; private set; }
    public object Object { get; private set; }
    public string PropertyName { get; private set; }

    public ErrorInfo(string propertyName, string errorMessage)
        : this(propertyName, errorMessage, null)
    {

    }

    public ErrorInfo(string propertyName, string errorMessage, object onObject)
    {
        PropertyName = propertyName;
        ErrorMessage = errorMessage;
        Object = onObject;
    } 
}

为了将这个验证包装好我的poco类，我继承了一个基类。对于验证，使其成为通用的继承子必须告诉基类的类型。它感觉循环，但它的工作原理。

[Serializable]
public class CoreObjectBase<T> : IValidatable where T : CoreObjectBase<T>  
{
    #region IValidatable Members

    public virtual bool IsValid
    {
        get
        {
            // First, check rules that always apply to this type
            var result = new Validator<T>().Validate((T)this);

            // return false if any violations occurred
            return !result.HasViolations;
        }
    }

    public virtual ValidationResponse ValidationResults
    {
        get
        {
            var result = new Validator<T>().Validate((T)this);
            return result;
        }
    }

    public virtual void Validate()
    {
        // First, check rules that always apply to this type
        var result = new Validator<T>().Validate((T)this);

        // throw error if any violations were detected
        if (result.HasViolations)
            throw new RulesException(result.Errors);
    }

    #endregion
}

最后，正如您所看到的，我的验证会抛出一个RulesException。这个类是所有错误的包装器。

[Serializable]
public class RulesException : Exception 
{
    public IEnumerable<ErrorInfo> Errors { get; private set; }

    public RulesException(IEnumerable<ErrorInfo> errors)
    {
        Errors = errors != null ? errors : new List<ErrorInfo>();
    }

    public RulesException(string propertyName, string errorMessage) : 
        this(propertyName, errorMessage, null)
    {

    }

    public RulesException(string propertyName, string errorMessage, object onObject) : 
        this (new ErrorInfo[] { new ErrorInfo(propertyName, errorMessage, onObject) } )
    {

    }
}

所以，说到这一点，我在我的控制器中的验证看起来更像是

public ActionResult MyAction()
{
   try
   {
      //call validation here
   }
   catch (RulesException ex)
   {
      ModelState.AddModelStateErrors(ex);
   }

   return View();
}

ModelState.AddModelStateErrors（前）;是我写的扩展方法。这很简单。

    public static void AddModelStateErrors(this System.Web.Mvc.ModelStateDictionary modelState, RulesException exception)
    {
        foreach (ErrorInfo info in exception.Errors)
        {
            modelState.AddModelError(info.PropertyName, info.ErrorMessage);
        }
    }

这样，我仍然可以将DI用于我的服务/存储库，并在模型无效时让它们抛出错误。然后我让前端 - 无论是MVC应用程序，Web服务还是Windows应用程序 - 决定如何处理这些错误。

我觉得将MVC控制器/模型/视图状态注入模型/ services / repositories / etc是违反了层之间的基本分离。

将ASP.NET MVC Controller属性注入服务层依赖项？

1 个答案: