uma - string[] c#




Verificando se uma string contém apenas letras em c# (6)

Eu tenho uma string de entrada e quero verificar se ela contém:

  • Apenas letras ou
  • Apenas letras e números ou
  • Apenas letras, números ou sublinhados

Para esclarecer, eu tenho 3 casos diferentes no código, cada um pedindo validação diferente. Qual é a maneira mais simples de conseguir isso em c #?


Apenas cartas:

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

Apenas letras e números:

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

Apenas letras, números e sublinhados:

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

Eu acho que é um bom caso para usar expressões 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_]+$");
}

Para aqueles que preferem não usar o Regex e estão no .NET 2.0 Framework (AKA no LINQ):

Apenas cartas:

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

Apenas números:

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

Apenas números ou letras:

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

Apenas números ou letras ou sublinhados:

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

Recentemente, fiz melhorias de desempenho para uma função que verifica letras em uma string com a ajuda desta página.

Eu descobri que as soluções com regex são 30 vezes mais lentas do que aquelas com a verificação Char.IsLetterOrDigit.

Não tínhamos certeza de que aquelas Cartas ou Dígitos incluíssem e precisávamos apenas de caracteres latinos, então implementamos nossa função com base na versão decompilada da função Char.IsLetterOrDigit.

Aqui está a nossa solução:

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 o uso é assim:

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

Somente letras:

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

Letras e números:

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

Letras, números e sublinhados:

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

Observe que esses padrões também correspondem a caracteres internacionais (em vez de usar a construção az ).


Você pode fazer um loop nos caracteres de string e checar usando o Char Method IsLetter mas você também pode fazer um truque usando o método String IndexOfAny para procurar outros charaters que não devem estar na string.





string