FluentValidation règle pour objet null

J'ai essayé de travailler sur la façon de créer un FluentValidation règle qui vérifie si l'instance d'un objet, c'est la validation n'est pas null, avant la validation de ses propriétés.

Je préfère encapsuler cette null validation dans le Validateur, plutôt que de le faire dans le code appelant.

Voir l'exemple de code ci-dessous avec les commentaires où la logique requise est nécessaire:

namespace MyNamespace
{
    using FluentValidation;

    public class Customer
    {
        public string Surname { get; set; }
    }

    public class CustomerValidator: AbstractValidator<Customer> 
    {
        public CustomerValidator() 
        {
            //Rule to check the customer instance is not null.

            //Don't continue validating.

            RuleFor(c => c.Surname).NotEmpty();
        }
    }

    public class MyClass
    {
        public void DoCustomerWork(int id)
        {
            var customer = GetCustomer(id);
            var validator = new CustomerValidator();

            var results = validator.Validate(customer);

            var validationSucceeded = results.IsValid;
        }

        public Customer GetCustomer(int id)
        {
            return null;
        }
    }
}

Donc ma question est comment puis-je vérifier dans le CustomerValidator() constructeur que l'instance actuelle de la clientèle n'est pas null et abandonner autre règle de traitement si elle est nulle?

Merci d'avance.

Remplacer le Validate méthode?
Afin de disposer d'une extension de la méthode qui vérifie si elle est null premier avant d'appeler la base de Valider() la méthode?
Non, voir ma réponse ci-dessous. Vous appelez ça comme vous le feriez pour tout autre programme de validation.
La dernière réponse à cette question est de remplacer la PreValidate() la méthode. Exemple de Code ci-dessous.

InformationsquelleAutor Bern | 2013-06-13

c#fluentvalidation

28

Vous devriez être en mesure de remplacer la Validate méthode dans votre CustomerValidator classe.
```
public class CustomerValidator: AbstractValidator<Customer> 
{
    //constructor...

    public override ValidationResult Validate(Customer instance)
    {
        return instance == null 
            ? new ValidationResult(new [] { new ValidationFailure("Customer", "Customer cannot be null") }) 
            : base.Validate(instance);
    }
}
```
- Vous pouvez même couper à ceci: retour instance == null ? nouveau résultat validationresult(new [] { new ValidationFailure("Client", "le Client ne peut pas être null") }) : de base.Valider(instance);
- J'utilise la dernière version de FluentValidation et la Valider() n'a même pas de feu pour moi. Ce ne semble pas être possible.
- Je ne comprends pas comment Validate ne pas le feu puisque vous serait celui de l'appel de la méthode de validation.
- Cela n'a pas fonctionné pour moi sur 6.2.0 que je fais appel ValidateAndThrow méthode d'extension. Il explose avant même de faire mon substituée Validate méthode..
- Avez-vous trouvez une solution pour gérer la valeur null modèle dans l'api web ?
- J'ai créé une autre méthode d'extension. Voir la réponse ci-dessous stackoverflow.com/questions/17095791/...
- dépend entièrement de la façon dont vous utilisez la bibliothèque. si vous l'avez explicitement appel de valider que cela va fonctionner. Si vous utilisez WebAPI intégration, que d'avoir l'objet null permettra d'éviter Couramment de découvrir le type spécifique de programme de validation et donc Validate() ne sera pas appelé.
- Comme de 8.1.3 (lien), il semble que vous pouvez remplacer le PreValidate() méthode si vous souhaitez mettre en œuvre une logique personnalisée pour gérer la valeur null modèles qui sont passé au validateur.
InformationsquelleAutor Matthew
14

Je ne peux pas vraiment tester ce droit maintenant, mais vous pouvez essayer de remplacer Validate, ou de comprendre les règles dans le When bloc:
```
public CustomerValidator()
{
     When(x => x != null, () => {
         RuleFor(x => x.Surname).NotEmpty();
         //etc.
     });
}
```
- Sympa, mais est-il une manière que je peux appliquer un message de validation, par exemple .WithMessage("le Client n'existe pas."); ?
- Peut-être que vous pourriez faire RuleFor(x => x).NotNull().WithMessage("Customer does not exist");, mais à l'extérieur de la When bloc?
- Merci s'accoupler, oui j'ai essayé et il a jeté une exception. Je pense que @Matthieu réussi à clouer au-dessus.
- Bon, je suppose alors que primordial Validate est la meilleure façon d'aller ici
- Merci pour votre compagnon.
InformationsquelleAutor Patryk Ćwiek

Pour ceux qui utilisent une version >6.2.1 vous avez besoin de remplacer cette signature au lieu de cela, dans le but de réaliser la même chose que @chrispr:

public override ValidationResult Validate(ValidationContext<T> context)
{
    return (context.InstanceToValidate == null) 
        ? new ValidationResult(new[] { new ValidationFailure("Property", "Error Message") })
        : base.Validate(context);       
}

Cette méthode ni pas viré pour WebApi.

InformationsquelleAutor Elmar

J'ai hérité de la fluidité de la AbstractValidator et créé un NullReferenceAbstractValidator classe à la place:

public class NullReferenceAbstractValidator<T> : AbstractValidator<T>
{
    public override ValidationResult Validate(T instance)
    {
        return instance == null
            ? new ValidationResult(new[] { new ValidationFailure(instance.ToString(), "response cannot be null","Error") })
            : base.Validate(instance);
    }
}

et puis héritée de la classe avec chaque validateur qui avait besoin d'une référence null check:

public class UserValidator : NullReferenceAbstractValidator<User>

pourquoi faites-vous de l'instance.ToString() lorsqu'une instance est nulle?

InformationsquelleAutor chrispr

Que les solutions ci-dessus ne fonctionne pas pour moi (FluentValidation, Version=6.2.1.0 pour Net45), je vous poste ce que j'ai fait.
C'est juste un simple remplacement/wrapper pour ValidateAndThrow méthode d'extension.

public static class ValidatorExtensions
{
    public static void ValidateAndThrowNotNull<T>(this IValidator<T> validator, T instance)
    {
        if (instance == null)
        {
            var validationResult = new ValidationResult(new[] { new ValidationFailure("", "Instance cannot be null") });
            throw new ValidationException(validationResult.Errors);
        }
        validator.ValidateAndThrow(instance);
    }
}

InformationsquelleAutor Lee Campbell

1

Utilisation du mode Cascade.

Voici l'exemple de la la documentation.
```
RuleFor(x => x.Surname).Cascade(CascadeMode.StopOnFirstFailure).NotNull().NotEqual("foo");
```
Également de la documentation:

Si le NotNull programme de validation échoue, alors le NotEqual validateur ne sera pas
exécutée. Ceci est particulièrement utile si vous avez une chaîne complexe
où chaque validateur dépend de la précédente validateur pour réussir.

InformationsquelleAutor Trevor
1

Remplacer EnsureInstanceNotNull comme ci-dessous
```
protected override void EnsureInstanceNotNull(object instanceToValidate)
{
    if(instanceToValidate==null)
      throw new ValidationException("Customer can not be null");
}
```
- Substitution de cette méthode est la méthode "officielle" comme expliqué ici: github.com/JeremySkinner/FluentValidation/issues/486
- Lorsque cette méthode est en cours d'exécution? Avant la ValidateMethod?
InformationsquelleAutor CreativeManix

Par le biais de la Coutume(). Il peut être également très utile lors de la validation d'un autre champ est basé sur la validation de votre domaine.

ruleBuilder.Custom((obj, context) =>
        {
            if (obj != null)
            {
                var propertyName = <field where should be validation>;
                context.AddFailure(propertyName, "'Your field name' Your validation message.");
            }
        });

InformationsquelleAutor user7617828

1

C'est un vieux post, mais souhaitez mettre à jour les réponses à inclure les éléments suivants à partir de la FluentValidation documentation:

À L'Aide De PreValidate

Si vous avez besoin pour l'exécution de code spécifique à chaque fois qu'un validateur est invoquée, vous pouvez le faire en remplaçant la PreValidate méthode. Cette méthode prend un ValidationContext ainsi qu'un résultat validationresult, que vous pouvez utiliser pour personnaliser le processus de validation.
```
public class MyValidator : AbstractValidator<Person> {
  public MyValidator() {
    RuleFor(x => x.Name).NotNull();
  }

  protected override bool PreValidate(ValidationContext<Person> context, ValidationResult result) {
    if (context.InstanceToValidate == null) {
      result.Errors.Add(new ValidationFailure("", "Please ensure a model was supplied."));
      return false;
    }
    return true;
  }
}
```
https://fluentvalidation.net/start#using-prevalidate

InformationsquelleAutor camainc

Vous devez vous connecter pour publier un commentaire.