RegEx IsMatch ist langsam

  • C#
  • .NET (FX) 4.5–4.8

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

    RegEx IsMatch ist langsam

    Hallo Community,

    Ich bin habe sogut wie nochnie mit RegEx gearbeitet, habe aber mit ein bisschen mich einlesen und rum experimentieren ein gutes pattern für meine Zwecke zusammen gebastelt.

    Dies ist mein pattern: ^[[|\(](.*){0,20}(]|\))(\s|)[[|\(][a-zA-Z]{1}(]|\))(\s|)(?<=(\s|))(.*)(?=(\s|)[[|\(])(\s|)[[|\(][a-zA-Z]{1}(]|\))(\s|)(.*)

    Das Pattern brauche ich um zu überprüfen ob eine Nachricht ein bestimmtes Format einhält.
    Das Format das die Nachricht haben soll:
    [PLATFORM] [H] item... [W] item...
    oder
    (PLATFORM) (H) item... (W) item...

    Methode zum überpüfen der Nachricht:

    C#-Quellcode

    1. bool isMatch = Regex.IsMatch(arg.Content, @"^[[|\(](.*){0,20}(]|\))(\s|)[[|\(][a-zA-Z]{1}(]|\))(\s|)(?<=(\s|))(.*)(?=(\s|)[[|\(])(\s|)[[|\(][a-zA-Z]{1}(]|\))(\s|)(.*)");


    Jetzt meine Frage: Wie kann ich das Pattern verbessern so das es Nachrichten schneller überprüft werden können?
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    puh!
    zunächstmal fällt mir dieses Detail auf:(.*){0,20}
    kann man da das {0,20} nicht weglassen?

    Auch hier: [a-zA-Z]{1} scheint mir die Zahlen-Angabe üflüssig: eins ist halt eins - braucht man nicht nochmal zu definieren.

    Ah - ich arbeite immer mit Regex-Objekten, die ich einmal erstelle und wiederverwende - vermutlich hat das auch eine bessere Performance.

    C#-Quellcode

    1. private Regex _rgxFormat = new Regex(@"^[[|\(](.*)(]|\))(\s|)[[|\(][a-zA-Z](]|\))(\s|)(?<=(\s|))(.*)(?=(\s|)[[|\(])(\s|)[[|\(][a-zA-Z](]|\))(\s|)(.*)");
    2. //...
    3. bool isMatch = _rgxFormat.IsMatch(arg.Content);

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Jo, {0,20} und {1} kann ruig weg. Ist wirklich etwas überflüssig.

    Ich werd's mal mit Regex-Objekten versuchen. Danke!
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Implementiere doch einfach selbst einen endlichen Automaten der alle Sprachen akzeptiert die mit [Pla... oder (Pla.... beginnen, beliebig viele Zeichen folgen, dann ein (H) folgt, beliebig viele Zeichen darauffolgend (W)/[W] akzeptiert und mit beliebig vielen Zeichen endet.

    _
    Und Gott alleine weiß alles am allerbesten und besser.

    φConst schrieb:

    Implementiere doch einfach selbst einen endlichen Automaten der alle Sprachen akzeptiert
    Jo - mach du das!


    Ich jdfs hab mein Regextester - OpenSource angeworfen und konnte einiges aus dem gegebenen Pattern rausschmeissen / korrigieren, was mir komisch vorkam.
    Kommt bislang dieses raus: ^[\[\(](.*)[\]\)]\s*[\[\(]([a-zA-Z])[\]\)](.*)[\[\(]([a-zA-Z])[\]\)](.*)
    Input habich folgende eingegeben:

    Quellcode

    1. [PLATFORM] [H]item H... [W]itemW...
    2. [PLitfrm] [H] itemH... [W] itemW...
    3. (PLATFORM) (B) itemB (W) itemW
    4. [PLATFORM] (B) itemB [X] itemX

    In mein Regextester kann man die Pattern mehrzeilig aufbauen, und so einzelne Bereiche/Gruppen besser verstehen, etwa so:

    Quellcode

    1. ^[\[\(]
    2. (.*)
    3. [\]\)]
    4. \s*
    5. [\[\(]
    6. ([a-zA-Z])
    7. [\]\)]
    8. (.*)
    9. [\[\(]
    10. ([a-zA-Z])
    11. [\]\)]
    12. (.*)
    Wie man vielleicht sieht, habe ich 5 aufzeichnende Gruppen eingebaut, wo man die Inhalte also auslesen kann - sieht in mein RTester so aus:

    Man könnte noch einiges mehr machen.
    • Insbesondere fraglich finde ich, dass auch input#4 matcht, der eine Mixtur von [], () aufweist - mein gefühl sagt mir, das sollte nicht erlaubt sein.
    • Weiters kommen bei meim Pattern auch führende + folgende Spaces in die Gruppen hinein.
      Bislang wurde da genau 1 Space entfernt, und wenns mehrere waren, kamen eben doch welche rein.
      Will man Spaces aus den Gruppen weg-trimmen muss man anders vorgehen.

    ErfinderDesRades schrieb:

    Jo - mach du das!

    Aber dann hätte er doch nichts zu tun (;?
    Einen endlichen Automaten zu realisieren ist extrem simpel.
    Wird halt bei seinem Beispiel extrem viele Zustände haben, ist aber vermutlich dennoch effizienter als das was er da gerade versucht.
    Alternativ muss er ja nicht unbedingt auf Buchstaben arbeiten - er kann ja einfach das Alphabet über ganze Wörter definieren - das reduziert die Anzahl der Zustände drastisch.
    Und Gott alleine weiß alles am allerbesten und besser.

    Ich würde den umschreiben in ^[\[\(]([^\]\)]+)[\]\)]\s*(?:[\[\(]([^\]\)]+)[\]\)]\s*(.+))[\[\(]([^\]\)]+)[\]\)]\s*(.+)

    mit den beispielen von @ErfinderDesRades

    ErfinderDesRades schrieb:

    Ah - ich arbeite immer mit Regex-Objekten, die ich einmal erstelle und wiederverwende - vermutlich hat das auch eine bessere Performance.

    Nicht vermutlich, hat auch, denn er muss nicht jedes mal neu den Patter parsen.

    φConst schrieb:

    Einen endlichen Automaten zu realisieren ist extrem simpel.
    Sorry, aber dassis Quatsch, Angeberei, Aprilscherz und/oder wasweissich.

    Aber wenns so simpel ist, beweise es. Kannst deine Lösung ja hier anhängen - bin gespannt.
    Kann dir ja nicht soviel Aufwand bereiten - simpel wie das ist.
    Und kann ich vlt. was lernen.

    Endliche Automaten hat man im ersten Semester im Modul theoretische Informatik. Da implementiert man dann auch einen endlichen Automaten der eine bestimmte Sprache akzeptiert. Das sind nur Zustandswechsel. Was soll bitteschön daran schwer sein? Zustand q0, dort liest er ein Wort, wechselt entweder zu q1, oder q2, andere Wörter führen jeweils wieder zu sich selbst, bis der ein [...]/(...) findet und wieder Zustand wechselt, bis er im akzeptierenden Zustand ist (zB weil es ein Epsilon las, denn die Sprache endet ja mit beliebigen Zeichen).
    Das ist eine reguläre Sprache - die simpelste aller Sprachen. (Kontextfrei wäre halt bissel schwerer, bräuchte dann einen Kellerautomaten).

    Im Moment habe ich zu tun, wenn ich Zeit habe implementiere ich es vielleicht'.
    Kann sein, das ich die reguläre Sprache zu dieser Aufgabe unterschätze, aber es beginnt doch mit [irgendwas], oder nicht?
    _
    Und Gott alleine weiß alles am allerbesten und besser.

    Also würdest du hingehen und

    Quellcode

    1. Ist [ oder (, dann
    2. Wiederhole solange Ist gefolgt von 'A' bis 'Z' oder 'a' bis 'z' und nicht ')' oder nicht ']' dann
    3. Sammeln
    4. End Wiederhole
    5. Spring 1 weiter
    6. Wiederhole solange ist ' '
    7. Spring 1 weiter
    8. End Wiederhole
    9. ...
    10. ENDE


    Ich glaub das macht Regex besser :D

    Nein, das ist ziemlich unschön was du da machst. Endlich Automaten arbeiten mit Zuständen. Pro eingelesenes Wort wird entschieden, welcher Zustand folgt. RegEx (also die Klasse, ansonsten ist es einfach die Sprache) ist NICHTS anderes. Es parst einfach ein gewisses Pattern und erzeugt dazu einen passenden endlichen Automaten der diese Sprache akzeptiert. Es gibt zu jedem regulären Ausdruck einen passenden Automaten (Beweis erfolgt über Kombination von Blackbox-Automaten).
    Aber im ernst, statt zu reden, mache ich es vielleicht einfach selbst. Kann verstehen wenn ich gerade ein wenig provokativ wirke.
    Und Gott alleine weiß alles am allerbesten und besser.

    Ähmmm.. Ich denke ich bleibe lieber bei Regex :P

    @ErfinderDesRades Ich habe bis jetzt immer zum testen meines Patterns diese Webseite genommen: regexr.com/
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    .... es ist RegEx (regular Expression => reguläre Ausdrücke => endliche Automaten) was ich hier schreibe, ich habe dir als Tipp nur mitgeben wollen, selbst einen endlichen Automaten zu erstellen, statt den dir generieren zu lassen. So kannst du schneller vorgehen und zudem an beliebig vielen Stellen optimieren. Das war kein OffTopic was ich schrieb.
    Und Gott alleine weiß alles am allerbesten und besser.

    Hier mal der endliche Automat das Sprachen der Form (...) (a) ... (b) ... akzeptiert:

    Spoiler anzeigen

    C#-Quellcode

    1. public class SpecifiedFiniteStateMachine
    2. {
    3. public enum State
    4. {
    5. qInit,
    7. qBracketOpen0,
    8. qBracketClose0,
    10. qBracketOpen1,
    11. qBracketClose1,
    13. qBracketOpen2,
    14. qBracketClose2,
    16. qSpaceB0,
    17. qSpaceB1,
    18. qSpaceB2,
    19. qSpaceB3,
    21. qFinal
    22. }
    24. public State AcceptingState { get; set; }
    26. public bool Accept(string input)
    27. {
    28. State currentState = State.qInit;
    30. int index = 0;
    32. while(index < input.Length && currentState != AcceptingState)
    33. {
    34. var t = input[index];
    35. switch (currentState)
    36. {
    37. case State.qInit:
    38. if (input[index] == '(')
    39. {
    40. currentState = State.qBracketOpen0;
    41. index++;
    42. }
    43. else return false;
    44. break;
    46. case State.qBracketOpen0:
    47. if (input[index++] == ')')
    48. currentState = State.qBracketClose0;
    50. break;
    51. case State.qBracketClose0:
    52. if (input[index++] == ' ')
    53. currentState = State.qSpaceB0;
    54. else return false;
    55. break;
    57. case State.qSpaceB0:
    58. if (input[index++] != ' ')
    59. {
    60. currentState = State.qBracketOpen1;
    61. index++;
    62. }
    63. else return false;
    64. break;
    66. case State.qBracketOpen1:
    67. if (input[index++] == ')')
    68. {
    69. currentState = State.qBracketClose1;
    70. }
    71. else return false;
    72. break;
    73. case State.qBracketClose1:
    74. if (input[index++] == ' ')
    75. currentState = State.qSpaceB1;
    76. else return false;
    77. break;
    79. case State.qSpaceB1:
    80. if (input[index++] == ' ')
    81. currentState = State.qSpaceB2;
    83. break;
    85. case State.qSpaceB2:
    86. if (input[index++] == '(')
    87. {
    88. currentState = State.qBracketOpen2;
    89. index++;
    90. }
    91. break;
    93. case State.qBracketOpen2:
    94. if (input[index++] == ')')
    95. currentState = State.qBracketClose2;
    96. else return false;
    97. break;
    99. case State.qBracketClose2:
    100. if (input[index++] == ' ')
    101. currentState = State.qSpaceB3;
    102. else return false;
    103. break;
    105. case State.qSpaceB3:
    106. if (input[index++] != ' ')
    107. currentState = State.qFinal;
    108. break;
    109. }
    110. }
    112. return currentState == AcceptingState;
    113. }
    114. }



    Aufruf:

    C#-Quellcode

    1. static void Main(string[] args)
    2. {
    4. SpecifiedFiniteStateMachine specifiedFiniteStateMachine
    5. = new SpecifiedFiniteStateMachine();
    7. specifiedFiniteStateMachine.AcceptingState = SpecifiedFiniteStateMachine.State.qFinal;
    9. string s = "(PLATFORM) (B) itemB (W) itemW ";
    10. Console.WriteLine(specifiedFiniteStateMachine.Accept(s)); // true
    12. s = "(PLAfkrM) (B) itemB (W) itemW";
    13. Console.WriteLine(specifiedFiniteStateMachine.Accept(s)); // true
    15. s = "(OJRGIPRJIG00000) (B) itemiorghrgregregore (W) itemW";
    16. Console.WriteLine(specifiedFiniteStateMachine.Accept(s)); // true
    18. s = "(PLAfkrM)(B) itemB (W) itemW";
    19. Console.WriteLine(specifiedFiniteStateMachine.Accept(s)); // false
    21. s = "(PLAfkrM) (B)itemB (W) itemW";
    22. Console.WriteLine(specifiedFiniteStateMachine.Accept(s)); // false
    24. Console.Read();
    26. }


    Kann sein, dass es noch hier und da Fehler gibt, hab es' auf die Schnelle implementiert.
    Dasselbe analog für [...] [x] ... [y] ...

    Ich habe "item..." als beliebig viele Zeichen interpretiert. Falls dem nicht so ist, sieht der Automat ein wenig anders aus. Aber es soll ja ein Anreiz sein, dass du das selbst implementierst.

    @ErfinderDesRades Es ist einfach - was denkst du findet im Hintergrund statt? Es wird zu einem regulären Ausdruck einfach ein endlicher Automat erzeugt. Guck dir das mal an:

    _
    Und Gott alleine weiß alles am allerbesten und besser.

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „φConst“ ()

    Also mit dem Pattern habe ich nun keine Probleme mehr: ^[[|\(](.+)(]|\))(\s|)[[|\(][a-zA-Z](]|\))(\s|)(?<=(\s|))(.*)(?=(\s|)[[|\(])(\s|)[[|\(][a-zA-Z](]|\))(\s|)(.+)
    Regex.IsMatch ist nun wieder super schnell^^

    Das Thema hätte sich für mich erledigt.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Naja, wenn du meinst. Dennoch empfehle ich dir endliche Automaten zu verstehen, statt einfach irgendwelche Pattern (z.B. try&error-mäßig) zu tippen.
    Das ist kein Hexenwerk, endliche Automaten sind simpel, auch wenn es nicht jeder so sieht.
    Und Gott alleine weiß alles am allerbesten und besser.

    Naja, wenn ich mich erstmal mehr damit beschaftige wird es später auch kein try&error-mäßiges Tippen mehr ^^
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    ClonkAndre schrieb:

    Also mit dem Pattern habe ich nun keine Probleme mehr: ^[[|\(](.+)(]|\))(\s|)[[|\(][a-zA-Z](]|\))(\s|)(?<=(\s|))(.*)(?=(\s|)[[|\(])(\s|)[[|\(][a-zA-Z](]|\))(\s|)(.+)
    Das ist aber doch voll der Rückschritt gegenüber was ich ausbaldovert habe.
    Funzt glaub auch nicht richtig - probiermal mit

    Quellcode

    1. [PLitfrm] [H] itemH... [W] itemW...
    2. |PLATFORM] (B) itemB [X] itemX
    #1 matcht nicht, obwohl sie glaub sollte
    #2 matcht, obwohl nicht sollte

    Und dann sind wieder die unsinnigen Nichtaufzeichnenden Gruppen drin: (?...)
    Und unangemessene bzw. disfunktionale Oder-Konstruktionen
    unsinn, kann weg: (?<=(\s|)), (?=(\s|)[[|\(])
    unangemessen: (\s|) besser wäre einfach \s?
    disfunktional: [[|\(] gemeint ist wohl: [\[\(]


    Wie kommts zu diesem Rückschritt? Ist das auf dem Online-RegexTester entwickelt?

    Bei meim Teil ist auch die Befehls-Referenz der Regex-Sprache mit dabei.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „ErfinderDesRades“ ()