Verificación de que una cadena contiene solo letras en C #

Tengo una cadena de entrada y quiero verificar que contenga:

• Solo letras o
• Solo letras y números o
• Solo letras, números o guiones bajos

Para aclarar, tengo 3 casos diferentes en el código, cada uno solicita una validación diferente. ¿Cuál es la forma más sencilla de lograr esto en C #?

Solo cartas:

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

Solo letras y números:

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

Solo letras, números y guiones bajos:

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 letras:

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

Letras y numeros:

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

Letras, números y guiones bajos:

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

Tenga en cuenta que estos patrones también coinciden con caracteres internacionales (en oposición al uso de la a-zconstrucción).

Para aquellos de ustedes que prefieren no ir con Regex y están en .NET 2.0 Framework (AKA no LINQ):

Solo cartas:

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

Sólo números:

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

Solo números o letras:

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

Solo números, letras o guiones bajos:

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

Creo que es un buen caso para usar expresiones regulares:

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

Puede hacer un bucle en los caracteres de la cadena y verificar con el Método de Char IsLetter, pero también puede hacer un truco con el método de Cadena IndexOfAny para buscar otros caracteres que no se supone que estén en la cadena.

Iterar a través de caracteres de cadenas y usar funciones de 'Char' llamadas 'IsLetter' e 'IsDigit'.

Si necesita algo más específico, use la clase Regex.

Si eres un novato, entonces puedes tomar la referencia de mi código ... ¡lo que hice fue poner un cheque para que solo pudiera obtener los alfabetos y los espacios en blanco! Puede repetir el ciclo for después de la segunda instrucción if para validar la cadena nuevamente

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

Recientemente, realicé mejoras de rendimiento para una función que verifica letras en una cadena con la ayuda de esta página.

Descubrí que las soluciones con expresiones regulares son 30 veces más lentas que las que tienen la verificación Char.IsLetterOrDigit.

No estábamos seguros de que esas letras o dígitos incluyeran y necesitábamos solo caracteres latinos, por lo que implementamos nuestra función basada en la versión descompilada de la función Char.IsLetterOrDigit.

Aquí está nuestra solución:

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

Y el uso es así:

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

Encuentre el método para validar si el carácter es letra, número o espacio, de lo contrario adjunte guión bajo (Sea libre de modificar según sus necesidades)

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