vb@rchiv
VB Classic
VB.NET
ADO.NET
VBA
C#
sevAniGif - als kostenlose Vollversion auf unserer vb@rchiv CD Vol.5  
 vb@rchiv Quick-Search: Suche startenErweiterte Suche starten   RSS-Feeds  | Newsletter  | Impressum  | Datenschutz  | vb@rchiv CD Vol.6  | Shop Copyright ©2000-2015
 
zurück
Rubrik: Variablen/Strings   |   VB-Versionen: VB200821.07.08
Zeichenfolgen fester Länge

Extension Methods, die Zeichenfolge bei der Zuweisung auf eine vorgegebene Länge einrichten (für String- und StringBuilder-Variablen)

Autor:   Manfred BohnBewertung:     [ Jetzt bewerten ]Views:  9.503 
ohne HomepageSystem:  Win2k, WinXP, Vista, Win7, Win8, Win10 Beispielprojekt auf CD 

Summer-Special bei Tools & Components!
Gute Laune Sommer bei Tools & Components
Top Summer-Special - Sparen Sie teilweise über 100,- EUR
Alle sev-Entwicklerkomponenten und Komplettpakete jetzt bis zu 25% reduziert!
zum Beispiel:
  • Developer CD nur 455,- EUR statt 569,- EUR
  • sevDTA 2.0 nur 224,30 EUR statt 299,- EUR
  •  
  • vb@rchiv   Vol.6 nur 18,70 EUR statt 24,95 EUR
  • sevCoolbar 3.0 nur 58,70 EUR statt 69,- EUR
  • - Werbung -Und viele weitere Angebote           Aktionspreise nur für kurze Zeit gültig

    Strings fester Länge sind String-Variable, die bei der Zuweisung einer Zeichenfolge dafür sorgen, dass eine vorgegebene Länge eingehalten wird. Zu kurze Zeichenfolgen werden bei der Zuweisung durch Leerzeichen ergänzt, zu lange Zeichenfolgen werden hinten abgeschnitten.

    Einen Variablentyp, der diese Aufgabe automatisch erledigt, gibt es in VB 2008 nicht.

    Relativ einfach ist es, eine Erweiterungsmethode zu erstellen, die bei der Zuweisung die Länge der zugewiesenen Zeichenfolge (auf eine 'gewöhnliche' Stringvariable) gemäß der Vorgabe einrichtet. Die Routine 'FixL' muss, um als 'Extension' zu funktionieren, in ein Standardmodul eingetragen werden.

    In VB gibt es neben String-Variablen auch die Klasse StringBuilder. Instanzen dieser Klasse bewahren eine Zeichenfolge auf und stellen einige Bearbeitungsmethoden zur Verfügung. Sie sind immer dann vorzuziehen, wenn im Programm viele Zeichenfolgen-Manipulationen vorgenommen werden, weil sie einen festen Speicherbereich verwalten, der nur bei Bedarf erweitert wird. String-Variablen beherrschen das nicht. Bei ihnen muss nach jeder Änderung die enthaltene Zeichenfolge in einem neuen Speicherbereich erstellt werden.

    Zu beachten ist auch, dass Stringbuilder-Variable Instanzen einer Klasse sind; d.h. als Parameter werden sie immer 'By Reference' übergeben - also als Zeiger auf den aktuell zugeordneten Speicherbereich. (Die Verwendung des 'Default'-Schlüsselworts 'ByVal' hat in diesem Fall keine Auswirkungen). Anders verhalten sich String-Variable. Die gelten zwar auch als Referenztypen ('spezielle Verwaltung'), können aber durch 'ByVal'-Übergabe im rufenden Code vor dem Überschreiben geschützt werden.

    Das Modul 'modStringFix' enthält 'Extensions' für String und StringBuilder-Variablen und ermöglicht wechselseitige Zeichenfolgen-Zuweisungen - als 'Function' und als 'Sub' unter Beachtung einer als Parameter vorgegebenen Länge.

    Die Routine 'Demo_StringFix' demonstriert die Anwendung.
    Man beachte, dass 'Extensions' auch dann aufgerufen werden können, wenn die Variable auf 'Nothing' zeigt.

    Module modStringFix
     
      Public Sub demo_stringfix()
     
        Const TheString As String = "teststring-und mehr"
     
        ' fixe Länge der Ziel-Strings
        Const FL As Integer = 10
     
        ' String-Variable (Quelle und Ziel)
        Dim qs As String = TheString
        Dim zs As String = ""
     
        ' StringBuilder-Variable (Quelle und Ziel)
        Dim qstb As New System.Text.StringBuilder(TheString)
        Dim zstb As System.Text.StringBuilder
     
        ' String --> String (FixL)
        zs = Nothing
        zs.FixL(qs, FL)
        zs = Nothing
        zs = qs.FixL(FL)
     
        ' StringBuilder --> StringBuilder (FixL)
        zstb = qstb.FixL(FL)
        zstb.FixL(qstb, FL)
     
        ' StringBuilder --> String (FixS)
        zs.FixS(qstb, FL)
        zs = qstb.FixS(FL)
     
        ' String --> StringBuilder (FixS)
        zstb = qs.FixS(FL)
        zstb.FixS(qs, FL)
     
        ' Die Quell-Variablen dürfen nicht verändert sein
        If qs <> TheString Then Stop
        If qstb.ToString <> TheString Then Stop
     
      End Sub
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="str">Der zuzuweisende String</param>
      ''' <param name="FixLength">Länge des String</param>
      ''' <returns>String fester Länge</returns>
      <System.Runtime.CompilerServices.Extension()> _
      Public Function FixL(ByVal str As String, _
        Optional ByVal FixLength As Integer = 15) As String
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
     
        Dim Add As Integer = FixLength - Microsoft.VisualBasic.Len(str)
        If Add > 0 Then
          Return str & Microsoft.VisualBasic.Space(Add)
        Else
          Return Microsoft.VisualBasic.Left(str, FixLength)
        End If
      End Function
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="str">Der zuzuweisende String</param>
      ''' <param name="FixLength">Länge des String</param>
      ''' <returns>String fester Länge</returns>
      <System.Runtime.CompilerServices.Extension()> _
      Public Function FixS(ByVal str As String, _
        Optional ByVal FixLength As Integer = 15) As System.Text.StringBuilder
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
        Dim Add As Integer = FixLength - Microsoft.VisualBasic.Len(str)
        If Add > 0 Then
          str &= Microsoft.VisualBasic.Space(Add)
        Else
          str = Microsoft.VisualBasic.Left(str, FixLength)
        End If
        Return New System.Text.StringBuilder(str)
      End Function
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="stb">Der zuzuweisende String</param>
      ''' <param name="FixLength">Länge des String</param>
      ''' <returns>String fester Länge</returns>
      <System.Runtime.CompilerServices.Extension()> _
      Public Function FixL(ByVal stb As System.Text.StringBuilder, _
        Optional ByVal FixLength As Integer = 15) As System.Text.StringBuilder
     
        Dim ret As New System.Text.StringBuilder
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
     
        Dim l As Integer = 0
        If Not IsNothing(stb) Then
          ret = New System.Text.StringBuilder( _
            stb.ToString, 0, stb.Length, FixLength)
        Else
          ret = New System.Text.StringBuilder(FixLength)
        End If
     
        Dim Add As Integer = FixLength - ret.Length
        If Add > 0 Then
          ret.Append(Microsoft.VisualBasic.Space(Add))
        Else
          ret.Length = FixLength
        End If
        Return ret
      End Function
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="stb">Der zuzuweisende String</param>
      ''' <param name="FixLength">Länge des String</param>
      ''' <returns>String fester Länge</returns>
      <System.Runtime.CompilerServices.Extension()> _
      Public Function FixS(ByVal stb As System.Text.StringBuilder, _
        Optional ByVal FixLength As Integer = 15) As String
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
     
        Dim ret As String
        Dim l As Integer = 0
        If Not IsNothing(stb) Then
          l = stb.Length
          ret = stb.ToString
        Else
          ret = ""
        End If
     
        Dim Add As Integer = FixLength - l
        If Add > 0 Then
          Return ret & Microsoft.VisualBasic.Space(Add)
        Else
          Return Microsoft.VisualBasic.Left(ret, FixLength)
        End If
      End Function
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="str">Die Stringvariable, auf die zugewiesen wird</param>
      ''' <param name="val">Die zuzuweisende Zeichenfolge</param>
      ''' <param name="FixLength">geforderte Länge der Zeichenfolge</param>
      <System.Runtime.CompilerServices.Extension()> _
      Public Sub FixL(ByRef str As String, _
        ByVal val As String, _
        Optional ByVal FixLength As Integer = 15)
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
     
        Dim Add As Integer = FixLength - Microsoft.VisualBasic.Len(val)
        If Add > 0 Then
          str = val & Microsoft.VisualBasic.Space(Add)
        Else
          str = Microsoft.VisualBasic.Left(val, FixLength)
        End If
      End Sub
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="str">Die Stringvariable, auf die zugewiesen wird</param>
      ''' <param name="val">Die zuzuweisende Zeichenfolge</param>
      ''' <param name="FixLength">Länge des String</param>
      <System.Runtime.CompilerServices.Extension()> _
      Public Sub FixS(ByRef str As String, _
        ByVal val As System.Text.StringBuilder, _
        Optional ByVal FixLength As Integer = 15)
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
     
        str = ""
        Dim Add As Integer = FixLength - val.Length
        If Add > 0 Then
          val.Append(Microsoft.VisualBasic.Space(Add))
          str = val.ToString
        Else
          str = Microsoft.VisualBasic.Left( _
          val.ToString, FixLength)
        End If
      End Sub
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="stb">Die Stringbuilder-Variable, 
      ''' auf die zugewiesen wird</param>
      ''' <param name="val">Die zuzuweisende Zeichenfolge</param>
      ''' <param name="FixLength">Länge des String</param>
      <System.Runtime.CompilerServices.Extension()> _
      Public Sub FixL(ByRef stb As System.Text.StringBuilder, _
        ByVal val As System.Text.StringBuilder, _
        Optional ByVal FixLength As Integer = 15)
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
     
        Dim l As Integer = 0
        If Not IsNothing(val) Then
          l = val.Length
          stb = New System.Text.StringBuilder(val.ToString)
        Else
          stb = New System.Text.StringBuilder(FixLength)
        End If
     
        Dim Add As Integer = FixLength - l
        If Add > 0 Then
          stb.Append(Microsoft.VisualBasic.Space(Add))
        Else
          stb.Length = FixLength
        End If
      End Sub
      ''' <summary>
      ''' Zuweisung eines Strings fester Länge
      ''' </summary>
      ''' <param name="stb">Die Stringbuilder-Variable, 
      ''' auf die zugewiesen wird</param>
      ''' <param name="val">Die zuzuweisende Zeichenfolge</param>
      ''' <param name="FixLength">Länge des String</param>
      <System.Runtime.CompilerServices.Extension()> _
      Public Sub FixS(ByRef stb As System.Text.StringBuilder, _
        ByVal val As String, _
        Optional ByVal FixLength As Integer = 15)
     
        If FixLength < 1 Or FixLength > 1024 Then
          Throw New ArgumentException
        End If
     
        Dim l As Integer = 0
        If Not IsNothing(val) Then
          l = Len(val)
          stb = New System.Text.StringBuilder(val)
        Else
          stb = New System.Text.StringBuilder(FixLength)
        End If
     
        Dim Add As Integer = FixLength - l
        If Add > 0 Then
          stb.Append(Microsoft.VisualBasic.Space(Add))
        Else
          stb.Length = FixLength
        End If
      End Sub
    End Module

    Hinweis für VB6-Umsteiger:
    Wenn Sie sich jetzt wundern, liegen Sie richtig. Es ist auch noch folgendes zu beachten:

    • Die in String-Variablen enthaltenen Zeichenfolgen sind in den aktuellen VB-Versionen grundsätzlich 'unveränderlich'. Jedes Anhängen, Verkürzen oder Überschreiben führt dazu, dass eine neue Zeichenfolge im Speicher erstellt wird.
       
    • Programme, die zahl- und umfangreiche String-Operationen durchführen, müssen deshalb nach der Umstellung auf VB 2008 eventuell überarbeitet werden (Verwendung der StringBuilder-Klasse).
       
    • Die vom Upgrade-Assistenten vorgenommene Umstellung der Strings fester Länge auf Instanzen der Kompatibilitäts-Klasse 'FixedLengthString' macht speziell in benutzerdefinierten Datentypen (umgestellt zu: Structures) Probleme. Sie müssen jetzt nach der Definition einer Struktur explizit initialisiert werden.
       
    • Es kann im Einzelfall günstig sein, die Variablen des Typs 'String fester Länge' auf String- oder StringBuilder-Variablen umzustellen und dann bei den Zuweisungen die 'FixL'-Methode einzusetzen. Die Notwendigkeit der Initialisierung entfällt dann.

    Das unterschiedliche Verhalten im Einzelnen:

    Structure StrucTest
      ' Konstanten sind in Structures "shared"
      Public Const Length As Integer = 13
      Dim Ordinärer_String As String
      Dim Fixed_String As VB6.FixedLengthString
    End Structure
     
    Public Sub demo_strucfix()
      Dim aaa As New StrucTest
     
      ' Eine einfache String-Variable muss nicht 
      ' initialisiert werden, benötigt aber Längenangabe 
      aaa.Ordinärer_String.FixL("Zeichenfolge, aber zu lang", StrucTest.Length)
     
      ' Eine Klassen-Instanz muss zunächst initialisiert werden 
      aaa.Fixed_String = New VB6.FixedLengthString(StrucTest.Length)
      aaa.Fixed_String.Value = "netter String, aber zu lang"
     
      ' Zuweisung auf eine zweite Instanz der Struktur 
      Dim bbb As StrucTest
      bbb = aaa
     
      ' Neuzuweisung einer Zeichenfolge auf 'bbb'-Member
     
      ' Bei einer einfachen Stringvariable wird die
      ' Referenz auf 'aaa'-Member bei Neuzuweisung aufgelöst
      bbb.Ordinärer_String.FixL("neue Zeichen", StrucTest.Length)
     
      ' Da FixedStringLength eine Klasse ist,
      ' handelt es sich um eine Referenz 
      ' (---> 'aaa'-Member wird ebenfalls geändert)
      bbb.Fixed_String.Value = "neue Zeichen"
    End Sub

    Dieser Tipp wurde bereits 9.503 mal aufgerufen.

    Voriger Tipp   |   Zufälliger Tipp   |   Nächster Tipp

    Über diesen Tipp im Forum diskutieren
    Haben Sie Fragen oder Anregungen zu diesem Tipp, können Sie gerne mit anderen darüber in unserem Forum diskutieren.

    Neue Diskussion eröffnen

    nach obenzurück


    Anzeige

    Kauftipp Unser Dauerbrenner!Diesen und auch alle anderen Tipps & Tricks finden Sie auch auf unserer aktuellen vb@rchiv  Vol.6
    (einschl. Beispielprojekt!)

    Ein absolutes Muss - Geballtes Wissen aus mehr als 8 Jahren vb@rchiv!
    - nahezu alle Tipps & Tricks und Workshops mit Beispielprojekten
    - Symbol-Galerie mit mehr als 3.200 Icons im modernen Look
    Weitere Infos - 4 Entwickler-Vollversionen (u.a. sevFTP für .NET), Online-Update-Funktion u.v.m.
     
       

    Druckansicht Druckansicht Copyright ©2000-2015 vb@rchiv Dieter Otter
    Alle Rechte vorbehalten.
    Microsoft, Windows und Visual Basic sind entweder eingetragene Marken oder Marken der Microsoft Corporation in den USA und/oder anderen Ländern. Weitere auf dieser Homepage aufgeführten Produkt- und Firmennamen können geschützte Marken ihrer jeweiligen Inhaber sein.

    Diese Seiten wurden optimiert für eine Bildschirmauflösung von mind. 1280x1024 Pixel