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

Tengo una cadena que uso para la validación del lado del cliente:

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

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

Sé que la bandera /i para una expresión regular de Javascript se usa para hacer que no distinga entre mayúsculas y minúsculas, pero simplemente virar al final de mi expresión regular (es decir, @"^....$/i" no funciona – la expresión regular la validación falla completamente, independientemente de lo que se ingrese (válido o no).

¿Qué me estoy perdiendo?

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

Creé este atributo que te 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)] 

DO#

 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 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 hacer que esto funcione: ASP.NET MVC 3 Validación de JavaScript no intrusiva con validadores personalizados

En C # puedes alinear algunas opciones de expresiones regulares. Para especificar la opción para ignorar el caso, agregaría (?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 RegularExpressionValidator de ASP.NET lo dudo; la expresión regular debería ser suficientemente vail para funcionar para ambos motores.

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

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