web-dev-qa-db-fra.com

Règle de validation Regex C # à l'aide de Regex.Match ()

J'ai écrit une expression régulière qui devrait valider une chaîne en utilisant les règles suivantes:

  1. Les quatre premiers caractères doivent être alphanumériques.
  2. Les caractères alpha sont suivis de 6 ou 7 valeurs numériques pour une longueur totale de 10 ou 11.

La chaîne devrait donc ressembler à ceci si elle est valide:

CCCCNNNNNN ou CCCCNNNNNNN

C étant n'importe quel caractère et N étant un nombre.

Mon expression est écrite: @"^[0-9A-Za-z]{3}[0-9A-Za-z-]\d{0,21}$";

Mon code de correspondance regex ressemble à ceci:

var cc1 = "FOOBAR"; // should fail.
var cc2 = "AAAA1111111111"; // should succeed

var regex = @"^[0-9A-Za-z]{3}[0-9A-Za-z-]\d{0,21}$";

Match match = Regex.Match( cc1, regex, RegexOptions.IgnoreCase );

if ( cc1 != string.Empty && match.Success )
{
     //"The Number must start with 4 letters and contain no numbers.",
     Error = SeverityType.Error
}

J'espère que quelqu'un pourra jeter un coup d'œil à mon expression et offrir des commentaires sur les améliorations pour produire une correspondance valide.

De plus, est-ce que j'utilise .Match() correctement? Si Match.Success Est true, cela signifie-t-il que la chaîne est valide?

c#regexvalidation
27
nocarrier

L'expression régulière pour 4 caractères alphanumériques suit de 6 à 7 chiffres décimaux:

var regex = @"^\w{4}\d{6,7}$";

Voir: Regular Expression Language - Quick Reference

La méthode Regex.Match renvoie un objet Match . Propriété de réussite indique si la correspondance est réussie ou non.

var match = Regex.Match(input, regex, RegexOptions.IgnoreCase);

if (!match.Success)
{
    // does not match
}
50
dtb

Le code suivant illustre l'utilisation de l'expression régulière:

        var cc1 = "FOOBAR"; // should fail.
        var cc2 = "AAAA1111111"; // should succeed
        var r = new Regex(@"^[0-9a-zA-Z]{4}\d{6,7}$");
        if (!r.IsMatch(cc2))
        {
            Console.WriteLine("cc2 doesn't match");
        }
        if (!r.IsMatch(cc1))
        {
            Console.WriteLine("cc1 doesn't match");
        }

La sortie sera cc1 doesn't match.

5
Smi

Le code suivant utilise une expression régulière et vérifie 4 modèles différents pour le tester, voir la sortie ci-dessous:

using System;
using System.Text.RegularExpressions;   
public class Program
{
    public static void Main()
    {
        var p1 = "aaaa999999"; 
        CheckMatch(p1);
        p1 = "aaaa9999999";
        CheckMatch(p1);
        p1 = "aaaa99999999";
        CheckMatch(p1);
        p1 = "aaa999999";
        CheckMatch(p1);
    }

    public static void CheckMatch(string p1)
    {
        var reg = new Regex(@"^\w{4}\d{6,7}$");
        if (!reg.IsMatch(p1))
        {
            Console.WriteLine($"{p1} doesn't match");
        }
        else
        {
            Console.WriteLine($"{p1} matches");
        }
    }
}

Sortie:

matchs de aaaa999999
correspond à aaaa9999999
aaaa99999999 ne correspond pas
aaa999999 ne correspond pas

Essayez-le comme DotNetFiddle

4
kirti kant pareek

Vos conditions donnent:

  1. Les quatre premiers caractères doivent être alphanumériques: [A-Za-z\d]{4}
  2. suivi de 6 ou 7 valeurs numériques: \d{6,7}

Assemblez-le et ancrez-le:

^[A-Za-z\d]{4}\d{6,7}\z

Mais cela dépend un peu de la façon dont vous définissez "alphanumérique". De plus, si vous utilisez l'option Ignorer la casse, vous pouvez supprimer le A-Z va de l'expression.

3
Qtax

Essayez le modèle suivant:

@"^[A-za-z\d]{4}\d{6,7}$"
1
Bernard