Verifica che una stringa contenga solo lettere in C #

Ho una stringa di input e voglio verificare che contenga:

• Solo lettere o
• Solo lettere e numeri o
• Solo lettere, numeri o trattini bassi

Per chiarire, ho 3 casi diversi nel codice, ognuno richiede una convalida diversa. Qual è il modo più semplice per raggiungere questo obiettivo in C #?

Solo lettere:

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

Solo lettere e numeri:

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

Solo lettere, numeri e trattini bassi:

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=='_');

Solo lettere:

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

Lettere e numeri:

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

Lettere, numeri e trattini bassi:

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

Nota, questi schemi corrispondono anche a caratteri internazionali (invece di usare il a-zcostrutto).

Per quelli di voi che preferiscono non andare con Regex e sono su .NET 2.0 Framework (AKA no LINQ):

Solo lettere:

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

Solo numeri:

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

Solo numeri o lettere:

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

Solo numeri o lettere o caratteri di sottolineatura:

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

Penso che sia un buon caso usare le espressioni regolari:

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_]+$");
}

È possibile eseguire il ciclo sui caratteri di stringa e verificare utilizzando il metodo Char IsLetter, ma è anche possibile eseguire un trucco utilizzando il metodo String IndexOfAny per cercare altri caratteri che non si suppone si trovino nella stringa.

Scorrere i caratteri delle stringhe e utilizzare le funzioni di "Char" chiamate "IsLetter" e "IsDigit".

Se hai bisogno di qualcosa di più specifico, usa la classe Regex.

Se sei un principiante, puoi prendere riferimento al mio codice .. quello che ho fatto è stato mettere un assegno in modo da poter ottenere solo gli alfabeti e gli spazi bianchi! È possibile ripetere il ciclo for dopo la seconda istruzione if per convalidare nuovamente la stringa

       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();
       }

Di recente, ho apportato miglioramenti delle prestazioni per una funzione che controlla le lettere in una stringa con l'aiuto di questa pagina.

Ho capito che le soluzioni con regex sono 30 volte più lente di quelle con il controllo Char.IsLetterOrDigit.

Non eravamo sicuri che quelle lettere o cifre includessero e avessimo bisogno solo di caratteri latini, quindi implementammo la nostra funzione in base alla versione decompilata della funzione Char.IsLetterOrDigit.

Ecco la nostra soluzione:

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;
        }
    }

E l'uso è così:

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

Si prega di trovare il metodo per convalidare se carattere è lettera, numero o spazio, altrimenti allegare il trattino basso (Essere liberi di modificare in base alle proprie esigenze)

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;
}