Regex Problem

  • C#
  • .NET (FX) 1.0–2.0

Es gibt 25 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Regex Problem

    Hey,

    Kann mir jemand helfen ein solches Regex-Pattern zu erstellen um mittels einer solchen Funktion

    C#-Quellcode

    1. private static bool IsValid(string pass)
    2. {
    3. }


    zu prüfen ob mein Passwort im richtigen Format ist.
    Das Passwort hat folgende Eigenschaften:

    - Es muss aus 8 Zeichen bestehen/bzw 8 Zeichen lang sein.
    - Es dürfen nur folgende Zeichen darin vorkommen : 0,1,2,3,4,5,6,7,8,9,0,A,B,C,D,E,F (ohne die Kommas)
    - Falls Buchstaben darin vorkommen müssen es Großbuchstaben sein.

    Lg
    Rikudo
    C# Developer
    Learning C++

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Rikudo“ ()

    Du willst nur Hexwerte in deinem Passwort zulassen?

    Naja, mir einer einfachen suche wäre man bei

    Quellcode

    1. ​^[0-9A-F]+$

    gelandet
    Die deutsche Sprache ist Freeware, du kannst sie benutzen, ohne dafür zu bezahlen. Sie ist aber nicht Open Source, also darfst du sie nicht verändern, wie es dir gerade passt.

    C#-Quellcode

    1. ​ private bool isValid(string pass)
    2. {
    3. if (pass.Length < 8) return false;
    4. var invalidChars = new[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A', 'C', 'D', 'E', 'F'};
    5. return pass.ToCharArray().All(x => invalidChars.Contains(x));
    6. }
    Mfg
    Vincent

    @Higlav, Sorry das mit den acht Zeichen hatte ich nicht eingefügt und das B übersehen.
    Wobei die Frage ist ob es wirklich nicht dabei sin soll oder im Startpost einfach nur fehlt
    Die deutsche Sprache ist Freeware, du kannst sie benutzen, ohne dafür zu bezahlen. Sie ist aber nicht Open Source, also darfst du sie nicht verändern, wie es dir gerade passt.

    Higlav schrieb:

    ^[0-9ACDEF]{8}$

    EDIT: @MrTrebron Das "B" ist nicht dabei und es sollen genau 8 Zeichen sein. ;)

    Whops, das hab ich ausversehen vergessen dazuzuschreiben :D
    Das B muss auch dazu ist aber ja kein Problem kann ich ja in dem Pattern grad dazufügen^^
    Danke für die schnellen antowrten an alle :D
    C# Developer
    Learning C++

    Rikudo schrieb:

    kann ich ja in dem Pattern grad dazufügen^^

    Schreib dafür doch einfach den Vorschlag von @Thunderbolt um:
    ^[0-9A-F]{8}$

    Somit sparst Du das mit den vielen Buchstaben. ;)

    Grüße
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    @Rikudo Wenn du Hex evaulieren möchtest, kann auch TryParse helfen. Ich weiß nur nicht, wie performant das abläuft:

    C#-Quellcode

    1. bool isValid(string pass) {
    2. int temp;
    3. return int.TryParse(pass, System.Globalization.NumberStyles.HexNumber, null, out temp);
    4. }
    Mit freundlichen Grüßen,
    Thunderbolt

    Hier meine Testergebnisse:


    TestCode

    C#-Quellcode

    1. class Program
    2. {
    3. static long timeRegexValid = 0;
    4. static long timeRegexInvalid = 0;
    5. static long timeLinqValid = 0;
    6. static long timeLinqInvalid = 0;
    7. static long timeParseValid = 0;
    8. static long timeParseInvalid = 0;
    9. static long timeRinecamoValid = 0;
    10. static long timeRinecamoInvalid = 0;
    12. static Stopwatch sRegex = new Stopwatch();
    13. static Stopwatch sLinq = new Stopwatch();
    14. static Stopwatch sParse = new Stopwatch();
    15. static Stopwatch sRinecamo = new Stopwatch();
    17. static long Freq = Stopwatch.Frequency;
    19. [STAThread]
    20. static void Main(string[] args)
    21. {
    22. Console.WriteLine("Tasks Running ...");
    23. Task Regex = Task.Factory.StartNew(delegate
    24. {
    25. for(int i = 0; i < 1000000; i++)
    26. {
    27. string pass = CreatePasswordValid();
    28. sRegex.Start();
    29. IsValidRegex(pass);
    30. timeRegexValid += sRegex.ElapsedTicks;
    31. sRegex.Reset();
    32. }
    33. for(int i = 0; i < 1000000; i++)
    34. {
    35. string pass = CreatePasswordInvalid();
    36. sRegex.Start();
    37. IsValidRegex(pass);
    38. timeRegexInvalid += sRegex.ElapsedTicks;
    39. sRegex.Reset();
    40. }
    41. });
    42. Task Linq = Task.Factory.StartNew(delegate
    43. {
    44. for(int i = 0; i < 1000000; i++)
    45. {
    46. string pass = CreatePasswordValid();
    47. sLinq.Start();
    48. IsValidLinq(pass);
    49. timeLinqValid += sLinq.ElapsedTicks;
    50. sLinq.Reset();
    51. }
    52. for(int i = 0; i < 1000000; i++)
    53. {
    54. string pass = CreatePasswordInvalid();
    55. sLinq.Start();
    56. IsValidLinq(pass);
    57. timeLinqInvalid += sLinq.ElapsedTicks;
    58. sLinq.Reset();
    59. }
    60. });
    61. Task Parse = Task.Factory.StartNew(delegate
    62. {
    63. for(int i = 0; i < 1000000; i++)
    64. {
    65. string pass = CreatePasswordValid();
    66. sParse.Start();
    67. IsValidParse(pass);
    68. timeParseValid += sParse.ElapsedTicks;
    69. sParse.Reset();
    70. }
    71. for(int i = 0; i < 1000000; i++)
    72. {
    73. string pass = CreatePasswordInvalid();
    74. sParse.Start();
    75. IsValidParse(pass);
    76. timeParseInvalid += sParse.ElapsedTicks;
    77. sParse.Reset();
    78. }
    79. });
    80. Task Rinecamo = Task.Factory.StartNew(delegate
    81. {
    82. for(int i = 0; i < 1000000; i++)
    83. {
    84. string pass = CreatePasswordValid();
    85. sRinecamo.Start();
    86. IsValidRinecamo(pass);
    87. timeRinecamoValid += sRinecamo.ElapsedTicks;
    88. sRinecamo.Reset();
    89. }
    90. for(int i = 0; i < 1000000; i++)
    91. {
    92. string pass = CreatePasswordInvalid();
    93. sRinecamo.Start();
    94. IsValidRinecamo(pass);
    95. timeRinecamoInvalid += sRinecamo.ElapsedTicks;
    96. sRinecamo.Reset();
    97. }
    98. });
    100. Task.WaitAll(Regex, Linq, Parse, Rinecamo);
    101. Console.WriteLine("After 1000000 runs each:\r\n");
    102. Console.WriteLine("Regex Valid Passwords: {0} seconds", Math.Round((double)timeRegexValid / (double)Freq,4));
    103. Console.WriteLine("Regex Invalid Passwords: {0} seconds\r\n", Math.Round((double)timeRegexInvalid / (double)Freq, 4));
    104. Console.WriteLine("Linq Valid Passwords: {0} seconds", Math.Round((double)timeLinqValid / (double)Freq, 4));
    105. Console.WriteLine("Linq Invalid Passwords: {0} seconds\r\n", Math.Round((double)timeLinqInvalid / (double)Freq, 4));
    106. Console.WriteLine("Parse Valid Passwords: {0} seconds", Math.Round((double)timeParseValid / (double)Freq, 4));
    107. Console.WriteLine("Parse Invalid Passwords: {0} seconds\r\n", Math.Round((double)timeParseInvalid / (double)Freq, 4));
    108. Console.WriteLine("Rinecamo Valid Passwords: {0} seconds", Math.Round((double)timeRinecamoValid / (double)Freq, 4));
    109. Console.WriteLine("Rinecamo Invalid Passwords: {0} seconds\r\n", Math.Round((double)timeRinecamoInvalid / (double)Freq, 4));
    110. Console.WriteLine("Frequency: {0}", Stopwatch.Frequency);
    111. Console.ReadKey(true);
    112. }
    114. public static string CreatePasswordValid(int passwordLength=8, string AllChar = "0123456789ABCDEF")
    115. {
    116. string allowedChars = AllChar;
    117. char[] chars = new char[passwordLength];
    118. var rd = new Random();
    120. for(int i = 0; i < passwordLength; i++)
    121. { chars[i] = allowedChars[rd.Next(0, allowedChars.Length)]; }
    122. return new string(chars);
    123. }
    125. public static string CreatePasswordInvalid(int passwordLength=8, string AllChar = "!\"§$%&/()=?GHIJKL")
    126. {
    127. string allowedChars = AllChar;
    128. char[] chars = new char[passwordLength];
    129. var rd = new Random();
    131. for(int i = 0; i < passwordLength; i++)
    132. { chars[i] = allowedChars[rd.Next(0, allowedChars.Length)]; }
    133. return new string(chars);
    134. }
    136. private static bool IsValidRegex(string Passwort)
    137. {
    138. return Regex.IsMatch(Passwort, "^[0-9A-F]{8}$",RegexOptions.Compiled);
    139. }
    141. private static bool IsValidLinq(string Passwort)
    142. {
    143. if(Passwort.Length < 8)
    144. return false;
    145. var invalidChars = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A', 'C', 'D', 'E', 'F' };
    146. return Passwort.ToCharArray().All(x => invalidChars.Contains(x));
    147. }
    149. private static bool IsValidRinecamo(string Passwort)
    150. {
    151. foreach(var c in Passwort)
    152. {
    153. if((c <= 47 || c >= 58) && (c <= 64 || c >= 71))
    154. return false;
    155. }
    156. return true;
    157. }
    159. private static bool IsValidParse(string Passwort)
    160. {
    161. int temp;
    162. return int.TryParse(Passwort, System.Globalization.NumberStyles.HexNumber, null, out temp);
    163. }
    164. }

    Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von „EaranMaleasi“ ()

    1. Deine PasswordInvalid-Methode sieht genauso aus wie die PassworValid-Methode
    2. Ist, was meinen PC angeht, am schnellsten.

    C#-Quellcode

    1. foreach (var c in Passwort) {
    2. if ((c <= 47 || c >= 58) && (c <= 64 || c >= 71)) return false;
    3. }
    4. return true;

    3. RegexOptions.Compiled ;)

    @EaranMaleasi
    Ich habe den Test gerade selbst mal gemacht, allerdings mit 100.000 Durchläufen und ich war erstaunt:


    Ich habe mir folgendes überlegt: Ich habe mal gehört, dass Linq langsamer ist, als wenn man es selbst mit einer ForEach-Schleife macht (keine Ahnung, was die machen). Die ForEach-Methode sieht so aus:
    Spoiler anzeigen

    C#-Quellcode

    1. private static bool IsValidForEach(string pass)
    2. {
    3. if (pass.Length < 8) return false;
    4. foreach (var c in pass.ToCharArray())
    5. {
    6. if (!validChars.Contains(c)) return false;
    7. }
    9. return true;
    10. }


    Wie man auch sehen kann, wird jetzt nicht jedes Mal dieses Array erstellt (ist einfach nur Speicherverschwendung), sondern es ist einfach eine statische, ReadOnly Variable. Das ist der komplette Code:
    Spoiler anzeigen

    C#-Quellcode

    1. class Program
    2. {
    3. private static readonly char[] validChars = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A', 'C', 'D', 'E', 'F' };
    5. static void Main(string[] args)
    6. {
    7. var stopwatch = new Stopwatch();
    8. long all = 0;
    9. const double loops = 100000;
    12. var password = CreatePasswordValid();
    13. Console.WriteLine("===================== Valid Password: {0} =====================", password);
    14. for (int i = 0; i < loops; i++)
    15. {
    16. stopwatch.Start();
    17. IsValidLinq(password);
    18. stopwatch.Stop();
    19. all += stopwatch.ElapsedTicks;
    20. stopwatch.Reset();
    21. }
    22. Console.WriteLine("Linq: " + (all / loops));
    24. all = 0;
    25. for (int i = 0; i < loops; i++)
    26. {
    27. stopwatch.Start();
    28. IsValidForEach(password);
    29. stopwatch.Stop();
    30. all += stopwatch.ElapsedTicks;
    31. stopwatch.Reset();
    32. }
    33. Console.WriteLine("ForEach: " + (all / loops));
    35. all = 0;
    36. for (int i = 0; i < loops; i++)
    37. {
    38. stopwatch.Start();
    39. IsValidRegex(password);
    40. stopwatch.Stop();
    41. all += stopwatch.ElapsedTicks;
    42. stopwatch.Reset();
    43. }
    44. Console.WriteLine("Regex: " + (all / loops));
    46. password = CreatePasswordInvalid();
    47. Console.WriteLine("===================== Invalid Password: {0} =====================", password);
    48. all = 0;
    49. for (int i = 0; i < loops; i++)
    50. {
    51. stopwatch.Start();
    52. IsValidLinq(password);
    53. stopwatch.Stop();
    54. all += stopwatch.ElapsedTicks;
    55. stopwatch.Reset();
    56. }
    57. Console.WriteLine("Linq: " + (all / loops));
    59. all = 0;
    60. for (int i = 0; i < loops; i++)
    61. {
    62. stopwatch.Start();
    63. IsValidForEach(password);
    64. stopwatch.Stop();
    65. all += stopwatch.ElapsedTicks;
    66. stopwatch.Reset();
    67. }
    68. Console.WriteLine("ForEach: " + (all / loops));
    70. all = 0;
    71. for (int i = 0; i < loops; i++)
    72. {
    73. stopwatch.Start();
    74. IsValidRegex(password);
    75. stopwatch.Stop();
    76. all += stopwatch.ElapsedTicks;
    77. stopwatch.Reset();
    78. }
    79. Console.WriteLine("Regex: " + (all / loops));
    81. password = "garcon";
    82. Console.WriteLine("===================== Too short password: {0} =====================", password);
    83. all = 0;
    84. for (int i = 0; i < loops; i++)
    85. {
    86. stopwatch.Start();
    87. IsValidLinq(password);
    88. stopwatch.Stop();
    89. all += stopwatch.ElapsedTicks;
    90. stopwatch.Reset();
    91. }
    92. Console.WriteLine("Linq: " + (all / loops));
    94. all = 0;
    95. for (int i = 0; i < loops; i++)
    96. {
    97. stopwatch.Start();
    98. IsValidForEach(password);
    99. stopwatch.Stop();
    100. all += stopwatch.ElapsedTicks;
    101. stopwatch.Reset();
    102. }
    103. Console.WriteLine("ForEach: " + (all / loops));
    105. all = 0;
    106. for (int i = 0; i < loops; i++)
    107. {
    108. stopwatch.Start();
    109. IsValidRegex(password);
    110. stopwatch.Stop();
    111. all += stopwatch.ElapsedTicks;
    112. stopwatch.Reset();
    113. }
    114. Console.WriteLine("Regex: " + (all / loops));
    116. Console.ReadKey();
    117. }
    119. private static bool IsValidLinq(string pass)
    120. {
    121. if (pass.Length < 8) return false;
    122. return pass.ToCharArray().All(c => validChars.Contains(c));
    123. }
    125. private static bool IsValidForEach(string pass)
    126. {
    127. if (pass.Length < 8) return false;
    128. foreach (var c in pass.ToCharArray())
    129. {
    130. if (!validChars.Contains(c)) return false;
    131. }
    133. return true;
    134. }
    136. private static bool IsValidRegex(string pass)
    137. {
    138. return Regex.IsMatch(pass, "^[0-9ACDEF]{8}$");
    139. }
    141. public static string CreatePasswordValid(int passwordLength = 8)
    142. {
    143. var result = new char[passwordLength];
    144. var rd = new Random();
    145. for (int i = 0; i < passwordLength; i++)
    146. { result[i] = validChars[rd.Next(0, validChars.Length)]; }
    147. return new string(result);
    148. }
    150. public static string CreatePasswordInvalid(int passwordLength = 9)
    151. {
    152. var garcon = "safiau&fasjif98´7o6".ToCharArray();
    153. var result = new char[passwordLength];
    154. var rd = new Random();
    155. for (int i = 0; i < passwordLength; i++)
    156. { result[i] = garcon[rd.Next(0, garcon.Length)]; }
    157. return new string(result);
    158. }
    159. }


    Also: ForEach ist am schnellsten! Ich bin so dumm, habe gar nicht gesehen, dass Parse noch schneller ist... Egal, angenommen, man möchte sich nicht nur auf gültige Hex-Buchstaben beschränken.
    Mfg
    Vincent

    EaranMaleasi schrieb:

    Und nu fehlt nur noch ein Geschwindigkeitsvergleich
    Was soll das bringen?
    Ist etwa vorgesehen, 100000 Pasworte auf einmal zu validieren?

    Andernfalls ist die Geschwindigkeit malwieder vollkommen irrelevant.

    Weil 10000 passworte würden im langsamsten Fall 0,3Sekunden brauchen, und wären im schnellsten Fall 0,2s schneller. wow!

    Nur wo nehmen wir jetzt 10000 Passworte her?

    Was das bringen soll?
    Es zeigt uns und anderen welche Methode in diesem Kontext am schnellsten ist.
    Wenn bei dir für so was jegliches Interesse fehlt, kannst du uns ja in Zukunft mit deinen unnötigen Beiträgen verschonen.
    Bei aller Liebe EDR, aber nein, einfach nein.

    naja, mein Beitrag ist eben nicht unnötig.
    Ich weise darauf hin, dass solche Geschwindigkeits-Optimierungen unnötig sind.
    Weil manch einer legt da viel Brain-Power rein, und es bringt nichts. Und das muss man sich klar machen.
    Oft verschlechtert sich gar die Lesbarkeit des Codes, und dann hat man eine Lösung, die zwar schneller ist (was ja nix bringt), aber schlechter wartbar - was ein deutlicher Nachteil ist.
    Ergibt in Summe eine Verschlechterung, von der ganz eindeutig abzuraten ist.
    So auch hier: Nach Geschwindigkeit würde man Foreach wählen, aber nach Lesbarkeit ist das die schlechteste Lösung, und also die falsche, denn Programmier-Prinzip: von 2 verschieden guten Lösungen ist nur die beste richtig.

    Und das erkennt ihr nicht, und deshalb ist nötig, dass ich euch vor dieser Denke warne, die den Rules Of Optimization zuwiderläuft.

    Mir persönlich ging es nur darum die Frage der Performance von @Thunderbolt zu beantworten. Klar, für Passwordvalidierungen mag das vielleicht nicht so nützlich sein, (einmal durch ne mehrere GB große Login-Daten-DB laufen lassen vielleicht?) aber es gibt bestimmt Bereiche, in denen mehrere Millionen von Datensätzen verglichen werden müssen. Ist dann eben praktisch wenns nur 0,2 Sekunden dauert anstatt 1,x Sekunden je Million.

    Habe nun meinen Code nach den Punkten von @Rinecamo angepasst und den Screenshot aktualisiert.

    Jo, generell die Geschwindigkeit verschiedener String-Verarbeitungs-Ansätze zu untersuchen findich durchaus sinnvoll.

    Kann einem ja helfen, wenn mal Performance-Probleme auftreten.

    kann man sich auch merken, welche Ansätze das sind:
    • Regex
    • mit Schleifen die Zeichen durchlaufen
    • Linq
    • TryParse - bei geeigneten String-Daten
    Und die good old Schleifen waren die schnellsten, mit bis zu Faktor 3, oder?