PathArgumentsSplitter (Trennt Pfad und eventuelle Argumente in einem String voneinander)

    • VB.NET

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

      PathArgumentsSplitter (Trennt Pfad und eventuelle Argumente in einem String voneinander)

      Hallo liebe Leser. :)

      Hier mein Werk, um Pfad und Argumente aus einem String (z.B. aus der Registry), voneinander zu trennen und als Paar in einer Klasse gespeichert.
      Eventuelle Argumente werden als ein String gespeichert, der bei bedarf zu einem StringArray konvertiert werden kann (Extension ist dabei).

      Kritikpunkte

      RodFromGermany schrieb:

      Allerdings ist die Nebenbedingung, dass die Datei bzw. der Pfad existieren muss, eine sehr einschränkende Nebenbedingung

      Lange Rede, kurzer Sinn, hier der Code:
      PathArgumentsSplitter.vb

      VB.NET-Quellcode

      1. ' Version: 1.0.2.0
      2. #Region "Options ..."
      3. Option Strict On
      4. Option Explicit On
      5. Option Compare Binary
      6. Option Infer Off
      7. #End Region
      8. Imports System.Runtime.CompilerServices
      9. Imports System.Text.RegularExpressions
      10. Imports System.IO
      11. Friend Class PathArgumentsSplitter
      12. Public Enum QuoteOption
      13. None
      14. All
      15. Auto
      16. End Enum
      17. ''' <summary>
      18. ''' Split subString from arguments (all as one string), if subString exist,
      19. ''' store both in data storage class "PathAndArguments()".
      20. ''' </summary>
      21. ''' <param name="_value"></param>
      22. ''' <returns>Data storage class "PathAndArguments()"</returns>
      23. ''' <exception cref="ValidFileOrDirectoryPathNotFoundException"></exception>
      24. Public Shared Function GetPathAndArguments(ByVal _value As String,
      25. ByVal Optional _quoteOption As QuoteOption = QuoteOption.Auto) As PathAndArguments
      26. Dim normalizedString As String = Normalize(_value)
      27. Dim subString As String
      28. ' Pass through "normalizedString" backwards (!) to prevent match a subfolder.
      29. For i As Integer = normalizedString.Length To 3 Step -1
      30. subString = normalizedString.Substring(0, i).TrimEnd
      31. If File.Exists(subString) OrElse Directory.Exists(subString) Then
      32. ' Check if substring "subString" eqals "normalizedString",
      33. ' or a space-char proximate substring "subString".
      34. ' If true, "subString" represent a existing path.
      35. If subString.Equals(normalizedString) OrElse
      36. normalizedString.Substring(subString.Length, 1).Equals(" ") Then
      37. Dim path As String
      38. If _quoteOption = QuoteOption.Auto AndAlso
      39. _value.StartsWith("""") AndAlso
      40. Regex.IsMatch(_value, "\""[^\]\r\n]+""") OrElse
      41. _quoteOption = QuoteOption.All Then
      42. path = Quote(subString)
      43. Else
      44. path = subString
      45. End If
      46. Return New PathAndArguments(path, normalizedString.Replace(subString, String.Empty).Trim)
      47. End If
      48. End If
      49. Next
      50. Throw New ValidFileOrDirectoryPathNotFoundException(
      51. $"No valid file/directory path found in ""{_value}"".")
      52. End Function
      53. ''' <summary>
      54. ''' Remove all """ And expand environment variables.
      55. ''' </summary>
      56. ''' <param name="_value"></param>
      57. ''' <returns>String</returns>
      58. Private Shared Function Normalize(ByVal _value As String) As String
      59. Return Environment.ExpandEnvironmentVariables(_value.Replace("""", String.Empty))
      60. End Function
      61. ''' <summary>
      62. ''' Add a """ char to the beginning and the end of the given string.
      63. ''' </summary>
      64. ''' <param name="_value"></param>
      65. ''' <returns>String</returns>
      66. Private Shared Function Quote(ByVal _value As String) As String
      67. Return $"""{_value}"""
      68. End Function
      69. End Class
      70. ''' <summary>
      71. ''' Data storage.
      72. ''' Property "Path" As String,
      73. ''' Property "Arguments" As String.
      74. ''' </summary>
      75. Public Class PathAndArguments
      76. Public Property Path As String
      77. Public Property Arguments As String
      78. Sub New(ByVal _subString As String, ByVal _arguments As String)
      79. Path = _subString
      80. Arguments = _arguments
      81. End Sub
      82. End Class
      83. ''' <summary>
      84. ''' Thrown if "GetPathAndArguments().subString.Length" is below 3 or,
      85. ''' "GetPathAndArguments().subString" not contain a existing file or folder subString.
      86. ''' </summary>
      87. <Serializable>
      88. Friend Class ValidFileOrDirectoryPathNotFoundException : Inherits Exception
      89. Public Sub New()
      90. End Sub
      91. Public Sub New(_message As String)
      92. MyBase.New(_message)
      93. End Sub
      94. End Class
      95. Public Module StringExtensions
      96. ''' <summary>
      97. ''' Convert a String to StringArray
      98. ''' </summary>
      99. ''' <param name="_value">The given string</param>
      100. ''' <param name="_seperator">Optional seperator as char = " "c</param>
      101. ''' <returns>StringArray</returns>
      102. <Extension>
      103. Public Function ToStringArray(ByVal _value As String, Optional _seperator As Char = " "c) As String()
      104. Return _value.Split(_seperator)
      105. End Function
      106. End Module

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

      @FormFollowsFunction Interessante Lösung.
      Allerdings ist die Nebenbedingung, dass die Datei bzw. der Pfad existieren muss, eine sehr einschränkende Nebenbedingung.
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!
      Ja, das stimmt allerdings, aber in der Regel will man ja was mit dem Ziel anfangen,
      z.b. einen Prozess starten, von daher haut das schon hin, denke ich mal.

      Habe aber noch ein paar Kleinigkeiten gefunden, und dann noch ein paar ...
      Von meiner Seite her, kann es so bleiben und hat die Versionsnummer 1.0.0.0 bekommen.
      ich find, das bricht etwas mit Konventionen.
      Also es ist zwar unbequem, dass man zB in einer Kommandozeile den den Pfad quoten muss, wenn er Spaces enthält. Aber die Regel ist sinnvoll, und die einzige Möglichkeit, die Kommandozeile mit eindeutigem Ergebnis zu parsen.
      Deine trickreiche Methode befreit den User von dieser Unbequemlichkeit - fördert damit aber auch schlechte Angewohnheiten.
      Also bei dir gewöhnt er sich da evtl. eine modifizierte Kommandozeilen-Syntax an, mit der er anderswo dann auf die Nase fällt.
      Ja, da hast du recht, die quotes könnte mann aber auch drin lassen,
      mir ging es konkret darum Process.StartInfo() mit einheitlichen Strings zu füttern.
      Mal gucken, ob ich da noch etwas drann schraube, aber erstmal noch ein Update auf version 1.0.1.0.
      So, habe den letzten Einwand berücksichtigt und nochmal drann rumgeschraubt.
      Anführungszeichen müssen jetzt beachtet und bewust behandelt werden.

      VB.NET-Quellcode

      1. Public Enum QuoteOption
      2. None
      3. All
      4. Auto
      5. End Enum

      Jetzt hat man die Wahl zwischen:
      1. Keine Pfad wird gequotet ausgegeben.
      2. Alle Pfade werden gequotet ausgegeben.
      3. Wenn im QuellString der Pfad gequotet (Anglizísmus sucks :D ) war, dann wir er auch wieder so ausgegeben. (Standardwert)

      Update auf version 1.0.2.0.