RegularExpressionAttribute - Comment font-il pas sensible à la casse pour la validation côté client?

J'ai une chaîne de caractères que j'utilise pour la validation côté client:

private const String regex = @"^(?:\b(?:\d{5}(?:\s*-\s*\d{5})?|([A-Z]{2})\d{3}(?:\s*-\s*\d{3})?)(?:,\s*)?)+$";

Je utiliser cette corde à mon [RegularExpression(regex, ErrorMessage = "invalid")] attribut.

Je sais que le /i drapeau pour une regex en Javascript est utilisé pour faire de la casse, mais juste en la clouant à la fin de ma regex (c'est à dire @"^....$/i" n'est pas la regex validation échoue complètement, indépendamment de ce qui est entré (valide ou non).

Ce qui me manque?

  • Le problème, c'est que .NET et JS est l'utilisation de différentes saveurs de Regex, donc si nous voulons le même schéma de travail universellement sur le client et le serveur, nous avons à utiliser un sous-ensemble de la syntaxe d'expression régulière qui est sûr en JS et C#. Alternativement, des approches comme Jeremy la solution ci-dessous nous permet d'richement composer et de contrôle des modificateurs dans les deux langues par la ramification de la logique de validation sur le serveur et le client
InformationsquelleAutor Scott Baker | 2010-11-18
  1. 7
    private const String regex = @"^(?:\b(?:\d{5}(?:\s*-\s*\d{5})?|([a-zA-Z]{2})\d{3}(?:\s*-\s*\d{3})?)(?:,\s*)?)+$";
    • ah! bien sûr! excellente réponse - cependant, je dois vous demander: est-il possible d'utiliser la casse drapeau?
    • Regex re = new Regex(@"^(?:\b(?:\d{5}(?:\s*-\s*\d{5})?|([a-zA-Z]{2})\d{3}(?:\s*-\s*\1\d{3})?)(?:,\s*)?)+$", RegexOptions.IgnoreCase); // C'est le code c#.
    • la question est liée à RegularExpressionAttribute et là, vous devez passer chaîne de caractères. Si vous ne pouvez pas utiliser les Regex classe avec des attributs
    InformationsquelleAutor Eric.K.Yung
  2. 35

    J'ai créé cet attribut qui permet de spécifier RegexOptions. EDIT: Il s'intègre également avec la discrète de validation. Le client ne peut obéir à RegexOptions.Multiline et RegexOptions.IgnoreCase étant donné que c'est du JavaScript qui prend en charge.

    [RegularExpressionWithOptions(@".+@example\.com", RegexOptions = RegexOptions.IgnoreCase)]

    C#

    public class RegularExpressionWithOptionsAttribute : RegularExpressionAttribute, IClientValidatable
{
    public RegularExpressionWithOptionsAttribute(string pattern) : base(pattern) { }

    public RegexOptions RegexOptions { get; set; }

    public override bool IsValid(object value)
    {
        if (string.IsNullOrEmpty(value as string))
            return true;

        return Regex.IsMatch(value as string, "^" + Pattern + "$", RegexOptions);
    }

    public IEnumerable<System.Web.Mvc.ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        var rule = new ModelClientValidationRule
        {
            ErrorMessage = FormatErrorMessage(metadata.DisplayName),
            ValidationType = "regexwithoptions"
        };

        rule.ValidationParameters["pattern"] = Pattern;

        string flags = "";
        if ((RegexOptions & RegexOptions.Multiline) == RegexOptions.Multiline)
            flags += "m";
        if ((RegexOptions & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
            flags += "i";
        rule.ValidationParameters["flags"] = flags;

        yield return rule;
    }
}

    JavaScript

    (function ($) {

    $.validator.unobtrusive.adapters.add("regexwithoptions", ["pattern", "flags"], function (options) {
        options.messages['regexwithoptions'] = options.message;
        options.rules['regexwithoptions'] = options.params;
    });

    $.validator.addMethod("regexwithoptions", function (value, element, params) {
        var match;
        if (this.optional(element)) {
            return true;
        }

        var reg = new RegExp(params.pattern, params.flags);
        match = reg.exec(value);
        return (match && (match.index === 0) && (match[0].length === value.length));
    });

})(jQuery);

    Cet article par Anthony Stevens m'a aidé à obtenir ce travail: ASP.NET MVC 3 Javascript Discret de Validation Avec les Validateurs Personnalisés

    • Je n'ai pas testé ta solution mais je sais que l'approche générale des travaux qu'il a résolu un problème similaire ici: stackoverflow.com/questions/5937174/...
    • Génial solution! J'ai essayé de nettoyer et de tirer parti de la sortie de la boîte regex validateur en enveloppant le mode de sortie de la /pattern/flag la syntaxe littérale, mais la valeur est passée en `new RegExp(params)` constructeur de syntaxe qui n'est pas analyser les attributs, donc, l'approche est la bonne pour écrire le côté client drapeau de la manipulation de nous-mêmes ainsi
    InformationsquelleAutor Jeremy Cook
  3. 16

    En C#, vous pouvez inline quelques regex options. Pour spécifier l'option pour ignorer le cas où vous souhaitez ajouter (?i) au début de votre modèle. Cependant, je ne suis pas sûr de savoir comment ce serait traitée par le RegularExpressionAttribute et si elle s'occupe de la traduction pour le côté client. De mon expérience avec ASP.NET's RegularExpressionValidator j'en doute; l'expression régulière doit être vanille assez de travail pour les deux moteurs.

    En tout cas, s'il était valide, il devrait ressembler à ceci:

    @"^(?i)(?:\b(?:\d{5}(?:\s*-\s*\d{5})?|([A-Z]{2})\d{3}(?:\s*-\s*\d{3})?)(?:,\s*)?)+$"
    • Il travaille pour ASP.NET MVC 2 au moins. Mais côté serveur uniquement.
    InformationsquelleAutor Ahmad Mageed