我有一个非常简单的模型，需要从数据库中验证

public class UserAddress
{
    public string CityCode {get;set;}
}

CityCode 可以具有仅在我的数据库表中可用的值。

我知道我可以做类似的事情。

[HttpPost]
public ActionResult Address(UserAddress model)
{
    var connection = ; // create connection
    var cityRepository = new CityRepository(connection);

    if (!cityRepository.IsValidCityCode(model.CityCode))
    {
        // Added Model error
    }
}

这看起来很WET，因为我必须在很多地方使用这个模型并且在每个地方添加相同的逻辑似乎我没有正确使用 MVC 架构。

那么，从数据库验证模型的最佳模式是什么？

注意: 大多数验证是从数据库中查找单个字段，其他验证可能包括字段组合。但现在我对单字段查找验证很满意，只要它是 DRY 并且没有使用太多反射就可以接受。

无客户端验证: 对于在客户端验证方面回答的任何人，我不需要任何此类验证，我的大部分验证都是服务器端的，我需要相同的，请不要使用客户端验证方法回答。

附言如果有人能给我提示如何从数据库进行基于属性的验证，将非常感谢。

最佳答案

请检查此答案中间附加的EDIT，以获得更详尽和通用的解决方案。

以下是我执行简单的基于属性的验证的解决方案。创建一个属性 -

public class Unique : ValidationAttribute
{
    public Type ObjectType { get; private set; }
    public Unique(Type type)
    {
        ObjectType = type;
    }
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        if (ObjectType == typeof(Email))
        {
            // Here goes the code for creating DbContext, For testing I created List<string>
            // DbContext db = new DbContext();
            var emails = new List<string>();
            emails.Add("ra@ra.com");
            emails.Add("ve@ve.com");

            var email = emails.FirstOrDefault(u => u.Contains(((Email)value).EmailId));

            if (String.IsNullOrEmpty(email))
                return ValidationResult.Success;
            else
                return new ValidationResult("Mail already exists");
        }

        return new ValidationResult("Generic Validation Fail");
    }
}

我创建了一个简单的模型来测试 -

public class Person
{
    [Required]
    [Unique(typeof(Email))]
    public Email PersonEmail { get; set; }
    [Required]
    public GenderType Gender { get; set; }
}

public class Email
{
    public string EmailId { get; set; }
}

然后我创建了以下 View -

@model WebApplication1.Controllers.Person
@using WebApplication1.Controllers;

<script src="~/Scripts/jquery-1.10.2.min.js"></script>
<script src="~/Scripts/jquery.validate.min.js"></script>
<script src="~/Scripts/jquery.validate.unobtrusive.min.js"></script>

@using (Html.BeginForm("CreatePersonPost", "Sale"))
{
    @Html.EditorFor(m => m.PersonEmail)

    @Html.RadioButtonFor(m => m.Gender, GenderType.Male) @GenderType.Male.ToString()
    @Html.RadioButtonFor(m => m.Gender, GenderType.Female) @GenderType.Female.ToString()
    @Html.ValidationMessageFor(m => m.Gender)

    <input type="submit" value="click" />
}

现在当我输入相同的电子邮件时 - ra@ra.com然后单击提交按钮 我可以在我的 POST 中得到错误 Action ，如下图。

编辑这里有更通用和详细的答案。

创建 IValidatorCommand -

public interface IValidatorCommand
{
    object Input { get; set; }
    CustomValidationResult Execute();
}

public class CustomValidationResult
{
    public bool IsValid { get; set; }
    public string ErrorMessage { get; set; }
}

假设我们有 Repository和 UnitOfWork以下列方式定义 -

public interface IRepository<TEntity> where TEntity : class
{
    List<TEntity> GetAll();
    TEntity FindById(object id);
    TEntity FindByName(object name);
}

public interface IUnitOfWork
{
    void Dispose();
    void Save();
    IRepository<TEntity> Repository<TEntity>() where TEntity : class;
} 

现在让我们创建我们自己的 Validator Commands -

public interface IUniqueEmailCommand : IValidatorCommand { }

public interface IEmailFormatCommand : IValidatorCommand { }

public class UniqueEmail : IUniqueEmailCommand
{
    private readonly IUnitOfWork _unitOfWork;
    public UniqueEmail(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }
    public object Input { get; set; }

    public CustomValidationResult Execute()
    {
        // Access Repository from Unit Of work here and perform your validation based on Input
        return new CustomValidationResult { IsValid = false, ErrorMessage = "Email not unique" };
    }
}

public class EmailFormat : IEmailFormatCommand
{
    private readonly IUnitOfWork _unitOfWork;
    public EmailFormat(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }
    public object Input { get; set; }

    public CustomValidationResult Execute()
    {
        // Access Repository from Unit Of work here and perform your validation based on Input
        return new CustomValidationResult { IsValid = false, ErrorMessage = "Email format not matched" };
    }
}

创建我们的 Validator Factory这将为我们提供基于类型的特定命令。

public interface IValidatorFactory
{
    Dictionary<Type,IValidatorCommand> Commands { get; }
}

public class ValidatorFactory : IValidatorFactory
{
    private static Dictionary<Type,IValidatorCommand> _commands = new Dictionary<Type, IValidatorCommand>();

    public ValidatorFactory() { }        

    public Dictionary<Type, IValidatorCommand> Commands
    {
        get
        {
            return _commands;
        }
    }

    private static void LoadCommand()
    {
        // Here we need to use little Dependency Injection principles and
        // populate our implementations from a XML File dynamically
        // at runtime. For demo, I am passing null in place of UnitOfWork
        _commands.Add(typeof(IUniqueEmailCommand), new UniqueEmail(null));
        _commands.Add(typeof(IEmailFormatCommand), new EmailFormat(null));
    }

    public static IValidatorCommand GetCommand(Type validatetype)
    {
        if (_commands.Count == 0)
            LoadCommand();            

        var command = _commands.FirstOrDefault(p => p.Key == validatetype);
        return command.Value ?? null;
    }
}

和翻新的验证属性 -

public class MyValidateAttribute : ValidationAttribute
{
    public Type ValidateType { get; private set; }
    private IValidatorCommand _command;
    public MyValidateAttribute(Type type)
    {
        ValidateType = type;            
    }
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        _command = ValidatorFactory.GetCommand(ValidateType);
        _command.Input = value;
        var result = _command.Execute();

        if (result.IsValid)
            return ValidationResult.Success;
        else
            return new ValidationResult(result.ErrorMessage);
    }
}

最后我们可以使用我们的属性如下 -

public class Person
{
    [Required]
    [MyValidate(typeof(IUniqueEmailCommand))]
    public string Email { get; set; }
    [Required]
    public GenderType Gender { get; set; }
}

输出如下——

编辑详细解释，使这个解决方案更通用。

假设我有一个属性 Email我需要做以下验证的地方 -

1. 格式
2. 长度
3. 独一无二

在这种情况下，我们可以创建 IEmailCommand继承自 IValidatorCommand .然后继承IEmailFormatCommand , IEmailLengthCommand和 IEmailUniqueCommand来自 IEmailCommand .

我们的 ValidatorFactory将在 Dictionary<Type, IValidatorCommand> Commands 中保存所有三个命令实现的池.

现在不用装饰我们的 Email三个命令的属性，我们可以用IEmailCommand修饰它.

在这种情况下，我们的 ValidatorFactory.GetCommand()方法需要改变。与其每次都返回一个命令，不如返回特定类型的所有匹配命令。所以基本上它的签名应该是 List<IValidatorCommand> GetCommand(Type validatetype) .

现在我们可以获得与属性关联的所有命令，我们可以循环命令并在我们的 ValidatorAttribute 中获得验证结果。 .

关于c# - 来自数据库的 MVC 模型验证，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31110329/