Jak mogę zweryfikować ciąg, aby zezwalał tylko na znaki alfanumeryczne?

Jak mogę zweryfikować ciąg przy użyciu wyrażeń regularnych, aby zezwalać tylko na znaki alfanumeryczne?

(Nie chcę też dopuszczać żadnych spacji).

Użyj następującego wyrażenia:

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

to znaczy:

using System.Text.RegularExpressions;

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

W .NET 4.0 możesz użyć LINQ:

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

yourText.Allprzestanie wykonywać i zwróci falsepierwsze char.IsLetterOrDigitraporty, falseponieważ umowa Allnie może być wtedy wykonana .

Uwaga! ta odpowiedź nie sprawdza ściśle znaków alfanumerycznych (zwykle są to AZ, az i 0-9). Ta odpowiedź zezwala na lokalne znaki, takie jak åäö.

Aktualizacja 2018-01-29

Powyższa składnia działa tylko wtedy, gdy używasz pojedynczej metody, która ma pojedynczy argument prawidłowego typu (w tym przypadku char).

Aby użyć wielu warunków, musisz napisać w ten sposób:

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

Możesz to łatwo zrobić za pomocą funkcji rozszerzającej zamiast wyrażenia regularnego ...

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

Za komentarz :) ...

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

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

Chociaż myślę, że rozwiązanie oparte na wyrażeniach regularnych jest prawdopodobnie drogą, którą bym poszedł, miałbym pokusę, aby zawrzeć to w typie.

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

Teraz, gdy potrzebujesz zweryfikowanego ciągu, możesz mieć podpis metody, aby wymagał AlphaNumericString i wiedzieć, że jeśli go otrzymasz, jest prawidłowy (oprócz wartości null). Jeśli ktoś spróbuje przekazać niezatwierdzony ciąg, wygeneruje błąd kompilatora.

Możesz uzyskać bardziej wyszukane i zaimplementować wszystkie operatory równości lub jawne rzutowanie na AlphaNumericString ze zwykłego łańcucha, jeśli ci zależy.

Musiałem sprawdzić AZ, az, 0-9; bez wyrażenia regularnego (nawet jeśli OP pyta o wyrażenie regularne).

Łącząc tutaj różne odpowiedzi i komentarze oraz dyskusję z https://stackoverflow.com/a/9975693/292060 , ten test sprawdza litery lub cyfry, unikając liter w innych językach i unikając innych liczb, takich jak znaki ułamkowe.

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

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

Służy ^[a-zA-Z0-9]+$do blokowania podkreślenia.

Zauważ, że oba wymagają, aby ciąg nie był pusty. Używanie *zamiast +zezwala na puste ciągi.

Aby sprawdzić, czy ciąg jest kombinacją liter i cyfr, możesz ponownie napisać odpowiedź @jgauffin w następujący sposób, używając .NET 4.0 i LINQ:

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

Ta sama odpowiedź jak tutaj .

Jeśli chcesz A-z 0-9sprawdzić ASCII inne niż regex , nie możesz użyć, char.IsLetterOrDigit()ponieważ obejmuje to inne znaki Unicode.

Możesz sprawdzić zakresy kodów znaków.

• 48 -> 57 to cyfry
• 65 -> 90 to wielkie litery
• 97 -> 122 to małe litery

Poniższy tekst jest nieco bardziej szczegółowy, ale służy raczej do zrozumienia niż do kodowania golfa.

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

Na podstawie odpowiedzi Cletusa możesz utworzyć nowe rozszerzenie.

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

Radzę nie polegać na gotowym i wbudowanym kodzie w .NET frameworku, spróbować stworzyć nowe rozwiązanie .. to właśnie robię ..

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