Meilleures pratiques de validation des paramètres

Imaginez que vous avez une application qui est une sorte de avant la fin de l' à tous de votre logique métier. Cette face avant a beaucoup de Dll dont il dépend, et les méthodes de ces Dll peuvent s'appeler les uns les autres à plusieurs reprises sur une seule exécution d'une méthode donnée dans le front-end. Si les utilisateurs de votre application n'avez pas directement accès à ces Dll, si vous...

1) le Risque d'une (petite) de performances et de valider les paramètres de chacune de ces méthodes, même si vous pouvez en validant les mêmes paramètres à 5 fois; ou

2) le Risque de comportements inattendus et supposons que, comme vous validez les paramètres d'entrée, tous les autres paramètres passés vers et à partir de votre code interne sont valides (par exemple, ni nulle ni vide)?

Edit: Juste pour donner un exemple, supposons que vous avez une Regex RegexA et une méthode

internal bool Matches(string expression)
{
    return RegexA.IsMatch(expression);
}

IsMatch lèvera une exception sur un paramètre null, mais pas sur la chaîne vide. Si vous savez à l'avance qu'une chaîne vide ne sera jamais un match pour que la Regex, devriez-vous utiliser if (String.IsNullOrEmpty(expression)) avant, même en sachant qu'il peut être validé pour une nullité à l'intérieur de la IsMatch cadre de la méthode? Dans ce cas, vous êtes clairement en répétant une validation, mais est-il mieux de le répéter ou à risque?

source d'informationauteur User | 2011-06-28

  1. 8

    Généralement des vérifications de paramètres sont très pas chermême si des milliers de fois.
    Par exemple tester si une valeur est null, une chaîne de caractères ou la Collection est vide, un numéro est dans une plage donnée.

    Mais méfiez-vous que des contrôles peuvent être cherdonc réfléchissez à deux fois: l'Évaluation d'une expression rationnelle sur une chaîne de grande taille, de vérifier si un fichier existe, en vérifiant que tous des éléments dans une collection répond à certains critères.

    J'aimerais aussi seulement vous recommandons de vérifier que dans public ou protégé méthodes.
    Noter que toutes les méthodes publiques avec décoché paramètres sont risques potentiels!

    MODIFIER/une autre pensée:
    Si une méthode n'utilise pas les paramètres, mais est juste de passage à une autre méthode, puis vous pouvez aussi omettre la vérification. Seulement la méthode qui est fait à l'aide de ces paramètres pour elle-même doit faire la vérification.

    C'est parce que si les exigences du changement dans les paramètres, vous devez changer les validations en plusieurs endroits, au risque de incohérence.

  2. 11

    À moins que la validation du paramètre est cher, je voudrais aller avec #1. Fail-fast comportement vous permet de repérer les bugs en une fraction du temps, ce qui vous permettra d'économiser beaucoup plus de temps qu'il n'en faut pour l'écrire un peu de garde consolidés au début de chaque méthode.

    Une technologie que vous pourriez être intéressés à aider avec cela .NET des Contrats de Code, qui vous permettent de créer des quasi-au moment de la compilation des vérifications pour s'assurer que personne ne l'appelle une méthode sans s'assurer que les entrées correspondent aux modèles.

    Personnellement, j'ai essayé d'utiliser le Code de Contrats, et a constaté qu'il y avait un peu trop de frais généraux pour mes besoins. Cependant, j'ai apprécié la syntaxe, j'ai donc fait une classe pour aider avec ces garde états, mais qui ne fonctionne qu'au moment de l'exécution. Il fonctionne comme ceci:

    public void ChangeUserName(int userId, string name)
{
    Require.ThatArgument(userId > 0);
    Require.ThatArgument(!string.IsNullOrWhitespace(name,
        () => "Usernames must be non-empty strings");
    var user = GetUser(userId);
    Require.That(user != null, 
        () => new UserDoesNotExistException("No user exists with ID " + userId));
    user.Name = name;
    ...
}

    Et une dernière technologie qui aide beaucoup pour ces contrôles est Resharper est Annotations. Considérons, par exemple, la méthode suivante:

    [CanBeNull]
public User GetUser(int userId)
{
    var user =  ... //Get the user from the db
    return user;
}

    En disant Resharper que la méthode peut retourner une valeur null, il saura vous avertir si vous ne l'avez pas fait un nul vérifier sur user avant d'essayer d'accéder user.Name. Une autre annotation est disponible pour Resharper que Require.That(user != null) constitue une valeur null vérifier. Vous pouvez également ré-écrire votre méthode comme ceci:

    [NotNull]
public User GetUser(int userId)
{
    Require.ThatArgument(userId > 0);
    var user =  ... //Get the user from the db
    Require.That(user != null)
    return user;
}

    Par marquage de cette méthode comme NotNull, Resharper peut automatiquement vous dire que user != null toujours résoudre à true de sorte que vous n'avez pas à les vérifier. Il y a toutes sortes de choses amusantes que vous pouvez faire pour le rendre plus facile de validation.

  3. 5

    En tant qu'auteur d'une bibliothèque, vous ne pouvez pas supposer que les consommateurs ont fait de la bonne validation des entrées, de sorte que vous comme une bibliothèque, l'auteur doit s'assurer que les arguments sont valides avant d'aller au travail avec eux.

    En tant que consommateur, d'une bibliothèque, si vous savez ce que sont les entrées va causer de la bibliothèque à l'échec, pourquoi voudriez-vous transmettre ces entrées à la bibliothèque? Valider contre eux, de sorte que vous pouvez peut-être inviter l'utilisateur pour une meilleure entrées ou autrement annuler quel que soit le processus, vous êtes en.

    Le fait que vous pourriez être l'auteur de la bibliothèque et le consommateur n'est pas particulièrement pertinent, à mon avis, que cette relation peut très bien changer.

  4. 1

    Sujet très intéressant 🙂

    en général, vous devriez mettre en œuvre une "validation de façade" plus bas que l'interface utilisateur et au niveau le plus bas possible fréquemment consultées par l'utilisateur de l'interface et des services externes.

    vous pouvez vérifier la valeur null et valider la saisie également dans l'INTERFACE utilisateur afin d'éviter une inutile d'aller-retour vers le serveur, côté client, la validation est une bonne pratique, toujours impossible de faire confiance à l'appelant uniquement de vous passer des valeurs valides.

  5. 1

    Vous pouvez obtenir des opinions divergentes, mais à mon avis..il est préférable de faire la validation en deux couches. À l'avant et à la logique d'entreprise (dll comme vous l'appelez)