У меня есть метод проверки, который вызвал некоторые другие инструменты:

public ValidationResult Validate(Some arg) {
    var errors = new List<ValidationError>();

    validate1(arg, errors);
    if (errors.Count > 0) {
        return ValidationResult.Failed(errors);
    }

    validate2(arg, other, errors);
    if (errors.Count > 0) {
        return ValidationResult.Failed(errors);
    }

    validate3(arg, other2, errors);
    if (errors.Count > 0) {
        return ValidationResult.Failed(errors);
    }

    return ValidationResult.Succeess();
}

Я хочу, чтобы какой-то способ сделать код, как показано ниже, используйте цикл for для вызова каждого валидатора:

public ValidationResult Validate(Some arg) {
    var errors = new List<ValidationError>();

    var validators = new [] {
        validate1(arg, errors),
        validate2(arg, other, errors),
        validate3(arg, other2, errors)
    };

    foreach (var validator in validators) {
        validator.invoke();
        if (errors.Count > 0) {
            return ValidationResult.Failed(errors);
        }
    }

    return ValidationResult.Success();
}

Как я могу это сделать?

2
PM Extra 4 Сен 2017 в 11:46

4 ответа

Лучший ответ

Вы можете попробовать это

var validators = new Action[]  {
    ()=>validate1(arg, errors),
    ()=>validate2(arg, other, errors),
    ()=>validate3(arg, other2, errors)
};

foreach (var v in  validators)
    v();
7
tym32167 4 Сен 2017 в 08:54

Спасибо @ tym32167!

И у меня есть некоторые дополнительные сведения об асинхронности:

        var validations = new Func<Task>[]
        {
            async () => await ValidateAsync(arg, other, errors)
        };

        foreach (var validation in validations)
        {
            await validation();
            if (errors.Count > 0)
            {
                return ValidationResult.Failed(errors);
            }
        }
0
PM Extra 4 Сен 2017 в 10:57

Что ж, я рассматриваю реализацию валидации в стиле Fluent:

public interface IValidator<T>
{
    IEnumerable<ValidationError> Validate(T obj);
    IEnumerable<ValidationError> ValidateAll(IEnumerable<T> obj);
}


public class SomeTypeValidator : IValidator<SomeType>
{
    private readonly IValidator<SomeNestedType> _validator1;
    public SomeTypeValidator(IValidator<SomeNestedType> validator1)
    {
        _validator1 = validator1;
    }

    public IEnumerable<ValidationError> Validate(SomeType obj)
    {
        yield return Error("My first error");
        foreach(var e in _validator1.Validate(obj.val1))
        {
             yield return e;
        }
        /*whatever you desire goes here*/
    }

    public IEnumerable<ValidationError> ValidateAll(IEnumerable<SomeType> objs)
    {
        return objs.SelectMany(Validate);
    }
}

Тогда какое-то полезное расширение:

public static void ThrowIfInvalid(this IEnumerable<ValidationError> errors)
{
    if(errors == null)
       return;
    var e = errors.ToList();
    if(e.Any())
    {
        throw new Exception(\*use 'e' here to form exception*\);
    }
}

Тогда где-то в коде я называю это так:

_validator.Validate(new SomeType()).ThrowIfInvalid();

Таким образом, вы освободите себя от этих списков / пакетов ошибок повсюду и просто перенаправите потоки ошибок валидации в любой другой валидатор, который вы пожелаете. Также вы всегда можете прекратить валидацию в некоторый момент, вызвав yield break, и сможете создать из них ансамбль.

0
eocron 4 Сен 2017 в 09:12

Вы можете определить общий интерфейс для валидаторов и реализовать класс для каждого варианта использования.

public interface IValidator {
    ValidationResult Invoke();
}

public class Validator1 : IValidator {
    private string _arg;
    private List<ValidationError> _errors;

    Validator1(string arg, List<ValidationError> errors) {
        _arg = arg; 
       _errors = errors
    }

    public ValidationResult Validate() {
        if (_errors.Count > 0) {
            return ValidationResult.Failed(_errors);
        }
        return ValidationResult.Success();
    }
}

Затем вы можете работать со списком экземпляров IValidator.

public ValidationResult Validate(Some arg) {
    var errors = new List<ValidationError>();

    var validators = new IValidator[] {
        new Validator1(arg, errors),
        new Validator2(arg, other, errors),
        new Validator3(arg, other2, errors)
    };

    foreach (var validator in validators) {
        var result = validator.Invoke();
        if (result != ValidationResult.Success()) {
            return result;
        }
    }

    return ValidationResult.Success();
}
1
Georg Patscheider 4 Сен 2017 в 09:23