Comment puis-je valider une chaîne pour n'autoriser que les caractères alphanumériques?

Comment puis-je valider une chaîne à l'aide d'expressions régulières pour n'autoriser que les caractères alphanumériques?

(Je ne veux pas non plus autoriser d'espaces).

Utilisez l'expression suivante:

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

c'est à dire:

using System.Text.RegularExpressions;

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

Dans .NET 4.0, vous pouvez utiliser LINQ:

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

yourText.Allarrêtera d'exécuter et retournera falseles premiers char.IsLetterOrDigitrapports de temps falsepuisque le contrat de Allne peut pas être exécuté alors.

Remarque! cette réponse ne vérifie pas strictement les alphanumériques (qui sont généralement AZ, az et 0-9). Cette réponse autorise les caractères locaux comme åäö.

Mise à jour 2018-01-29

La syntaxe ci-dessus ne fonctionne que lorsque vous utilisez une seule méthode qui a un seul argument du type correct (dans ce cas char).

Pour utiliser plusieurs conditions, vous devez écrire comme ceci:

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

Vous pouvez le faire facilement avec une fonction d'extension plutôt qu'une 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;
}

Par commentaire :) ...

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

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

Bien que je pense que la solution basée sur les regex est probablement la voie à suivre, je serais tenté de l'encapsuler dans un type.

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

Désormais, lorsque vous avez besoin d'une chaîne validée, vous pouvez faire en sorte que la signature de la méthode nécessite une AlphaNumericString, et sachez que si vous en obtenez une, elle est valide (à l'exception des valeurs nulles). Si quelqu'un tente de passer une chaîne non validée, cela générera une erreur du compilateur.

Vous pouvez devenir plus sophistiqué et implémenter tous les opérateurs d'égalité, ou un cast explicite en AlphaNumericString à partir d'une chaîne de caractères classique, si vous vous en souciez.

J'avais besoin de vérifier AZ, az, 0-9; sans regex (même si l'OP demande une regex).

Mélange de diverses réponses et commentaires ici, et discussion de https://stackoverflow.com/a/9975693/292060 , cela teste la lettre ou le chiffre, évite les lettres d'autres langues et évite d'autres nombres tels que les fractions.

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

^\w+$ permettra a-zA-Z0-9_

Utilisez ^[a-zA-Z0-9]+$pour interdire le trait de soulignement.

Notez que les deux nécessitent que la chaîne ne soit pas vide. Utiliser *au lieu de +autorise les chaînes vides.

Afin de vérifier si la chaîne est à la fois une combinaison de lettres et de chiffres, vous pouvez réécrire la réponse @jgauffin comme suit en utilisant .NET 4.0 et LINQ:

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

Même réponse qu'ici .

Si vous voulez une A-z 0-9vérification ASCII non-regex , vous ne pouvez pas utiliser char.IsLetterOrDigit()car cela inclut d'autres caractères Unicode.

Ce que vous pouvez faire est de vérifier les plages de codes de caractères.

• 48 -> 57 sont des nombres
• 65 -> 90 sont des lettres majuscules
• 97 -> 122 sont des lettres minuscules

Ce qui suit est un peu plus détaillé, mais c'est pour faciliter la compréhension plutôt que pour le code 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;
    }

Sur la base de la réponse de cletus, vous pouvez créer une nouvelle extension.

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

Je conseille de ne pas dépendre du code prêt à l'emploi et intégré dans le framework .NET, essayez de proposer une nouvelle solution ... c'est ce que je fais.

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