RegularExpressionAttribute - ¿Cómo hacer que no distinga entre mayúsculas y minúsculas para la validación del lado del cliente?

Question

que tienen una cadena que utilizo para la validación del lado del cliente:

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

utilizo esta cadena en mi atributo [RegularExpression(regex, ErrorMessage = "invalid")].

sé que la bandera /i para una expresión regular Javascript se utiliza para que sea sensible a mayúsculas, pero sólo viradas que hasta el final de mi expresión regular (es decir @"^....$/i" no está funcionando - la validación de expresiones regulares falla por completo, independientemente de lo se introduce (válido o no).

¿Qué me falta?

Answer 1

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

Answer 2

En C# se puede inline algunas opciones de expresiones regulares. para especificar la opción de ignorar caso deberá añadir (?i) al comienzo de su patrón Sin embargo, no estoy seguro de cómo esto sería tratado por el RegularExpressionAttribute y si maneja la traducción para el lado del cliente. De mi experiencia con ASP.NET RegularExpressionValidator lo dudo; la expresión regular debería ser vainilla suficiente para funcionar en ambos motores.

En cualquier caso, si era válido que se vería así:

@"^(?i)(?:\b(?:\d{5}(?:\s*-\s*\d{5})?|([A-Z]{2})\d{3}(?:\s*-\s*\1\d{3})?)(?:,\s*)?)+$" 

Answer 3

creé este atributo que le permite especificar RegexOptions. EDITAR: También se integra con una validación discreta. El cliente solo obedecerá RegexOptions.Multiline y RegexOptions.IgnoreCase, ya que es lo que admite JavaScript.

[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); 

Este artículo de Anthony Stevens me ayudó a conseguir este trabajo: ASP.NET MVC 3 Unobtrusive Javascript Validation With Custom Validators