Vérifier qu'une chaîne ne contient que des lettres en C #

J'ai une chaîne d'entrée et je veux vérifier qu'elle contient:

• Seulement des lettres ou
• Seulement des lettres et des chiffres ou
• Seulement des lettres, des chiffres ou des traits de soulignement

Pour clarifier, j'ai 3 cas différents dans le code, chacun appelant une validation différente. Quel est le moyen le plus simple d'y parvenir en C #?

Seulement des lettres:

Regex.IsMatch(input, @"^[a-zA-Z]+$");

Seulement des lettres et des chiffres:

Regex.IsMatch(input, @"^[a-zA-Z0-9]+$");

Seuls les lettres, les chiffres et le trait de soulignement:

Regex.IsMatch(input, @"^[a-zA-Z0-9_]+$");

bool result = input.All(Char.IsLetter);

bool result = input.All(Char.IsLetterOrDigit);

bool result = input.All(c=>Char.IsLetterOrDigit(c) || c=='_');

Lettres seulement:

Regex.IsMatch(theString, @"^[\p{L}]+$");

Lettres et chiffres:

Regex.IsMatch(theString, @"^[\p{L}\p{N}]+$");

Lettres, chiffres et trait de soulignement:

Regex.IsMatch(theString, @"^[\w]+$");

Notez que ces modèles correspondent également aux caractères internationaux (par opposition à l'utilisation de la a-zconstruction).

Pour ceux d'entre vous qui préfèrent ne pas utiliser Regex et sont sur le Framework .NET 2.0 (AKA no LINQ):

Seulement des lettres:

public static bool IsAllLetters(string s)
{
    foreach (char c in s)
    {
        if (!Char.IsLetter(c))
            return false;
    }
    return true;
}

Seulement les chiffres:

    public static bool IsAllDigits(string s)
    {
        foreach (char c in s)
        {
            if (!Char.IsDigit(c))
                return false;
        }
        return true;
    }

Seulement des chiffres ou des lettres:

    public static bool IsAllLettersOrDigits(string s)
    {
        foreach (char c in s)
        {
            if (!Char.IsLetterOrDigit(c))
                return false;
        }
        return true;
    }

Seulement des chiffres ou des lettres ou des traits de soulignement:

    public static bool IsAllLettersOrDigitsOrUnderscores(string s)
    {
        foreach (char c in s)
        {
            if (!Char.IsLetterOrDigit(c) && c != '_')
                return false;
        }
        return true;
    }

Je pense que c'est un bon cas pour utiliser les expressions régulières:

public bool IsAlpha(string input)
{
    return Regex.IsMatch(input, "^[a-zA-Z]+$");
}

public bool IsAlphaNumeric(string input)
{
    return Regex.IsMatch(input, "^[a-zA-Z0-9]+$");
}

public bool IsAlphaNumericWithUnderscore(string input)
{
    return Regex.IsMatch(input, "^[a-zA-Z0-9_]+$");
}

Vous pouvez effectuer une boucle sur les caractères de string et vérifier à l'aide de la méthode Char IsLetter, mais vous pouvez également faire une astuce en utilisant la méthode String IndexOfAny pour rechercher d'autres caractères qui ne sont pas supposés être dans la chaîne.

Itérez les chaînes de caractères et utilisez les fonctions de «Char» appelées «IsLetter» et «IsDigit».

Si vous avez besoin de quelque chose de plus spécifique, utilisez la classe Regex.

Si vous êtes un débutant, vous pouvez prendre la référence de mon code .. ce que j'ai fait était de mettre un chèque afin que je ne puisse obtenir que les alphabets et les espaces blancs! Vous pouvez répéter la boucle for après la seconde instruction if pour valider à nouveau la chaîne

       bool check = false;

       Console.WriteLine("Please Enter the Name");
       name=Console.ReadLine();

       for (int i = 0; i < name.Length; i++)
       {
           if (name[i]>='a' && name[i]<='z' || name[i]==' ')
           {
               check = true;
           }
           else
           {
               check = false;
               break;
           }

       }

       if (check==false)
       {
           Console.WriteLine("Enter Valid Value");
           name = Console.ReadLine();
       }

Récemment, j'ai amélioré les performances d'une fonction qui vérifie les lettres dans une chaîne à l'aide de cette page.

J'ai compris que les solutions avec regex sont 30 fois plus lentes que celles avec la vérification Char.IsLetterOrDigit.

Nous n'étions pas sûrs que ces lettres ou chiffres incluent et nous n'avions besoin que de caractères latins, nous avons donc implémenté notre fonction basée sur la version décompilée de la fonction Char.IsLetterOrDigit.

Voici notre solution:

internal static bool CheckAllowedChars(char uc)
    {
        switch (uc)
        {
            case '-':
            case '.':
            case 'A':
            case 'B':
            case 'C':
            case 'D':
            case 'E':
            case 'F':
            case 'G':
            case 'H':
            case 'I':
            case 'J':
            case 'K':
            case 'L':
            case 'M':
            case 'N':
            case 'O':
            case 'P':
            case 'Q':
            case 'R':
            case 'S':
            case 'T':
            case 'U':
            case 'V':
            case 'W':
            case 'X':
            case 'Y':
            case 'Z':
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                return true;
            default:
                return false;
        }
    }

Et l'utilisation est comme ceci:

 if( logicalId.All(c => CheckAllowedChars(c)))
 { // Do your stuff here.. }

Veuillez trouver la méthode pour valider si char est une lettre, un chiffre ou un espace, sinon attachez un trait de soulignement (soyez libre de modifier selon vos besoins)

public String CleanStringToLettersNumbers(String data)
{
    var result = String.Empty;

    foreach (var item in data)
    {
        var c = '_';

        if ((int)item >= 97 && (int)item <= 122 ||
            (int)item >= 65 && (int)item <= 90 ||
            (int)item >= 48 && (int)item <= 57 ||
            (int)item == 32)
        {
            c = item;
        }

        result = result + c;
    }

    return result;
}