Come posso convalidare una stringa per consentire solo caratteri alfanumerici in essa?

Come posso convalidare una stringa utilizzando espressioni regolari per consentire solo caratteri alfanumerici in essa?

(Non voglio nemmeno consentire spazi).

Usa la seguente espressione:

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

vale a dire:

using System.Text.RegularExpressions;

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

In .NET 4.0 puoi usare LINQ:

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

yourText.Allinterromperà l'esecuzione e restituirà falsei char.IsLetterOrDigitrapporti per la prima volta falsepoiché il contratto di Allnon può essere adempiuto in quel momento.

Nota! questa risposta non controlla rigorosamente i caratteri alfanumerici (che tipicamente sono AZ, az e 0-9). Questa risposta consente caratteri locali come åäö.

Aggiornamento 2018-01-29

La sintassi precedente funziona solo quando si utilizza un singolo metodo con un singolo argomento del tipo corretto (in questo caso char ).

Per utilizzare più condizioni, devi scrivere in questo modo:

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

Potresti farlo facilmente con una funzione di estensione piuttosto che una 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;
}

Per commento :) ...

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

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

Anche se penso che la soluzione basata su regex sia probabilmente il modo in cui andrei, sarei tentato di incapsularlo in 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;
    }
}

Ora, quando hai bisogno di una stringa convalidata, puoi fare in modo che la firma del metodo richieda un AlphaNumericString e sapere che se ne ottieni uno, è valido (a parte i null). Se qualcuno tenta di passare una stringa non convalidata, genererà un errore del compilatore.

Puoi diventare più elaborato e implementare tutti gli operatori di uguaglianza o un cast esplicito a AlphaNumericString dalla semplice stringa, se ti interessa.

Dovevo controllare AZ, az, 0-9; senza regex (anche se l'OP richiede regex).

Mescolando qui varie risposte e commenti e discussioni da https://stackoverflow.com/a/9975693/292060 , questo verifica la lettera o la cifra, evitando lettere in altre lingue ed evitando altri numeri come i caratteri frazionari.

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

^\w+$ permetterà a-zA-Z0-9_

Utilizzare ^[a-zA-Z0-9]+$per non consentire il carattere di sottolineatura.

Nota che entrambi richiedono che la stringa non sia vuota. L'utilizzo *invece di +consente stringhe vuote.

Per verificare se la stringa è sia una combinazione di lettere che di cifre, puoi riscrivere la risposta @jgauffin come segue utilizzando .NET 4.0 e LINQ:

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

Stessa risposta come qui .

Se vuoi un A-z 0-9controllo ASCII non regex , non puoi usarechar.IsLetterOrDigit() poiché include altri caratteri Unicode.

Quello che puoi fare è controllare gli intervalli di codici dei caratteri.

• 48 -> 57 sono valori numerici
• 65 -> 90 sono lettere maiuscole
• 97 -> 122 sono lettere minuscole

Quanto segue è un po 'più dettagliato, ma è per facilità di comprensione piuttosto che per il golf in codice.

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

In base alla risposta di Cletus puoi creare una nuova estensione.

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

Consiglio di non dipendere da codice già pronto e integrato in .NET framework, prova a far apparire una nuova soluzione .. questo è quello che faccio

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