Como posso validar uma string para permitir apenas caracteres alfanuméricos nela?

Como posso validar uma string usando Expressões regulares para permitir apenas caracteres alfanuméricos nela?

(Também não quero permitir espaços).

Use a seguinte expressão:

^[a-zA-Z0-9]*$

ie:

using System.Text.RegularExpressions;

Regex r = new Regex("^[a-zA-Z0-9]*$");
if (r.IsMatch(SomeString)) {
  ...
}

No .NET 4.0, você pode usar LINQ:

if (yourText.All(char.IsLetterOrDigit))
{
    //just letters and digits.
}

yourText.Allinterromperá a execução e retornará falseos char.IsLetterOrDigitrelatórios da primeira vez , falsepois o contrato de Allnão pode ser cumprido nessa ocasião .

Nota! esta resposta não verifica estritamente alfanuméricos (que normalmente é AZ, az e 0-9). Esta resposta permite personagens locais como åäö.

Atualização 29/01/2018

A sintaxe acima só funciona quando você usa um único método que tem um único argumento do tipo correto (neste caso char).

Para usar várias condições, você precisa escrever assim:

if (yourText.All(x => char.IsLetterOrDigit(x) || char.IsWhiteSpace(x)))
{
}

Você poderia fazer isso facilmente com uma função de extensão em vez de um regex ...

public static bool IsAlphaNum(this string str)
{
    if (string.IsNullOrEmpty(str))
        return false;

    for (int i = 0; i < str.Length; i++)
    {
        if (!(char.IsLetter(str[i])) && (!(char.IsNumber(str[i]))))
            return false;
    }

    return true;
}

Por comentário :) ...

public static bool IsAlphaNum(this string str)
{
    if (string.IsNullOrEmpty(str))
        return false;

    return (str.ToCharArray().All(c => Char.IsLetter(c) || Char.IsNumber(c)));
}

Embora eu ache que a solução baseada em regex é provavelmente o caminho que eu escolheria, ficaria tentado a encapsular isso em um tipo.

public class AlphaNumericString
{
    public AlphaNumericString(string s)
    {
        Regex r = new Regex("^[a-zA-Z0-9]*$");
        if (r.IsMatch(s))
        {
            value = s;                
        }
        else
        {
            throw new ArgumentException("Only alphanumeric characters may be used");
        }
    }

    private string value;
    static public implicit operator string(AlphaNumericString s)
    {
        return s.value;
    }
}

Agora, quando você precisa de uma string validada, pode fazer com que a assinatura do método exija uma AlphaNumericString e saiba que, se obtiver uma, ela é válida (exceto nulos). Se alguém tentar passar uma string não validada, um erro do compilador será gerado.

Você pode obter mais elaborado e implementar todos os operadores de igualdade, ou uma conversão explícita para AlphaNumericString de uma string simples, se você se importar.

Eu precisava verificar AZ, az, 0-9; sem uma regex (mesmo que o OP solicite a regex).

Combinando várias respostas e comentários aqui e discussão de https://stackoverflow.com/a/9975693/292060 , isso testa a letra ou o dígito, evitando letras de outros idiomas e evitando outros números, como caracteres fracionários.

if (!String.IsNullOrEmpty(testString)
    && testString.All(c => Char.IsLetterOrDigit(c) && (c < 128)))
{
    // Alphanumeric.
}

^\w+$ permitirá a-zA-Z0-9_

Use ^[a-zA-Z0-9]+$para impedir o sublinhado.

Observe que ambos exigem que a string não esteja vazia. Usar em *vez de +permite strings vazias.

Para verificar se a string é uma combinação de letras e dígitos, você pode reescrever a resposta @jgauffin da seguinte maneira usando .NET 4.0 e LINQ:

if(!string.IsNullOrWhiteSpace(yourText) && 
yourText.Any(char.IsLetter) && yourText.Any(char.IsDigit))
{
   // do something here
}

Mesma resposta que aqui .

Se você quiser uma A-z 0-9verificação ASCII sem regex , não poderá usar, char.IsLetterOrDigit()pois isso inclui outros caracteres Unicode.

O que você pode fazer é verificar os intervalos de código de caracteres.

• 48 -> 57 são numéricos
• 65 -> 90 são letras maiúsculas
• 97 -> 122 são letras minúsculas

O que segue é um pouco mais detalhado, mas é para facilitar o entendimento e não para definir o código.

    public static bool IsAsciiAlphaNumeric(this string str)
    {
        if (string.IsNullOrEmpty(str))
        {
            return false;
        }

        for (int i = 0; i < str.Length; i++)
        {
            if (str[i] < 48) // Numeric are 48 -> 57
            {
                return false;
            }

            if (str[i] > 57 && str[i] < 65) // Capitals are 65 -> 90
            {
                return false;
            }

            if (str[i] > 90 && str[i] < 97) // Lowers are 97 -> 122
            {
                return false;
            }

            if (str[i] > 122)
            {
                return false;
            }
        }

        return true;
    }

Com base na resposta de cletus, você pode criar uma nova extensão.

public static class StringExtensions
{        
    public static bool IsAlphaNumeric(this string str)
    {
        if (string.IsNullOrEmpty(str))
            return false;

        Regex r = new Regex("^[a-zA-Z0-9]*$");
        return r.IsMatch(str);
    }
}

Aconselho não depender de código pronto e embutido no framework .NET, tente trazer uma nova solução .. é isso que eu faço ..

public  bool isAlphaNumeric(string N)
{
    bool YesNumeric = false;
    bool YesAlpha = false;
    bool BothStatus = false;


    for (int i = 0; i < N.Length; i++)
    {
        if (char.IsLetter(N[i]) )
            YesAlpha=true;

        if (char.IsNumber(N[i]))
            YesNumeric = true;
    }

    if (YesAlpha==true && YesNumeric==true)
    {
        BothStatus = true;
    }
    else
    {
        BothStatus = false;
    }
    return BothStatus;
}