Plusieurs méthodes de vérification des paramètres d'arrière-plan ASP.NET MVC

Avant-propos

La vérification des paramètres est un problème courant. Qu'il s'agisse du front-end ou du back-end, les entrées de l'utilisateur doivent être vérifiées pour garantir l'exactitude des données du système. Pour le Web, certaines personnes voudront peut-être le vérifier sur le front-end, mais c'est une très mauvaise approche. Le code du front-end est transparent pour les utilisateurs, et les personnes disposant d'un peu de technologie peuvent contourner cela. vérification et soumettre les données directement. Qu'il s'agisse de l'interface soumise par la page web front-end ou de l'interface fournie vers l'extérieur, la vérification des paramètres est visible partout et est essentielle. En bref, toutes les entrées des utilisateurs ne sont pas dignes de confiance.

Il existe de nombreuses façons d'effectuer la vérification des paramètres. Prenons mvc comme exemple pour répertorier plusieurs méthodes de vérification courantes. Supposons qu'il existe une méthode d'enregistrement des utilisateurs

[HttpPost]
public ActionResult Register(RegisterInfo info)

.

1. Jugement par if-if

if(string.IsNullOrEmpty(info.UserName))
 
{
 
  return FailJson("用户名不能为空");
 
}
 
if(string.IsNullOrEmpty(info.Password))
 
{
 
  return FailJson("用户密码不能为空")
 
}

Vérifiez les paramètres un par un Cette méthode est la plus grossière, mais en plus. temps sous WebForm Il a en effet été utilisé de cette façon. C'est bien pour la méthode avec peu de paramètres. S'il y a plus de paramètres, vous devez écrire n autres if-ifs, ce qui est assez fastidieux, cette partie du jugement ne peut pas être réutilisée.

2. Grâce à DataAnnotation

mvc fournit DataAnnotation pour vérifier le modèle d'action. En dernière analyse, DataAnnotation est une série de caractéristiques qui héritent de ValidationAttribute, telles que RangeAttribute, RequiredAttribute, etc. La méthode virtuelle IsValid de ValidationAttribute est utilisée pour déterminer si l'objet marqué est conforme aux règles actuelles. Lorsque asp.net mvc effectue la liaison de modèle, il obtiendra le ValidationAttribute marqué par réflexion, puis appellera IsValid pour déterminer si les paramètres actuels sont conformes aux règles. Si la vérification échoue, les informations d'erreur seront également collectées. Utilisez ModelState.IsValid pour déterminer si la vérification du modèle réussit et utilisez ModelState pour obtenir la raison de l'échec de la vérification. Par exemple, l'exemple ci-dessus :

public class RegisterInfo
 
{
 
  [Required(ErrorMessage="用户名不能为空")]
 
  public string UserName{get;set;}
 
 [Required(ErrorMessage="密码不能为空")]
 
  public string Password { get; set; }
 
}

En fait, ce processus peut également être implémenté sur un formulaire Web en se référant au principe d'implémentation de mvc. Les avantages de cette méthode sont très élégants et flexibles à mettre en œuvre. S'il y a plusieurs actions partageant un paramètre de modèle, il suffit de l'écrire au même endroit. La clé est que cela donne à notre code un aspect très concis.

Cependant, cette méthode présente également des inconvénients. Habituellement, nos projets peuvent avoir de nombreuses interfaces, par exemple des dizaines d'interfaces. Certaines interfaces n'ont que deux ou trois paramètres. Il est un peu luxueux de définir un paramètre d'empaquetage de classe pour chacune. interface. Et en fait, nommer cette classe est également un véritable casse-tête.

3. DataAnnotation peut également être marquée sur les paramètres

Vous pouvez voir à travers l'AttributeUsage de la fonction de vérification qu'elle peut être marquée non seulement sur les attributs et les champs, mais également sur les paramètres. En d'autres termes, nous pouvons aussi écrire comme ceci :

public ActionResult Register([Required(ErrorMessage="用户名不能为空")]string userName, [Required(ErrorMessage="密码不能为空")]string password)

Écrire comme ceci est également OK, mais évidemment, écrire des paramètres de méthode comme celui-ci sera moche , en particulier lorsqu'il y a plusieurs paramètres ou que les paramètres ont plusieurs règles de validation.

4. Custom ValidateAttribute

Nous savons que nous pouvons utiliser des filtres pour effectuer certains traitements avant l'exécution de l'action de mvc, comme la vérification d'identité et le traitement des autorisations. De la même manière, il peut également être utilisé pour vérifier des paramètres. FilterAttribute est un filtre commun qui nous permet d'effectuer certaines opérations avant et après l'exécution de l'action. Ce que nous devons faire ici est de vérifier les paramètres avant l'action. Si la vérification échoue, elle ne sera plus exécutée.

Définissez une classe de base BaseValidateAttribute comme suit :

public class BaseValidateAttribute : FilterAttribute
 
{
 
  protected virtual void HandleError(ActionExecutingContext context)
 
  {
 
    for (int i = ValidateHandlerProviders.Handlers.Count; i > 0; i--)
 
    {
 
      ValidateHandlerProviders.Handlers[i - 1].Handle(context);
 
      if (context.Result != null)
 
      {
 
        break;
 
      }
 
    }
 
  }
 
}

Pour le traitement des résultats, elle peut être enregistrée en externe. IValidateHandler est défini comme suit :

public interface IValidateHandler
 
{
 
  void Handle(ActionExecutingContext context);
 
}

ValidateHandlerProviders est défini comme suit, il a un gestionnaire par défaut.

public class ValidateHandlerProviders
 
{
 
  public static List<IValidateHandler> Handlers { get; private set; }
 
  
 
  static ValidateHandlerProviders()
 
  {
 
    Handlers = new List<IValidateHandler>()
 
    {
 
      new DefaultValidateHandler()
 
    };
 
  }
 
  
 
  public static void Register(IValidateHandler handler)
 
  {
 
    Handlers.Add(handler);
 
  }
 
}　　

Le but de ceci est que, puisque nous pouvons avoir de nombreux ValidateAttributes spécifiques, nous pouvons séparer ce module et séparer le processus de traitement final. Laissez-le à l'externe Par exemple, nous pouvons définir un processeur dans le projet :

public class StanderValidateHandler : IValidateHandler
 
{
 
  public void Handle(ActionExecutingContext filterContext)
 
  {
 
    filterContext.Result = new StanderJsonResult()
 
    {
 
      Result = FastStatnderResult.Fail("参数验证失败", 555)
 
    };
 
  }
 
}

puis l'enregistrer au démarrage de l'application : ValidateHandlerProviders.Handlers.Add ( new StanderValidateHandler());

Deux exemples :

ValidateNullttribute :

public class ValidateNullAttribute : BaseValidateAttribute, IActionFilter
 
{
 
  public bool ValidateEmpty { get; set; }
 
  
 
  public string Parameter { get; set; }
 
  
 
  public ValidateNullAttribute(string parameter, bool validateEmpty = false)
 
  {
 
    ValidateEmpty = validateEmpty;
 
    Parameter = parameter;
 
  }
 
  
 
  public void OnActionExecuting(ActionExecutingContext filterContext)
 
  {
 
    string[] validates = Parameter.Split(',');
 
    foreach (var p in validates)
 
    {
 
      string value = filterContext.HttpContext.Request[p];
 
      if(ValidateEmpty)
 
      {
 
        if (string.IsNullOrEmpty(value))
 
        {
 
          base.HandleError(filterContext);
 
        }
 
      }
 
      else
 
      {
 
        if (value == null)
 
        {
 
          base.HandleError(filterContext);
 
        }
 
      }
 
    }
 
  }
 
  
 
  public void OnActionExecuted(ActionExecutedContext filterContext)
 
  {
 
  
 
  }
 
}

ValidateRegexAttribute :

public class ValidateRegexAttribute : BaseValidateAttribute, IActionFilter
 
{
 
  private Regex _regex;
 
  
 
  public string Pattern { get; set; }
 
  
 
  public string Parameter { get; set; }
 
  
 
  public ValidateRegexAttribute(string parameter, string pattern)
 
  {
 
    _regex = new Regex(pattern);
 
    Parameter = parameter;
 
  }
 
  
 
  public void OnActionExecuting(ActionExecutingContext filterContext)
 
  {
 
    string[] validates = Parameter.Split(',');
 
    foreach (var p in validates)
 
    {
 
      string value = filterContext.HttpContext.Request[p];
 
      if (!_regex.IsMatch(value))
 
      {
 
        base.HandleError(filterContext);
 
      }
 
    }
 
  }
 
  public void OnActionExecuted(ActionExecutedContext filterContext)
 
  {
 
  }
 
}

D'autres vérifications peuvent être mises en œuvre de la même manière.

De cette façon, notre écriture ci-dessus devient :

Pesez le choix à utiliser, ici nous pouvons développer des informations plus utiles, telles que les descriptions d'erreurs, etc.

Résumé

[ValidateNull("userName,password")]
 
public ActionResult Register(string userName, string password)

Bien entendu, chaque méthode a ses inconvénients. Ce choix dépend de la situation spécifique. Généralement, s’il y a trop de paramètres, il est recommandé de les envelopper dans un objet.

Pour plus d'articles connexes sur plusieurs méthodes de vérification des paramètres d'arrière-plan ASP.NET MVC, veuillez faire attention au site Web PHP chinois !