Regulärer Ausdruck, um zu überprüfen, ob das Passwort "8 Zeichen einschließlich 1 Großbuchstaben, 1 Sonderzeichen, alphanumerische Zeichen" enthält

(                   # Start of group
    (?=.*\d)        #   must contain at least one digit
    (?=.*[A-Z])     #   must contain at least one uppercase character
    (?=.*\W)        #   must contain at least one special symbol
       .            #     match anything with previous condition checking
         {8,8}      #        length is exactly 8 characters
)                   # End of group

In einer Zeile:

((?=.*\d)(?=.*[A-Z])(?=.*\W).{8,8})

Quellen:

• Kennwort passenden Ausdruck

• Passwort Stärke Validierung mit Regulären Ausdrücken

InformationsquelleAutor der Antwort mmdemirbas

Als ein Beispiel, wie dies getan werden könnte, eine lesbare/wartbare regex.

Für eine längere regex sollten Sie immer RegexOptions.IgnorePatternWhitespace zu ermöglichen, whitespace und Kommentare in den Ausdruck für die bessere Lesbarkeit.

String[] passwords = { "foobar", "Foobar", "Foobar1", "Fooobar12" };

foreach (String s in passwords) {

    Match password = Regex.Match(s, @"
                                      ^              # Match the start of the string
                                       (?=.*\p{Lu})  # Positive lookahead assertion, is true when there is an uppercase letter
                                       (?=.*\P{L})   # Positive lookahead assertion, is true when there is a non-letter
                                       \S{8,}        # At least 8 non whitespace characters
                                      $              # Match the end of the string
                                     ", RegexOptions.IgnorePatternWhitespace);

    if (password.Success) {
        Console.WriteLine(s + ": valid");
    }
    else {
        Console.WriteLine(s + ": invalid");
    }
}

Console.ReadLine();

InformationsquelleAutor der Antwort stema

Wenn Sie benötigen nur einen Großbuchstaben und Sonderzeichen, dann sollte dies funktionieren:

@"^(?=.{8,}$)(?=[^A-Z]*[A-Z][^A-Z]*$)\w*\W\w*$"

InformationsquelleAutor der Antwort user1096188

Dieser Frage beginnt die virale und eine Menge interessanter Vorschlag erschien.

Ja, das schreiben von hand ist schwierig. So eine einfachere Lösung ist die Verwendung einer Vorlage. Obwohl die Folge regex möglicherweise nicht optimal, es wird leichter zu verwalten und/oder ändern, und die Anwender haben eine bessere Kontrolle über das Ergebnis. Es ist möglich, dass ich etwas verpasst haben, so dass jede Konstruktive Kritik hilfreich sein wird.

Diese links könnten interessant sein: match mindestens 2 Ziffern 2 Buchstaben in beliebiger Reihenfolge in einem stringSprache Für Reguläre AusdrückeErfassung von Gruppen

Ich bin mit dieser Vorlage (?=(?:.*?({type})){({count})}) auf der Basis aller regex sah ich ALSO aus. Der nächste Schritt ist das ersetzen der benötigten Muster ( numberspecial character ... ) hinzufügen und die Konfiguration für die Länge.

Habe ich eine kleine Klasse für das erstellen der regex PasswordRegexGenerator.cs
Ein Beispiel:

string result = new PasswordRegexGenerator ( )
        .UpperCase ( 3, -1 )    //... {3,}
        .Number ( 2, 4 )        //... {2,4}
        .SpecialCharacter ( 2 ) //... {2}
        .Total ( 8,-1 )
        .Compose ( );

///<summary>
///Generator for regular expression, validating password requirements.
///</summary>
public class PasswordRegexGenerator
{
    private string _elementTemplate = "(?=(?:.*?({type})){({count})})";

    private Dictionary<string, string> _elements = new Dictionary<string, string> {
        { "uppercase", "[A-Z]" },
        { "lowercase", "[a-z]" },
        { "number", @"\d" },
        { "special", @"\W" },
        { "alphanumeric", @"\w" }
    };

    private StringBuilder _sb = new StringBuilder ( );

    private string Construct ( string what, int min, int max )
    {
        StringBuilder sb = new StringBuilder ( _elementTemplate );
        string count = min.ToString ( );

        if ( max == -1 )
        {
            count += ",";
        }
        else if ( max > 0 )
        {
            count += "," + max.ToString();
        }

        return sb
            .Replace ( "({type})", what )
            .Replace ( "({count})", count )
            .ToString ( );
    }

    ///<summary>
    ///Change the template for the generation of the regex parts
    ///</summary>
    ///<param name="newTemplate">the new template</param>
    ///<returns></returns>
    public PasswordRegexGenerator ChangeRegexTemplate ( string newTemplate )
    {
        _elementTemplate = newTemplate;
        return this;
       }

    ///<summary>
    ///Change or update the regex for a certain type ( number, uppercase ... )
    ///</summary>
    ///<param name="name">type of the regex</param>
    ///<param name="regex">new value for the regex</param>
    ///<returns></returns>
    public PasswordRegexGenerator ChangeRegexElements ( string name, string regex )
    {
        if ( _elements.ContainsKey ( name ) )
        {
            _elements[ name ] = regex;
        }
        else
        {
            _elements.Add ( name, regex );
        }
        return this;
    }

    #region construction methods 

    ///<summary>
    ///Adding number requirement
    ///</summary>
    ///<param name="min"></param>
    ///<param name="max"></param>
    ///<returns></returns>
    public PasswordRegexGenerator Number ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "number" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator UpperCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "uppercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator LowerCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "lowercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator SpecialCharacter ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "special" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator Total ( int min, int max = 0 )
    {
        string count = min.ToString ( ) + ( ( max == 0 ) ? "" : "," + max.ToString ( ) );
        _sb.Append ( ".{" + count + "}" );
        return this;
    }

    #endregion

    public string Compose ()
    {
        return "(" + _sb.ToString ( ) + ")";
    }
}

InformationsquelleAutor der Antwort Bakudan

/^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}$/

InformationsquelleAutor der Antwort Kailash Karki