regex .NET specifico per .net C# dataannotations

Question

Ho un'espressione regolare che sto cercando di capire per un modello di convalida di annotazione dati .NET che sto utilizzando. Attualmente sembra che questo

[RegularExpression("^((?!City)[a-zA-Z '])+$", ErrorMessage = "City is required and must be properly formatted.")] 

La prima metà di questa regex è quello di tenere conto di Città, la seconda metà è quello di assicurarsi che i suoi solo lettere e spazi.

Il valore predefinito per la casella di testo di input è Città, quindi solo "Città" non può superare la convalida. Non riesco a ottenere la prima sezione di questa regex per far passare questi casi.

Cityville 
City City 
Jersey City 
Arizona City 

Ma questo caso non passa:

City 

Qualsiasi aiuto sarebbe molto apprezzato.

* EDIT * Questo ha fatto il trucco:

^(?! (^ Città $) [a-zA-Z ']) + $

ho aggiornato tutti la mia convalida per includere questo. Nel caso volessi vedere cosa sto facendo. Qui se il codice per l'intero modello di dati di validazione che sto usando. (aggiornato con la regex corretta)

public class FormModel { 
    [Required(ErrorMessage = "First Name is a Required field.")] 
    [DataType(DataType.Text)] 
    [Display(Order = 1, Name = "FirstName")] 
    [RegularExpression("^((?!^First Name$)[a-zA-Z '])+$", ErrorMessage = "First name is required and must be properly formatted.")] 
    public string FirstName { get; set; } 

    [Required(ErrorMessage = "Last Name is a Required field.")] 
    [DataType(DataType.Text)] 
    [Display(Order = 2, Name = "LastName")] 
    [RegularExpression("^((?!^Last Name$)[a-zA-Z '])+$", ErrorMessage = "Last name is required and must be properly formatted.")] 
    public string LastName { get; set; } 

    [Required(ErrorMessage = "Address is a Required field.")] 
    [DataType(DataType.Text)] 
    [Display(Order = 3, Name = "Address")] 
    [RegularExpression("^((?!^Address$)[0-9A-Za-z #.,])+$", ErrorMessage = "Address is required and must be properly formatted.")] 
    public string Address { get; set; } 

    [DataType(DataType.Text)] 
    [Display(Order = 4, Name = "Address2")] 
    public string Address2 { get; set; } 

    [Required(ErrorMessage = "City is a Required field.")] 
    [DataType(DataType.Text)] 
    [RegularExpression("^((?!^City$)[a-zA-Z '])+$", ErrorMessage = "City is required and must be properly formatted.")] 
    [Display(Order = 6, Name = "City")] 
    public string City { get; set; } 

    [Required(ErrorMessage = "State is a Required field.")] 
[DataType(DataType.Text)] 
[Display(Order = 7, Name = "State")] 
public IEnumerable<String> State { get; set; } 

[Required(ErrorMessage = "Zip is a Required field.")] 
[DataType(DataType.Text)] 
[RegularExpression("\\d{5}", 
     ErrorMessage = "Zip Code is required and must be properly formatted.")] 
[Display(Order = 8, Name = "Zip")] 
public String Zip { get; set; } 

[Required(ErrorMessage = "Phone is a Required field.")] 
[DataType(DataType.PhoneNumber)] 
[RegularExpression("^[01]?[- .]?\\(?[2-9]\\d{2}\\)?[- .]?\\d{3}[- .]?\\d{4}$", 
     ErrorMessage = "Phone is required and must be properly formatted.")] 
[Display(Order = 9, Name = "Phone")] 
public string Phone { get; set; } 

[Required(ErrorMessage = "Email is a Required field.")] 
[DataType(DataType.EmailAddress)] 

[RegularExpression("^[A-Za-z0-9._%+-]*@[A-Za-z0-9.-]*\\.[A-Za-z0-9-]{2,}$", 
     ErrorMessage = "Email is required and must be properly formatted.")] 
[Display(Order = 10, Name = "Email")] 
public string Email { get; set; } 

Answer 1

provare questo fuori per l'espressione regolare - ^((?!^City$)[a-zA-Z '])+$
per fare un controllo negativo per "City", ho aggiunto un inizio (^) & end ($) caratteri alla città. L'ho provato a http://regex101.com/r/bF4bZ3 e sembra funzionare se sto capendo correttamente il requisito.

Answer 2

Questo è in realtà un errore molto piccolo da parte vostra. Cambia il tuo Regex a:

^(?!^City$)[a-zA-Z ']+$ 

E avrai l'effetto desiderato. Fondamentalmente il segno + indica una o più volte, e dato che hai avuto l'espressione WHOLE racchiusa tra parentesi che dovevano verificarsi una o più volte, avrebbe trovato la corrispondenza "Città" in qualsiasi punto della stringa ... Questo invece dice, in Inglese: non "Città" e lettere e spazi o virgolette singole una o più volte.

Un buon strumento per testare Regex è Regex Hero: http://regexhero.net/tester

Answer 3

(?!City) significa City Zero Larghezza lookahead negativo, quindi, ^((?!City)[a-zA-Z '])+$ significa:

• contiene solo lettere spazi e '
• Non contiene City

Ecco come disabilitare City:

//Regular Expression  
//^(?!^\s*City\s*$)[a-zA-Z ']+$ 
//as a .Net string 
string str = "^(?!^\\s*City\\s*$)[a-zA-Z ']+$" 

Demo

Answer 4

corrispondente negativo nelle espressioni regolari è generalmente una cattiva idea, non è solo progettato in quel modo. Il metodo migliore sarebbe quello di verificare:

"^City$" 

E annullare il test. In questo caso non hai davvero un'opzione per farlo.

Sei davvero vicino, è sufficiente spostare le ancore nel lookahead negativo, e dare la stringa una lunghezza min.

(?!^City$)[-a-zA-Z ]{4,} 

Questo corrisponderà tutto ciò che è 4 caratteri o più che non è "City".

Senza la lunghezza min il "ity" in "City" sarà una partita che non vi aiuterà.

È possibile ridurre la lunghezza min a 3 con l'aggiunta di uno sguardo dietro, se volete.

(?!^City$)[-a-zA-Z ]{3,}(?<!^City$) 

Answer 5

Altre risposte ti hanno dato l'aiuto con l'espressione regolare richiesta. Ho intenzione di commentare un aspetto leggermente diverso: il valore predefinito dovrebbe essere qualcosa di significativo o assolutamente nulla ("Città" è un valore predefinito errato).

Ciò che probabilmente si voleva fare è stato messo testo segnaposto, che scompare non appena si entra nella casella di testo. È possibile farlo con l'Prompt proprietà di attributo Display se si sta utilizzando NET 4.5 - vedi this answer per i dettagli.

Non utilizzare un valore predefinito falso significa che è possibile utilizzare solo [Required] e gli utenti dovranno inserire qualcosa, e non è necessario tenere traccia di quali sono i propri valori di default falsi.

Giusto per lanciare un'altra chiave nelle opere, "Città" è un valid place name - ci sono due villaggi chiamati Città in Galles e un'area a Zurigo!