Hilfestellung bei Objektmodell

  • Allgemein

Es gibt 5 Antworten in diesem Thema. Der letzte Beitrag () ist von TheProfessor.

    Hilfestellung bei Objektmodell

    Hallo zusammen,

    momentan entwickle ich einen Parser (hoffe das ist hierfür die richtige Bezeichnung :D) der mir eine bestimmte Zeichenkette einliest und zerlegt. Eine mögliche Zeichenkette wäre Folgende:

    +(Rot/Blau/Grün)+Viereckig+(Leicht/Schwer)+Teuer

    Rauskommen sollen alle möglichen Kombinationen die dieser Term beinhaltet, also:

    Rot, Viereckig, Leicht, Teuer
    Blau, Viereckig, Leicht, Teuer
    usw...

    Die Aufdröselung nach einzelnen Kombinationen funktioniert schon mal einwandfrei. Im nächsten Schritt möchte ich die Ergebnisse aber untereinander vergleichen. Hierfür muss ich mithilfe zugeführter Daten kategorisieren um welchen Typ sich jedes Merkmal handelt damit ich weiß was ich womit vergleich muss, Farbe mit Farbe zum Beispiel. Rot/Blau/Grün sind vom Typ Farbe, Viereckig ist vom Typ Form usw...
    Das ist wichtig für mich weil die Vergleichsmechanismen vom jeweiligen Typ abhängig sind und sich nicht verallgemeinern lassen.

    Hier mein Ansatz:

    Jeder Typ (Farbe, Form, Preis, ...) bekommt eine eigene Klasse spendiert die alle von der Basisklasse "Merkmal" erben. In den jeweiligen Klassen lassen sich sehr bequem die Vergleichsmechanismen realisieren. Das Problem ist jetzt aber der Schritt wie ich überhaupt an ein Objekt des richtigen Typs komme. Zu welchem Typ meine Zeichenkette (z.B. "Blau") gehört lese ich mir aus einer XML-Datei aus:

    XML-Quellcode

    1. <MermalTypen>
    2. <Typ Name="Farbe">
    3. <Value>Blau</Value>
    4. <Value>Rot</Value>
    5. <Value>Grün</Value>
    6. </Typ>
    7. <Typ Name="Form">
    8. <Value>Viereckig</Value>
    9. <Value>Rund</Value>
    10. <Value>Oval</Value>
    11. </Typ>
    12. <Typ Name="Preis">
    13. <Value>Teuer </Value>
    14. <Value>Billig </Value>
    15. </Typ>
    16. <Typ Name="Gewicht">
    17. <Value>Leicht</Value>
    18. <Value>Schwer</Value>
    19. </Typ>
    20. </MermalTypen>


    VB.NET-Quellcode

    1. Private Sub MerkmaleHinzufuegen(MerkmalWerte As List(Of XElement))
    3. For Each MerkmalWertXElement As XElement In MerkmalWerte
    5. Dim MerkmalWertTyp As String = MerkmalWertXElement.@Name
    6. Dim NeuesMerkmal As Merkmal
    8. Select Case MerkmalWert
    9. Case "Farbe"
    10. NeuesMerkmal = New Farbe()
    11. Case "Form"
    12. NeuesMerkmal = New Form()
    13. Case "Preis"
    14. NeuesMerkmal = New Preis()
    15. Case "Gewicht"
    16. NeuesMerkmal = New Gewicht()
    17. Case Else
    18. Throw New ArgumentException(MerkmalWert & " ist nicht im Merkmalsvorrat vorhanden", "MerkmalWerte")
    19. End Select
    20. '...
    21. End Sub



    Obwohl der Ansatz im weiteren Verlauf blendend funktionieren zu scheint so bin ich an dieser Stelle doch noch sehr unzufrieden. Problematisch wird es wenn jetzt weitere Typen hinzukommen was definitiv passieren wird. Ich müsste sowohl Neue Klassen anlegen (Damit könnte ich noch leben) aber auch diese Methode abändern. Auch dass hier nach einem String differenziert wird gefällt mir nicht wirklich. Ich hätte gerne so etwas wie ein Enum dass sich dynamisch erstellt und erweitet und dann jedes mal durchlaufen wird.

    Ja die "Fragestellung" hier ist sehr vage aber vielleicht gibt es ja jemanden dem auf Anhieb ein viel besserer Ansatz einfällt. Bin für alles offen.

    Vielen Dank fürs lesen und für eventuell folgende Beiträge :thumbsup:


    Gruß Tommi

    Hi,

    habe hier mal ne Lösung für dich:

    PHP-Quellcode

    1. <?php
    2. /**
    3. * In Anlehnung an den Code von: https://pmellor.wordpress.com/2013/09/30/working-out-combinations-of-a-multidimensional-array-in-php/
    4. */
    6. function workOutCombinations ($data, &$all = array(), $group = array(), $val = null, $i = 0) {
    7. if (isset($val)) {
    8. array_push($group, $val);
    9. }
    11. if ($i >= count($data)) {
    12. array_push($all, $group);
    13. } else {
    14. foreach ($data[$i] as $v) {
    15. workOutCombinations($data, $all, $group, $v, $i + 1);
    16. }
    17. }
    18. return $all;
    19. }
    21. # Dein String
    22. $str = "+(Rot/Blau/Grün)+Viereckig+(Leicht/Schwer)+Teuer";
    23. if(isset($_POST['str'])){
    24. $str = htmlspecialchars($_POST['str'], ENT_QUOTES);
    25. }
    26. $str = @preg_replace('/^ *\++|\++ *$/i', '', $str);
    27. $arr = @preg_split('/\+/', $str);
    28. $myArray = array();
    30. foreach($arr as $k => $v){
    31. if(@preg_match('/^\(.*?\)$/i', $v)){
    32. $v = @preg_replace('/\(|\)/', '', $v);
    33. $subarr = @preg_split('/\//i', $v);
    34. $arr[] = $subarr;
    35. $myArray[] = $subarr;
    36. }else{
    37. $myArray[] = array($v);
    38. }
    39. }
    41. $combos = workOutCombinations($myArray);
    42. foreach($combos as $c){
    43. echo implode(', ', $c) . "<br>";
    44. }
    45. ?>
    46. <!DOCTYPE html>
    47. <html>
    49. <head>
    50. <title>Test</title>
    51. </head>
    53. <body>
    55. <main>
    56. <hr>
    57. <form method="POST">
    58. <input type="text" name="str" value="<?php echo $str, ENT_QUOTES; ?>" style="width: 90%;"><br>
    59. <input type="submit" value="Submit">
    60. </form>
    62. </main>
    64. </body>
    66. </html>



    Eine Demo zum Sofort-Testen: marius-gerum.de/hurr.php

    String zum Testen: (Rot/Blau/Grün)+Viereckig+(Leicht/Schwer)+Teuer+(Neu/Gebraucht/Neuwertig)+(Bezahlt/Offen)

    Ausgabe im Falle des eben genannten Test-Strings:

    Quellcode

    1. Rot, Viereckig, Leicht, Teuer, Neu, Bezahlt
    2. Rot, Viereckig, Leicht, Teuer, Neu, Offen
    3. Rot, Viereckig, Leicht, Teuer, Gebraucht, Bezahlt
    4. Rot, Viereckig, Leicht, Teuer, Gebraucht, Offen
    5. Rot, Viereckig, Leicht, Teuer, Neuwertig, Bezahlt
    6. Rot, Viereckig, Leicht, Teuer, Neuwertig, Offen
    7. Rot, Viereckig, Schwer, Teuer, Neu, Bezahlt
    8. Rot, Viereckig, Schwer, Teuer, Neu, Offen
    9. Rot, Viereckig, Schwer, Teuer, Gebraucht, Bezahlt
    10. Rot, Viereckig, Schwer, Teuer, Gebraucht, Offen
    11. Rot, Viereckig, Schwer, Teuer, Neuwertig, Bezahlt
    12. Rot, Viereckig, Schwer, Teuer, Neuwertig, Offen
    13. Blau, Viereckig, Leicht, Teuer, Neu, Bezahlt
    14. Blau, Viereckig, Leicht, Teuer, Neu, Offen
    15. Blau, Viereckig, Leicht, Teuer, Gebraucht, Bezahlt
    16. Blau, Viereckig, Leicht, Teuer, Gebraucht, Offen
    17. Blau, Viereckig, Leicht, Teuer, Neuwertig, Bezahlt
    18. Blau, Viereckig, Leicht, Teuer, Neuwertig, Offen
    19. Blau, Viereckig, Schwer, Teuer, Neu, Bezahlt
    20. Blau, Viereckig, Schwer, Teuer, Neu, Offen
    21. Blau, Viereckig, Schwer, Teuer, Gebraucht, Bezahlt
    22. Blau, Viereckig, Schwer, Teuer, Gebraucht, Offen
    23. Blau, Viereckig, Schwer, Teuer, Neuwertig, Bezahlt
    24. Blau, Viereckig, Schwer, Teuer, Neuwertig, Offen
    25. Grün, Viereckig, Leicht, Teuer, Neu, Bezahlt
    26. Grün, Viereckig, Leicht, Teuer, Neu, Offen
    27. Grün, Viereckig, Leicht, Teuer, Gebraucht, Bezahlt
    28. Grün, Viereckig, Leicht, Teuer, Gebraucht, Offen
    29. Grün, Viereckig, Leicht, Teuer, Neuwertig, Bezahlt
    30. Grün, Viereckig, Leicht, Teuer, Neuwertig, Offen
    31. Grün, Viereckig, Schwer, Teuer, Neu, Bezahlt
    32. Grün, Viereckig, Schwer, Teuer, Neu, Offen
    33. Grün, Viereckig, Schwer, Teuer, Gebraucht, Bezahlt
    34. Grün, Viereckig, Schwer, Teuer, Gebraucht, Offen
    35. Grün, Viereckig, Schwer, Teuer, Neuwertig, Bezahlt
    36. Grün, Viereckig, Schwer, Teuer, Neuwertig, Offen


    Code musst halt in VB umwandeln, bin einfach wesentlich fitter in PHP.

    Wenn dann sowieso Typen hinzukommen, die du gar nicht beeinflussen kannst, wird aber das mit der Kategorisierung nicht so wirklich hinhauen 8|
    Theoretisch kannst du die Ausgabe auch als HTML-Tabelle schreiben - fertige js-Bibliotheken mit der man Tabellen sortieren kann gibt's ja genug. Und in VB is sowas eh mit an Bord.


    Link :thumbup:
    Hello World

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

    jo, interessante Anforderung.
    Scheinbar liegt ein 4-dimensionales Kategorisierungs-System vor: Farbe, Form, Gewicht, Preis.
    Und jede Kategorie kann mehrere Werte enthalten.

    Ausserdem liegt eine Abfrage-Grammatik vor:
    + bedeutet "muss enthalten sein" - logisches AND
    ( / ) ist eine Auflistung zulässiger Alternativen - logisches OR
    Werte ohne Klammer entsprechen einer Auflistung mit nur einem Element

    Man kann nun eine Datenmodell der Kategorien anlegen, also 4 Listen, und solch kann man dann auch aus Dateien laden.
    Vermutlich im Datenmodell enthalten sind auch die Artikel, die durch das Kategoriesystem kategorisiert sind.

    Das wäre jdfs besonders einfach, und wohl mal wieder am einfachsten in einem typisierten Dataset zu modellieren.

    Nur der Parser ist eine Herausforderung, da die Grammatik richtig umzusetzen, und auch syntax-widrigen Abfragen abzulehnen.
    Man kann auch einen Abfrage-Assistenten bauen, dem die Kategorien und die möglichen Werte einer jeden bekannt sind, und mit Comboboxen bereitgestellt, dass man von vornherein erst gar keine syntax-widrigen Abfragen zusammenbauen kann.

    Also ich würde empfehlen, zunächstmal in einem typDataset das Datenmodell zu erstellen, und auch schon Haufen Daten einzuspeisen.
    Ob man dann einen Parser baut, oder einen Abfrage-Assistenten kann man dann immer noch überlegen.
    zu typDataset bisserl was zum angugge: vier Views-Videos
    Interessanterweise gibts da ja auch ein Kategorie-System, allerdings ganz primitiv nur eine Kategorie.
    Was das "Abfragen" dann so einfach macht, dass mans garnet mehr als solches erkennt (nämlich ein Parent-Child-View ist eine kategorie-abhängige Abfrage der Artikel)

    Uih - grad nochmal die Filterausdrücke für typDatasets geguckt - also eine geeignete Abfragesprache, die And- und Or-Verknüpfungen unterstützt ist bereits verfügbar!

    EDIT: Erschreckend wie viel Code ich im Gegensatz zur obigen PHP-Version brauche 8|

    Danke für die Antworten, habe beide bis jetzt nur kurz überflogen und noch nicht im Detail durchgearbeitet.

    Falls jemand Interesse hat poste ich hier mal meinen Parser. Ablehnung von widrigen Strings habe ich bis jetzt noch nicht eingebaut (fällt mir komischer Weise am schwersten).

    Die Grammatik hat ErfinderDesRades hier schon richtig aufgezeichnet:
    + bedeutet "muss enthalten sein" - logisches AND
    ( / )ist eine Auflistung zulässiger Alternativen - logisches OR
    Werte ohne Klammer entsprechen einer Auflistung mit nur einem Element
    - bedeutet einen ausschluss - logisches NOT (habe ich im Beispiel nicht aufgeführt)

    Die Funktion habe ich so aufgebaut, dass Sie die ganze Zeichenkette betrachtet, entscheidet welcher Typ vorliegt, auf den entsprechenden Typ reagiert (meistens in Teilzeichenketten zerlegt) und sich selbst erneut aufruft.
    Folgende Typen gibt es:

    ODER - Wie oben beschrieben Auflistung einzelner Attribute
    KLAMMER - Eingeklammerte Zeichenkette, muss aufgelöst werden da auch Klammern mit "-" angeschrieben werden können und sich somit die Vorzeichen der innen liegenden Zeichenketten umdrehen
    MERKMAL- Einzelner Merkmalwert mit/ohne Vorzeichen
    VERKETTUNG - Mix aus den drei oberen Typen

    VB.NET-Quellcode

    1. Protected Friend Function ZeichenketteAnalysieren(ByVal Zeichenkette As String) As List(Of Konfiguration)
    2. Try
    3. Dim lstKonfigurationen As New List(Of Konfiguration)
    4. If Oder(Zeichenkette) = True Then
    5. Dim lstOderZeichenketten As New List(Of String)
    6. lstOderZeichenketten = OderZerlegen(Zeichenkette)
    7. For Each OderZeichenkette As String In lstOderZeichenketten
    8. lstKonfigurationen.AddRange(ZeichenketteAnalysieren(OderZeichenkette))
    9. Next OderZeichenkette
    10. ElseIf Klammer(Zeichenkette) = True Then
    11. Zeichenkette = KlammerEntfernen(Zeichenkette)
    12. lstKonfigurationen = ZeichenketteAnalysieren(Zeichenkette)
    13. ElseIf Merkmal(Zeichenkette) = True Then
    14. lstKonfigurationen.Add(MerkmalAuslesen(Zeichenkette, Me.Merkmalsvorrat))
    15. ElseIf Verkettung(Zeichenkette) = True Then
    16. Dim lstTeilstrings As New List(Of String)
    17. Dim lstKonfigurationenListen As New List(Of List(Of Konfiguration))
    18. lstTeilstrings = VerkettungZerlegen(Zeichenkette)
    19. For Each Teilstring As String In lstTeilstrings
    20. lstKonfigurationenListen.Add(ZeichenketteAnalysieren(Teilstring))
    21. Next Teilstring
    22. lstKonfigurationen = KonfigurationenAusmultiplizieren(lstKonfigurationenListen)
    23. End If
    24. Return lstKonfigurationen
    25. Catch ex As Exception
    26. Throw New ArgumentException(Zeichenkette & " konnte nicht eingelesen werden." & vbCrLf & vbCrLf & ex.Message, ex)
    27. End Try
    28. End Function
    30. ''' <summary>
    31. ''' Prüft ob ein 'ODER' vorliegt
    32. ''' </summary>
    33. ''' <param name="Zeichenkette"></param>
    34. ''' <returns></returns>
    35. ''' <remarks></remarks>
    36. Protected Friend Shared Function Oder(Zeichenkette As String) As Boolean
    37. Dim intAktuelleEbene As Integer = 0
    38. For Each Zeichen As Char In Zeichenkette
    39. If Zeichen = "(" Then : intAktuelleEbene += 1
    40. ElseIf Zeichen = ")" Then : intAktuelleEbene -= 1
    41. ElseIf Zeichen = "/" AndAlso intAktuelleEbene = 0 Then : Return True : End If
    42. Next Zeichen
    43. Return False
    44. End Function
    46. ''' <summary>
    47. ''' Prüft ob eine 'KLAMMER' vorliegt
    48. ''' </summary>
    49. ''' <param name="Zeichenkette"></param>
    50. ''' <returns></returns>
    51. ''' <remarks></remarks>
    52. Protected Friend Shared Function Klammer(Zeichenkette As String) As Boolean
    53. Dim bolBeginn As Boolean = False
    54. Dim intAktuelleEbene As Integer = 0
    55. Dim Zeichen As Char
    56. For Zeichenindex As Integer = 0 To Zeichenkette.Length - 1
    57. Zeichen = Zeichenkette(Zeichenindex)
    58. If {"+", "-", "("}.Contains(Zeichen) = False AndAlso bolBeginn = False Then Return False
    59. If Zeichen = "(" Then bolBeginn = True
    60. If Zeichen = "(" Then intAktuelleEbene += 1
    61. If Zeichen = ")" Then intAktuelleEbene -= 1
    62. If intAktuelleEbene = 0 AndAlso bolBeginn = True AndAlso Zeichenindex < Zeichenkette.Length - 2 Then Return False
    63. Next Zeichenindex
    64. If intAktuelleEbene = 0 Then
    65. Return True
    66. Else
    67. Return False
    68. End If
    69. End Function
    71. ''' <summary>
    72. ''' Prüft ob ein 'Merkmal' vorliegt
    73. ''' </summary>
    74. ''' <param name="Zeichenkette"></param>
    75. ''' <returns></returns>
    76. ''' <remarks></remarks>
    77. Protected Friend Shared Function Merkmal(Zeichenkette As String) As Boolean
    78. For Zeichenindex As Integer = 0 To Zeichenkette.Length - 1
    79. If Zeichenindex > 0 AndAlso {"+", "/", "(", ")"}.Contains(Zeichenkette(Zeichenindex)) Then Return False
    80. Next Zeichenindex
    81. Return True
    82. End Function
    84. ''' <summary>
    85. ''' Prüft ob eine 'VERKETTUNG' vorliegt
    86. ''' </summary>
    87. ''' <param name="Zeichenkette"></param>
    88. ''' <returns></returns>
    89. ''' <remarks></remarks>
    90. Protected Friend Shared Function Verkettung(Zeichenkette As String) As Boolean
    91. If Oder(Zeichenkette) = False AndAlso Klammer(Zeichenkette) = False AndAlso Merkmal(Zeichenkette) = False Then
    92. Return True
    93. Else
    94. Return False
    95. End If
    96. End Function
    98. ''' <summary>
    99. ''' Prüft ob die Klammersetzung der übergebeben Zeichenkette konsistent ist. Löst einen Fehler auf falls die nicht der Fall ist.
    100. ''' </summary>
    101. ''' <param name="Zeichenkette"></param>
    102. ''' <remarks></remarks>
    103. Protected Friend Shared Sub KlammersetzungKontrollieren(Zeichenkette As String)
    104. Dim intEbene As Integer = 0
    105. For Each Zeichen As Char In Zeichenkette
    106. If Zeichen = "(" Then
    107. intEbene += 1
    108. ElseIf Zeichen = ")" Then
    109. intEbene -= 1
    110. End If
    111. Next Zeichen
    112. If intEbene <> 0 Then Throw New ArgumentException("Klammersetzung ist inkonsistent:" & vbCrLf & Zeichenkette)
    113. End Sub
    115. ''' <summary>
    116. ''' Gibt eine Liste von Zeichenketten zurück die durch das übergebene 'ODER' verbunden waren
    117. ''' </summary>
    118. ''' <param name="OderZeichenkette"></param>
    119. ''' <returns></returns>
    120. ''' <remarks></remarks>
    121. Protected Friend Shared Function OderZerlegen(OderZeichenkette As String) As List(Of String)
    122. Try
    123. If BeziehungswissenTerm.Oder(OderZeichenkette) = False Then Throw New ArgumentException("Übergebene Zeichenkette ist kein 'Oder'", "OderZeichenkette")
    124. KlammersetzungKontrollieren(OderZeichenkette)
    125. Dim intEbene As Integer = 0
    126. Dim intAnfangIndex As Integer
    127. Dim intEndeIndex As Integer
    128. Dim lstPositionenOderZeichen As New List(Of Integer)
    129. Dim lstOderStrings As New List(Of String)
    130. For Zeichenindex As Integer = 0 To OderZeichenkette.Length - 1
    131. If OderZeichenkette(Zeichenindex) = "(" Then intEbene += 1
    132. If OderZeichenkette(Zeichenindex) = ")" Then intEbene -= 1
    133. If OderZeichenkette(Zeichenindex) = "/" AndAlso intEbene = 0 Then lstPositionenOderZeichen.Add(Zeichenindex)
    134. Next Zeichenindex
    135. For OderZeichenIndex As Integer = 0 To lstPositionenOderZeichen.Count
    136. If OderZeichenIndex = 0 Then
    137. intAnfangIndex = 0
    138. intEndeIndex = lstPositionenOderZeichen(OderZeichenIndex)
    139. ElseIf OderZeichenIndex = lstPositionenOderZeichen.Count Then
    140. intAnfangIndex = lstPositionenOderZeichen(OderZeichenIndex - 1) + 1
    141. intEndeIndex = OderZeichenkette.Length
    142. Else
    143. intAnfangIndex = lstPositionenOderZeichen(OderZeichenIndex - 1) + 1
    144. intEndeIndex = lstPositionenOderZeichen(OderZeichenIndex)
    145. End If
    146. lstOderStrings.Add(OderZeichenkette.Substring(intAnfangIndex, intEndeIndex - intAnfangIndex))
    147. Next OderZeichenIndex
    148. Return lstOderStrings
    149. Catch ex As Exception
    150. Throw New ArgumentException("Fehler bei Oder-Zerlegung:" & vbCrLf & "Zeichenkette: " & OderZeichenkette & vbCrLf & ex.Message, ex)
    151. End Try
    152. End Function
    154. ''' <summary>
    155. ''' Gibt eine Zeichenkette ohne oberste Klammerebene zurück
    156. ''' </summary>
    157. ''' <param name="KlammerZeichenkette"></param>
    158. ''' <returns></returns>
    159. ''' <remarks></remarks>
    160. Protected Friend Shared Function KlammerEntfernen(ByVal KlammerZeichenkette As String) As String
    161. Try
    162. If BeziehungswissenTerm.Klammer(KlammerZeichenkette) = False Then Throw New ArgumentException("Übergebene Zeichenkette ist keine 'Klammer'", "KlammerZeichenkette")
    163. KlammersetzungKontrollieren(KlammerZeichenkette)
    164. Dim intIndexErsteKlammer As Integer
    165. Dim intAktuelleEbene As Integer = 0
    166. Dim strErsetzenderOperator As String
    167. For Zeichenindex As Integer = 0 To KlammerZeichenkette.Length - 1
    168. If KlammerZeichenkette(Zeichenindex) = "(" Then
    169. intIndexErsteKlammer = Zeichenindex
    170. Exit For
    171. End If
    172. Next Zeichenindex
    173. If intIndexErsteKlammer > 0 AndAlso KlammerZeichenkette(intIndexErsteKlammer - 1) = "-" Then
    174. strErsetzenderOperator = "+-"
    175. Else
    176. strErsetzenderOperator = "+"
    177. End If
    178. For IndexZeichen As Integer = KlammerZeichenkette.Length - 1 To intIndexErsteKlammer + 1 Step -1
    179. If KlammerZeichenkette(IndexZeichen) = "(" Then intAktuelleEbene += 1
    180. If KlammerZeichenkette(IndexZeichen) = ")" Then intAktuelleEbene -= 1
    181. If KlammerZeichenkette(IndexZeichen) = "," Then
    182. KlammerZeichenkette = KlammerZeichenkette.Remove(IndexZeichen, 1)
    183. KlammerZeichenkette = KlammerZeichenkette.Insert(IndexZeichen, strErsetzenderOperator)
    184. End If
    185. Next IndexZeichen
    186. Return KlammerZeichenkette.Substring(intIndexErsteKlammer + 1, KlammerZeichenkette.Length - intIndexErsteKlammer - 2)
    187. Catch ex As Exception
    188. Throw New ArgumentException("Fehler bei Klammer-Zerlegung:" & vbCrLf & "Zeichenkette: " & KlammerZeichenkette & vbCrLf & ex.Message, ex)
    189. End Try
    190. End Function
    192. ''' <summary>
    193. ''' Gibt eine Liste von Zeichenketten zurück die durch eine 'VERKETTUNG' verbunden waren
    194. ''' </summary>
    195. ''' <param name="VerkettungZeichenkette"></param>
    196. ''' <returns></returns>
    197. ''' <remarks></remarks>
    198. Protected Friend Shared Function VerkettungZerlegen(VerkettungZeichenkette As String) As List(Of String)
    199. Try
    200. If BeziehungswissenTerm.Verkettung(VerkettungZeichenkette) = False Then Throw New ArgumentException("Übergebene Zeichenkette ist keine 'Verkettung'", "VerkettungZeichenkette")
    201. KlammersetzungKontrollieren(VerkettungZeichenkette)
    202. Dim intEbene As Integer = 0
    203. Dim intAnfangIndex As Integer
    204. Dim intEndeIndex As Integer
    205. Dim intLaenge As Integer
    206. Dim lstPositionenUndZeichen As New List(Of Integer)
    207. Dim lstUndStrings As New List(Of String)
    209. For Zeichenindex As Integer = 1 To VerkettungZeichenkette.Length - 1
    210. If VerkettungZeichenkette(Zeichenindex) = "(" Then intEbene += 1
    211. If VerkettungZeichenkette(Zeichenindex) = ")" Then intEbene -= 1
    212. If VerkettungZeichenkette(Zeichenindex) = "+" AndAlso intEbene = 0 Then lstPositionenUndZeichen.Add(Zeichenindex)
    213. Next Zeichenindex
    214. For UndZeichenIndex As Integer = 0 To lstPositionenUndZeichen.Count
    215. If UndZeichenIndex = 0 Then
    216. intAnfangIndex = 0
    217. intEndeIndex = lstPositionenUndZeichen(UndZeichenIndex)
    218. intLaenge = intEndeIndex - intAnfangIndex
    219. ElseIf UndZeichenIndex = lstPositionenUndZeichen.Count Then
    220. intAnfangIndex = lstPositionenUndZeichen(UndZeichenIndex - 1)
    221. intEndeIndex = VerkettungZeichenkette.Length
    222. intLaenge = intEndeIndex - intAnfangIndex
    223. Else
    224. intAnfangIndex = lstPositionenUndZeichen(UndZeichenIndex - 1)
    225. intEndeIndex = lstPositionenUndZeichen(UndZeichenIndex)
    226. intLaenge = intEndeIndex - intAnfangIndex
    227. End If
    228. lstUndStrings.Add(VerkettungZeichenkette.Substring(intAnfangIndex, intLaenge))
    229. Next UndZeichenIndex
    230. Return lstUndStrings
    231. Catch ex As Exception
    232. Throw New ArgumentException("Fehler bei Verkettung-Zerlegung:" & vbCrLf & "Zeichenkette: " & VerkettungZeichenkette & vbCrLf & ex.Message, ex)
    233. End Try
    234. End Function
    236. ''' <summary>
    237. ''' Gibt eine Konfiguration zurück die aus dem Merkmal besteht das in der Zeichenkette vorlag
    238. ''' </summary>
    239. ''' <param name="MerkmalZeichenkette"></param>
    240. ''' <returns></returns>
    241. ''' <remarks></remarks>
    242. Friend Shared Function MerkmalAuslesen(MerkmalZeichenkette As String, Merkmalsvorrat As Merkmalsvorrat) As Konfiguration
    243. If BeziehungswissenTerm.Merkmal(MerkmalZeichenkette) = False Then Throw New ArgumentException("Übergebene Zeichenkette ist kein 'Merkmal'", "MerkmalZeichenkette")
    244. KlammersetzungKontrollieren(MerkmalZeichenkette)
    245. Dim Konfiguartion As New Konfiguration
    246. Dim intIndexAnfang As Integer
    247. Dim bolNegation As Boolean
    248. If MerkmalZeichenkette(0) = "+" Then
    249. If MerkmalZeichenkette(1) = "-" Then
    250. intIndexAnfang = 2
    251. bolNegation = True
    252. Else
    253. intIndexAnfang = 1
    254. bolNegation = False
    255. End If
    256. Else
    257. If MerkmalZeichenkette(0) = "-" Then
    258. intIndexAnfang = 1
    259. bolNegation = True
    260. Else
    261. intIndexAnfang = 0
    262. bolNegation = False
    263. End If
    264. End If
    265. Konfiguartion.MerkmalHinzufuegen(Merkmalsvorrat.GetMerkmalObjekt(MerkmalZeichenkette.Substring(intIndexAnfang, MerkmalZeichenkette.Length - intIndexAnfang), bolNegation))
    266. Return Konfiguartion
    267. End Function

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

    aber was sagst du zu meinen weitergehenden Überlegungen, dass deine Grammatik zwar schön und gut ist, dass aber mit DataExpressions bereits eine Grammatik vorliegt, die alles das abdeckt?

    Der Filter-Ausdruck etwa für deine Query in post#1 sähe so aus:
    Farbe in (1,2,3) And Form = 2 And Gewicht in (0,2) And Preis = 3
    Die Zahlen hierbei wären Verweise auf DataRows, die entweder Farben, Formen, Gewichte oder Preise definieren.
    Für einen FilterAusdruck könnte man auch einen Assistenten coden, ich schätze die Gesamt-Geschichte auf vlt 100 Zeilen Code, und dann ist der Filter erstellt und bereits angewendet und du siehst das Filtrat.

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

    Die Grammatik ist bereits über eine recht bekannte Unternehmenssoftware vorgegeben, die Idee kommt nicht von mir. Ich bekomme Strings die so aussehen. Dein Vorschlag ist natürlich sehr viel bequemer zu handlen aber eine Wahl habe ich an dieser Stelle nicht. Einen Parser brauche ich in jedem Fall.

Facebook
Telefonspende