Überprüfen, ob eine Zeichenfolge nur Buchstaben in C # enthält

Ich habe eine Eingabezeichenfolge und möchte überprüfen, ob sie Folgendes enthält:

• Nur Briefe oder
• Nur Buchstaben und Zahlen oder
• Nur Buchstaben, Zahlen oder Unterstriche

Zur Verdeutlichung habe ich 3 verschiedene Fälle im Code, die jeweils eine andere Validierung erfordern. Was ist der einfachste Weg, um dies in C # zu erreichen?

Nur Buchstaben:

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

Nur Buchstaben und Zahlen:

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

Nur Buchstaben, Zahlen und Unterstriche:

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

Nur Buchstaben:

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

Buchstaben und Zahlen:

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

Buchstaben, Zahlen und Unterstriche:

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

Beachten Sie, dass diese Muster auch mit internationalen Zeichen übereinstimmen (im Gegensatz zur Verwendung des a-zKonstrukts).

Für diejenigen unter Ihnen, die lieber nicht mit Regex arbeiten möchten und sich im .NET 2.0 Framework (AKA no LINQ) befinden:

Nur Buchstaben:

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

Nur Zahlen:

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

Nur Zahlen oder Buchstaben:

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

Nur Zahlen oder Buchstaben oder Unterstriche:

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

Ich denke, es ist ein guter Fall, reguläre Ausdrücke zu verwenden:

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

Sie können die Zeichen der Zeichenfolge durchlaufen und mit der Char-Methode IsLetter überprüfen, aber Sie können auch einen Trick mit der Zeichenfolgenmethode IndexOfAny ausführen , um andere Zeichen zu suchen, von denen nicht angenommen wird, dass sie in der Zeichenfolge enthalten sind.

Durchlaufen Sie Zeichenfolgen und verwenden Sie die Funktionen von 'Char' namens 'IsLetter' und 'IsDigit'.

Wenn Sie etwas Spezifischeres benötigen, verwenden Sie die Regex-Klasse.

Wenn Sie ein Neuling sind, können Sie sich auf meinen Code beziehen. Ich habe einen Scheck ausgestellt, damit ich nur die Alphabete und Leerzeichen erhalten kann! Sie können die for-Schleife nach der zweiten if-Anweisung wiederholen, um die Zeichenfolge erneut zu validieren

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

Kürzlich habe ich Leistungsverbesserungen für eine Funktion vorgenommen, die mithilfe dieser Seite Buchstaben in einer Zeichenfolge überprüft.

Ich habe herausgefunden, dass die Lösungen mit Regex 30-mal langsamer sind als die mit dem Char.IsLetterOrDigit-Check.

Wir waren uns nicht sicher, ob diese Buchstaben oder Ziffern enthalten sind, und wir brauchten nur lateinische Zeichen. Deshalb haben wir unsere Funktion basierend auf der dekompilierten Version der Char.IsLetterOrDigit-Funktion implementiert.

Hier ist unsere Lösung:

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

Und die Verwendung ist wie folgt:

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

Bitte finden Sie die Methode, um zu überprüfen, ob es sich bei char um einen Buchstaben, eine Zahl oder ein Leerzeichen handelt. Andernfalls fügen Sie einen Unterstrich hinzu.

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