¿Cómo puedo validar una cadena para permitir solo caracteres alfanuméricos en ella?

¿Cómo puedo validar una cadena usando expresiones regulares para permitir solo caracteres alfanuméricos en ella?

(Tampoco quiero permitir espacios).

Utilice la siguiente expresión:

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

es decir:

using System.Text.RegularExpressions;

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

En .NET 4.0 puede usar LINQ:

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

yourText.Alldejará de ejecutarse y devolverá falselos char.IsLetterOrDigitinformes por primera vez falseya que el contrato de Allno se puede cumplir en ese momento.

¡Nota! esta respuesta no comprueba estrictamente los caracteres alfanuméricos (que normalmente son AZ, az y 0-9). Esta respuesta permite personajes locales como åäö.

Actualización 2018-01-29

La sintaxis anterior solo funciona cuando usa un solo método que tiene un solo argumento del tipo correcto (en este caso char).

Para usar múltiples condiciones, debe escribir así:

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

Puede hacerlo fácilmente con una función de extensión en lugar de una expresión regular ...

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 comentario :) ...

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

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

Si bien creo que la solución basada en expresiones regulares es probablemente la forma en que iría, estaría tentado a encapsular esto en un 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;
    }
}

Ahora, cuando necesite una cadena validada, puede hacer que la firma del método requiera una AlphaNumericString, y saber que si obtiene una, es válida (aparte de los nulos). Si alguien intenta pasar una cadena no validada, generará un error del compilador.

Puede ser más elegante e implementar todos los operadores de igualdad, o una conversión explícita a AlphaNumericString desde una cadena simple, si le importa.

Necesitaba buscar AZ, az, 0-9; sin una expresión regular (aunque el OP solicita una expresión regular).

Combinando varias respuestas y comentarios aquí, y la discusión de https://stackoverflow.com/a/9975693/292060 , esto prueba la letra o el dígito, evitando letras de otros idiomas y evitando otros números como caracteres de fracción.

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

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

Utilizar ^[a-zA-Z0-9]+$ para no permitir el subrayado.

Tenga en cuenta que ambos requieren que la cadena no esté vacía. Usar en *lugar de +permite cadenas vacías.

Para verificar si la cadena es una combinación de letras y dígitos, puede reescribir la respuesta de @jgauffin de la siguiente manera usando .NET 4.0 y LINQ:

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

Misma respuesta que aquí .

Si desea una A-z 0-9verificación ASCII que no sea de expresiones regulares , no puede usarla, char.IsLetterOrDigit()ya que incluye otros caracteres Unicode.

Lo que puede hacer es verificar los rangos de códigos de caracteres.

• 48 -> 57 son números
• 65 -> 90 son letras mayúsculas
• 97 -> 122 son letras minúsculas

Lo siguiente es un poco más detallado, pero es para facilitar la comprensión más que para el código de golf.

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

Según la respuesta de cletus, puede crear una nueva extensión.

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

Aconsejo no depender del código prefabricado e integrado en .NET framework, intente traer una nueva solución ... esto es lo que hago ...

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