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

J'ai écrit une expression Régulière qui doit valider une chaîne de caractères en utilisant les règles suivantes:

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

Ainsi, la chaîne devrait ressembler à ceci si sa validité:

CCCCNNNNNN ou CCCCNNNNNNN

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

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

Ma regex match de code 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 peut prendre un coup d'oeil à mon expression et d'offrir des commentaires sur les améliorations à produire une correspondance valide.

Aussi, suis-je utiliser .Match() correctement? Si Match.Success est true, alors cela veut dire que la chaîne est-elle valable?

OriginalL'auteur nocarrier | 2012-01-06

  1. 32

    La regex pour 4 caractères alphanumériques suit par 6 à 7 décimales sont:

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

    Voir: Expression Régulière De La Langue De Référence Rapide

    La Regex.Méthode Match renvoie une Match objet. Le Le Succès De La Propriété indique si le match est réussie ou non.

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

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

    OriginalL'auteur dtb

  2. 5

    Le code suivant illustre la regex utilisation:

            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.

    OriginalL'auteur Smi

  3. 3

    Vos conditions:

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

    Les mettre ensemble et d'ancrage:

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

    Bien que cela dépend un peu comment vous définissez "alphanumérique". Aussi, si vous êtes en utilisant ignorer la casse drapeau ensuite, vous pouvez supprimer le A-Z gamme à partir de l'expression.

    OriginalL'auteur Qtax

  4. 2

    Le code suivant est à l'aide d'une expression régulière et des contrôles de 4 motifs différents pour le tester, voir 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");
        }
    }
}

    De sortie:

    aaaa999999 correspond

    aaaa9999999 correspond

    aaaa99999999 ne correspond pas

    aaa999999 ne correspond pas

    Essayer comme DotNetFiddle

    OriginalL'auteur kirti kant pareek

  5. 1

    Essayer le modèle suivant:

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

    OriginalL'auteur Bernard