strings.vb

大名鼎鼎的mono是.NET平台的跨平台（支持linux

        Public Function Mid(ByVal str As String, ByVal Start As Integer, ByVal Length As Integer) As String

            If Start <= 0 Then
                Throw New ArgumentException("Argument 'Start' is not a valid value.")
            End If

            If Length < 0 Then
                Throw New ArgumentException("Argument 'Length' is not a valid value.")
            End If

            If str Is Nothing Or str = String.Empty Or Length = 0 Then
                Return String.Empty
            End If

            If Start > str.Length Then
                Return String.Empty
            End If

            If Start + Length > str.Length Then
                Return str.Substring(Start - 1)
            Else
                Return str.Substring(Start - 1, Length)
            End If

        End Function

        Public Function Mid(ByVal str As String, ByVal Start As Integer) As String
            If str Is Nothing Then
                Return Nothing
            End If

            Return Mid(str, Start, str.Length)

        End Function

        Public Function Replace(ByVal Expression As String, ByVal Find As String, ByVal Replacement As String, _
                                Optional ByVal Start As Integer = 1, Optional ByVal Count As Integer = -1, _
                                <OptionCompare()> Optional ByVal Compare As CompareMethod = CompareMethod.Binary) As String
            If Count < -1 Then
                Throw New ArgumentException("Argument 'Count' must be greater than or equal to -1.")
            End If

            If Start <= 0 Then
                Throw New ArgumentException("Argument 'Start' must be greater than zero.")
            End If

            If Expression Is Nothing Or Expression = String.Empty Then
                Return Nothing
            End If

            If Start > Expression.Length Then
                Return Nothing
            End If

            If Find Is Nothing Or Find = String.Empty Then
                Return Expression
            End If

            Expression = Expression.Substring(Start - 1)

            Dim IgnoreCase As Boolean = False
            If Compare = CompareMethod.Text Then
                IgnoreCase = True
            End If

            Return Replace(Expression, Find, Replacement, Start, Count, IgnoreCase)

        End Function

        Private Function Replace(ByVal Expression As String, ByVal Find As String, ByVal Replacement As String, _
                                ByVal Start As Integer, ByVal Count As Integer, ByVal IgnoreCase As Boolean) As String

            Dim replaced As Integer = 0
            Dim current As Integer = 0
            Dim carr() As Char = Expression.ToCharArray()
            Dim sb As StringBuilder = New StringBuilder(Expression.Length)

            While (replaced < Count Or Count = -1) And current < Expression.Length
                Dim res As Integer = String.Compare(Expression, current, Find, 0, Find.Length, IgnoreCase)
                If res = 0 Then
                    sb.Append(Replacement)
                    current = current + Find.Length
                    replaced = replaced + 1
                Else
                    sb.Append(carr(current))
                    current = current + 1
                End If
            End While

            sb.Append(Expression.Substring(current))

            Return sb.ToString()
        End Function


        Public Function Right(ByVal Str As String, ByVal Length As Integer) As String

            If Length < 0 Then
                Throw New ArgumentException("Argument 'Length' must be greater or equal to zero")
            End If

            If Str Is Nothing Or Str = String.Empty Then
                Return String.Empty
            End If

            If Length >= Str.Length Then
                Return Str
            End If

            Return Str.Substring(Str.Length - Length)

        End Function

        Public Function RSet(ByVal Source As String, ByVal Length As Integer) As String
            If Source Is Nothing Then
                Source = String.Empty
            End If

            If Source.Length >= Length Then
                Return Source.Substring(0, Length)
            Else
                Return Source.PadLeft(Length)
            End If
        End Function

        Public Function RTrim(ByVal Str As String) As String
            If Str Is Nothing Then
                Return String.Empty
            End If

            Dim carr() As Char = {" "c}
            Return Str.TrimEnd(carr)
        End Function

        Public Function Space(ByVal Number As Integer) As String
            If Number < 0 Then
                Throw New ArgumentException("Argument 'Number' must be greater or equal to zero.")
            End If

            Select Case Number
                Case 0
                    Return String.Empty
                Case 1
                    Return " "
                Case 2
                    Return "  "
                Case 3
                    Return "   "
                Case 4
                    Return "    "
                Case 5
                    Return "     "
                Case 6
                    Return "      "
                Case 7
                    Return "       "
                Case 8
                    Return "        "
                Case 9
                    Return "         "
                Case 10
                    Return "          "
                Case Else
                    Dim carr(Number - 1) As Char
                    For i As Integer = 0 To Number - 1
                        carr(i) = " "c
                    Next
                    Return New String(carr)
            End Select
        End Function

        Public Function Split(ByVal Expression As String, Optional ByVal Delimiter As String = " ", _
                Optional ByVal Limit As Integer = -1, _
                <OptionCompare()> Optional ByVal Compare As CompareMethod = CompareMethod.Binary) As String()

            If Expression Is Nothing Or Expression = String.Empty Then
                Dim r(0) As String
                r(0) = String.Empty
                Return r
            End If

            If Delimiter Is Nothing Or Delimiter = String.Empty Then
                Dim r(0) As String
                r(0) = Expression
                Return r
            End If

            Dim carr() As Char = Expression.ToCharArray()
            Dim current As Integer = 0
            Dim IgnoreCase As Boolean = False
            If Compare = CompareMethod.Text Then
                IgnoreCase = True
            End If

            If Limit = -1 Then
                Limit = 0
                While current < Expression.Length
                    Dim res As Integer = String.Compare(Expression, current, Delimiter, 0, Delimiter.Length, IgnoreCase)
                    If res = 0 Then
                        current = current + Delimiter.Length
                        Limit = Limit + 1
                    Else
                        current = current + 1
                    End If
                End While
                Limit = Limit + 1
            End If

            Dim sarr(Limit - 1) As String
            Dim count As Integer = 0
            Dim previous As Integer = 0
            current = 0
            While current < Expression.Length And count < Limit - 1
                Dim res As Integer = String.Compare(Expression, current, Delimiter, 0, Delimiter.Length, IgnoreCase)
                If res = 0 Then
                    sarr(count) = Expression.Substring(previous, current - previous)
                    current = current + Delimiter.Length
                    previous = current
                    count = count + 1
                Else
                    current = current + 1
                End If
            End While

            sarr(count) = Expression.Substring(previous)

            ReDim Preserve sarr(count)
            Return sarr

        End Function

        Public Function StrComp(ByVal String1 As String, ByVal String2 As String, _
                        <OptionCompare()> Optional ByVal Compare As CompareMethod = 0) As Integer

            If String1 Is Nothing Then
                String1 = String.Empty
            End If

            If String2 Is Nothing Then
                String2 = String.Empty
            End If

            Dim res As Integer
            If Compare = CompareMethod.Binary Then
                res = String.CompareOrdinal(String1, String2)
            Else
                res = String.Compare(String1, String2, True)
            End If

            If res > 0 Then
                Return 1
            ElseIf res < 0 Then
                Return -1
            Else
                Return 0
            End If

        End Function

        Public Function StrConv(ByVal str As String, _
                                        ByVal Conversion As VbStrConv, _
                                        Optional ByVal LocaleID As Integer = 0) As String

            If str Is Nothing Then
                Throw New ArgumentNullException("Value can not be null.")
            End If

            Select Case Conversion
                Case VbStrConv.None
                    Return str
                Case VbStrConv.UpperCase
                    Return str.ToUpper()
                Case VbStrConv.LowerCase
                    Return str.ToLower()
                Case VbStrConv.ProperCase
                    Dim carr() As Char = str.ToCharArray()
                    Dim inWord As Boolean = False
                    For i As Integer = 0 To carr.Length - 1
#If NET_2_0 Then
                        If (Char.IsLetter(carr(i)) Or carr(i) = "'"c Or Char.IsDigit(carr(i))) Then
#Else
                        If (Char.IsLetter(carr(i)) Or carr(i) = "'"c) Then
#End If

                            If Not inWord Then
                                carr(i) = Char.ToUpper(carr(i))
                            Else
                                carr(i) = Char.ToLower(carr(i))
                            End If
                            inWord = True
                        Else
                            inWord = False
                        End If
                    Next
                    Return New String(carr)
                Case VbStrConv.LinguisticCasing
                    Throw New ArgumentException("'StrConv.LinguisticCasing' requires 'StrConv.LowerCase' or 'StrConv.UpperCase'.")
            End Select

            Throw New NotSupportedException(String.Format("Conversion {0} is not supported yet", Conversion))

        End Function

        Public Function StrDup(ByVal Number As Integer, ByVal Character As Char) As String
            If Character = Nothing Then
                Throw New ArgumentException("Length of argument 'Character' must be greater than zero.")
            End If

            If Number < 0 Then
                Throw New ArgumentException("Argument 'Number' must be greater or equal to zero.")
            End If

            Dim carr(Number - 1) As Char
            For i As Integer = 0 To carr.Length - 1
                carr(i) = Character
            Next

            Return New String(carr)
        End Function

        Public Function StrDup(ByVal Number As Integer, ByVal Character As String) As String
            If Character = Nothing Or Character = String.Empty Then
                Throw New ArgumentException("Length of argument 'Character' must be greater than zero.")
            End If

            Return StrDup(Number, Character.Chars(0))
        End Function

        Public Function StrDup(ByVal Number As Integer, ByVal Character As Object) As Object
            Dim c As Char = "c"c
            Try
                c = DirectCast(Character, Char)
                Return StrDup(Number, c)
            Catch ex As InvalidCastException
            End Try

            Dim s As String = "c"
            Try
                s = DirectCast(Character, String)
                Return StrDup(Number, s)
            Catch ex As InvalidCastException
            End Try

            Throw New ArgumentException("Argument 'Character' is not a valid value.")

        End Function

        Public Function StrReverse(ByVal Expression As String) As String
            If Expression Is Nothing Or Expression = String.Empty Then
                Return String.Empty
            End If

            Dim carr() As Char = Expression.ToCharArray()
            Array.Reverse(carr)
            Return New String(carr)
        End Function

        Public Function Trim(ByVal Str As String) As String
            If Str Is Nothing Then
                Return String.Empty
            End If

            Dim carr() As Char = {" "c}
            Return Str.Trim(carr)
        End Function

        Public Function UCase(ByVal Value As Char) As Char
            Return Char.ToUpper(Value)
        End Function

        Public Function UCase(ByVal Value As String) As String
            If Value Is Nothing Then
                Return String.Empty
            End If

            Return Value.ToUpper()
        End Function
#If NET_2_0 Then
        <CLSCompliant(False)> _
        Public Function Len(ByVal Expression As SByte) As Integer
            Return GetSize(Expression)
        End Function

        <CLSCompliant(False)> _
        Public Function Len(ByVal Expression As UInteger) As Integer
            Return GetSize(Expression)
        End Function

        <CLSCompliant(False)> _
        Public Function Len(ByVal Expression As ULong) As Integer
            Return GetSize(Expression)
        End Function

        <CLSCompliant(False)> _
        Public Function Len(ByVal Expression As UShort) As Integer
            Return GetSize(Expression)
        End Function
#End If

    End Module
End Namespace