StringBuilderExtensions

    • VB.NET

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

      StringBuilderExtensions

      Hallo.

      Microsoft hat uns ja mit dem StringBuilder eine performante Alternative zu normalen Strings gegeben. Leider findet sie (zumindest bei mir) nicht sehr oft den Einsatz, da einige wesentliche Funktionen von Strings fehlen. Da ich gerade nichts anderes zu tun hatte, habe ich da mal Abhilfe geschafft. Im Folgenden findet ihr eine ganze Reihe von Extension-Methoden, die von Strings bekannte Operationen auf einem StringBuilder durchführen.

      VB

      VB.NET-Quellcode

      1. Imports System.Collections.Generic
      2. Imports System.Linq
      3. Imports System.Text
      4. Imports System.Threading.Tasks
      5. Imports System.Runtime.CompilerServices
      6. Namespace Artentus
      7. Namespace Utils
      8. Namespace StringBuilderExtensions
      9. Public Module Extensions
      10. <System.Runtime.CompilerServices.Extension> _
      11. Public Shared Function StartsWith(sb As StringBuilder, value As String) As Boolean
      12. If sb.Length < value.Length Then
      13. Return False
      14. End If
      15. For i As Integer = 0 To charsSb.Length - 1
      16. If sb(i) <> value(i) Then
      17. Return False
      18. End If
      19. Next
      20. Return True
      21. End Function
      22. <System.Runtime.CompilerServices.Extension> _
      23. Public Shared Function StartsWith(sb As StringBuilder, value As Char) As Boolean
      24. Return sb.Length > 0 AndAlso sb(0) = value
      25. End Function
      26. <System.Runtime.CompilerServices.Extension> _
      27. Public Shared Function EndsWith(sb As StringBuilder, value As String) As Boolean
      28. If sb.Length < value.Length Then
      29. Return False
      30. End If
      31. For i As Integer = 0 To charsSb.Length - 1
      32. If charsSb((sb.Length - value.Length) + i) <> value(i) Then
      33. Return False
      34. End If
      35. Next
      36. Return True
      37. End Function
      38. <System.Runtime.CompilerServices.Extension> _
      39. Public Shared Function EndsWith(sb As StringBuilder, value As Char) As Boolean
      40. Return sb.Length > 0 AndAlso sb(sb.Length - 1) = value
      41. End Function
      42. <System.Runtime.CompilerServices.Extension> _
      43. Public Shared Function IndexOf(sb As StringBuilder, value As String, startIndex As Integer, count As Integer) As Integer
      44. Dim maxIndex = Math.Min(sb.Length - value.Length, startIndex + count)
      45. For i As Integer = startIndex To maxIndex - 1
      46. Dim found = True
      47. For j As Integer = 0 To value.Length - 1
      48. If sb(i + j) <> value(j) Then
      49. found = False
      50. Exit For
      51. End If
      52. Next
      53. If found Then
      54. Return i
      55. End If
      56. Next
      57. Return -1
      58. End Function
      59. <System.Runtime.CompilerServices.Extension> _
      60. Public Shared Function IndexOf(sb As StringBuilder, value As Char, startIndex As Integer, count As Integer) As Integer
      61. Dim maxIndex = Math.Min(sb.Length, startIndex + count)
      62. For i As Integer = startIndex To maxIndex - 1
      63. If sb(i) = value Then
      64. Return i
      65. End If
      66. Next
      67. Return -1
      68. End Function
      69. <System.Runtime.CompilerServices.Extension> _
      70. Public Shared Function IndexOf(sb As StringBuilder, value As String, startIndex As Integer) As Integer
      71. Return sb.IndexOf(value, startIndex, sb.Length - startIndex)
      72. End Function
      73. <System.Runtime.CompilerServices.Extension> _
      74. Public Shared Function IndexOf(sb As StringBuilder, value As Char, startIndex As Integer) As Integer
      75. Return sb.IndexOf(value, startIndex, sb.Length - startIndex)
      76. End Function
      77. <System.Runtime.CompilerServices.Extension> _
      78. Public Shared Function IndexOf(sb As StringBuilder, value As String) As Integer
      79. Return sb.IndexOf(value, 0, sb.Length)
      80. End Function
      81. <System.Runtime.CompilerServices.Extension> _
      82. Public Shared Function IndexOf(sb As StringBuilder, value As Char) As Integer
      83. Return sb.IndexOf(value, 0, sb.Length)
      84. End Function
      85. <System.Runtime.CompilerServices.Extension> _
      86. Public Shared Function LastIndexOf(sb As StringBuilder, value As String, startIndex As Integer, count As Integer) As Integer
      87. Dim minIndex = Math.Min(-1, startIndex - count)
      88. For i As Integer = startIndex To minIndex + 1 Step -1
      89. Dim found = True
      90. For j As Integer = 0 To value.Length - 1
      91. If sb(i + j) <> value(j) Then
      92. found = False
      93. Exit For
      94. End If
      95. Next
      96. If found Then
      97. Return i
      98. End If
      99. Next
      100. Return -1
      101. End Function
      102. <System.Runtime.CompilerServices.Extension> _
      103. Public Shared Function LastIndexOf(sb As StringBuilder, value As Char, startIndex As Integer, count As Integer) As Integer
      104. Dim minIndex = Math.Max(-1, startIndex - count)
      105. For i As Integer = startIndex To minIndex + 1 Step -1
      106. If sb(i) = value Then
      107. Return i
      108. End If
      109. Next
      110. Return -1
      111. End Function
      112. <System.Runtime.CompilerServices.Extension> _
      113. Public Shared Function LastIndexOf(sb As StringBuilder, value As String, startIndex As Integer) As Integer
      114. Return sb.LastIndexOf(value, startIndex, sb.Length - startIndex)
      115. End Function
      116. <System.Runtime.CompilerServices.Extension> _
      117. Public Shared Function LastIndexOf(sb As StringBuilder, value As Char, startIndex As Integer) As Integer
      118. Return sb.LastIndexOf(value, startIndex, sb.Length - startIndex)
      119. End Function
      120. <System.Runtime.CompilerServices.Extension> _
      121. Public Shared Function LastIndexOf(sb As StringBuilder, value As String) As Integer
      122. Return sb.LastIndexOf(value, 0, sb.Length)
      123. End Function
      124. <System.Runtime.CompilerServices.Extension> _
      125. Public Shared Function LastIndexOf(sb As StringBuilder, value As Char) As Integer
      126. Return sb.LastIndexOf(value, 0, sb.Length)
      127. End Function
      128. <System.Runtime.CompilerServices.Extension> _
      129. Public Shared Function PadLeft(sb As StringBuilder, totalWidth As Integer, paddingChar As Char) As StringBuilder
      130. While sb.Length < totalWidth
      131. sb.Insert(0, paddingChar)
      132. End While
      133. Return sb
      134. End Function
      135. <System.Runtime.CompilerServices.Extension> _
      136. Public Shared Function PadLeft(sb As StringBuilder, totalWidth As Integer) As StringBuilder
      137. Return sb.PadLeft(totalWidth, " "C)
      138. End Function
      139. <System.Runtime.CompilerServices.Extension> _
      140. Public Shared Function PadRight(sb As StringBuilder, totalWidth As Integer, paddingChar As Char) As StringBuilder
      141. While sb.Length < totalWidth
      142. sb.Append(paddingChar)
      143. End While
      144. Return sb
      145. End Function
      146. <System.Runtime.CompilerServices.Extension> _
      147. Public Shared Function PadRight(sb As StringBuilder, totalWidth As Integer) As StringBuilder
      148. Return sb.PadRight(totalWidth, " "C)
      149. End Function
      150. <System.Runtime.CompilerServices.Extension> _
      151. Public Shared Function SubString(sb As StringBuilder, startIndex As Integer, length As Integer) As StringBuilder
      152. Dim newSb = New StringBuilder(length - startIndex)
      153. Dim chars = New Char(length - 1) {}
      154. sb.CopyTo(startIndex, chars, 0, length)
      155. newSb.Append(chars)
      156. Return newSb
      157. End Function
      158. <System.Runtime.CompilerServices.Extension> _
      159. Public Shared Function SubString(sb As StringBuilder, startIndex As Integer) As StringBuilder
      160. Return sb.SubString(startIndex, sb.Length - startIndex)
      161. End Function
      162. <System.Runtime.CompilerServices.Extension> _
      163. Public Shared Function TrimStart(sb As StringBuilder, trimChar As Char) As StringBuilder
      164. While sb.StartsWith(trimChar)
      165. sb.Remove(0, 1)
      166. End While
      167. Return sb
      168. End Function
      169. <System.Runtime.CompilerServices.Extension> _
      170. Public Shared Function TrimEnd(sb As StringBuilder, trimChar As Char) As StringBuilder
      171. While sb.EndsWith(trimChar)
      172. sb.Remove(sb.Length - 1, 1)
      173. End While
      174. Return sb
      175. End Function
      176. <System.Runtime.CompilerServices.Extension> _
      177. Public Shared Function Trim(sb As StringBuilder, trimChar As Char) As StringBuilder
      178. While sb.StartsWith(trimChar)
      179. sb.Remove(0, 1)
      180. End While
      181. While sb.EndsWith(trimChar)
      182. sb.Remove(sb.Length - 1, 1)
      183. End While
      184. Return sb
      185. End Function
      186. <System.Runtime.CompilerServices.Extension> _
      187. Public Shared Function ToCharArray(sb As StringBuilder) As Char()
      188. Dim chars = New Char(sb.Length - 1) {}
      189. sb.CopyTo(0, chars, 0, sb.Length)
      190. Return chars
      191. End Function
      192. <System.Runtime.CompilerServices.Extension> _
      193. Public Shared Function Replace(sb As StringBuilder, oldString As String, newString As String) As StringBuilder
      194. For i As Integer = sb.Length - oldString.Length To -1 + 1 Step -1
      195. If sb.SubString(i).StartsWith(oldString) Then
      196. sb.Remove(i, oldString.Length)
      197. sb.Insert(i, newString)
      198. End If
      199. Next
      200. Return sb
      201. End Function
      202. <System.Runtime.CompilerServices.Extension> _
      203. Public Shared Function Replace(sb As StringBuilder, oldChar As Char, newChar As Char) As StringBuilder
      204. For i As Integer = 0 To sb.Length - 1
      205. If sb(i) = oldChar Then
      206. sb(i) = newChar
      207. End If
      208. Next
      209. Return sb
      210. End Function
      211. <System.Runtime.CompilerServices.Extension> _
      212. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of String), count As Integer, options As StringSplitOptions) As StringBuilder()
      213. Dim parts = New List(Of StringBuilder)()
      214. Dim i = 0
      215. While i < sb.Length
      216. If count > -1 AndAlso count = parts.Count Then
      217. Exit While
      218. End If
      219. Dim builder = New StringBuilder()
      220. parts.Add(builder)
      221. While i < sb.Length
      222. Dim foundEnd = False
      223. For Each separator As var In separators
      224. If (i + separator.Length < sb.Length) AndAlso sb.SubString(i, separator.Length).StartsWith(separator) Then
      225. i += separator.Length
      226. foundEnd = True
      227. Exit For
      228. End If
      229. Next
      230. If Not foundEnd Then
      231. builder.Append(sb(i))
      232. i += 1
      233. End If
      234. End While
      235. End While
      236. Dim result = New List(Of StringBuilder)()
      237. For Each part As var In parts
      238. If Not ((options = StringSplitOptions.RemoveEmptyEntries) AndAlso (part.Length = 0)) Then
      239. result.Add(part)
      240. End If
      241. Next
      242. Return result.ToArray()
      243. End Function
      244. <System.Runtime.CompilerServices.Extension> _
      245. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of Char), count As Integer, options As StringSplitOptions) As StringBuilder()
      246. Dim parts = New List(Of StringBuilder)()
      247. Dim i = 0
      248. While i < sb.Length
      249. If count > -1 AndAlso count = parts.Count Then
      250. Exit While
      251. End If
      252. Dim builder = New StringBuilder()
      253. parts.Add(builder)
      254. While i < sb.Length
      255. Dim foundEnd = False
      256. For Each separator As var In separators
      257. If (i + 1 < sb.Length) AndAlso (sb.SubString(i, 1)(0) = separator) Then
      258. i += 1
      259. foundEnd = True
      260. Exit For
      261. End If
      262. Next
      263. If Not foundEnd Then
      264. builder.Append(sb(i))
      265. i += 1
      266. End If
      267. End While
      268. End While
      269. Dim result = New List(Of StringBuilder)()
      270. For Each part As var In parts
      271. If Not ((options = StringSplitOptions.RemoveEmptyEntries) AndAlso (part.Length = 0)) Then
      272. result.Add(part)
      273. End If
      274. Next
      275. Return result.ToArray()
      276. End Function
      277. <System.Runtime.CompilerServices.Extension> _
      278. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of String)) As StringBuilder()
      279. Return sb.Split(separators, -1, StringSplitOptions.None)
      280. End Function
      281. <System.Runtime.CompilerServices.Extension> _
      282. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of Char)) As StringBuilder()
      283. Return sb.Split(separators, -1, StringSplitOptions.None)
      284. End Function
      285. <System.Runtime.CompilerServices.Extension> _
      286. Public Shared Function Split(sb As StringBuilder, separator As String) As StringBuilder()
      287. Return sb.Split(New String() {separator}, -1, StringSplitOptions.None)
      288. End Function
      289. <System.Runtime.CompilerServices.Extension> _
      290. Public Shared Function Split(sb As StringBuilder, separator As Char) As StringBuilder()
      291. Return sb.Split(New Char() {separator}, -1, StringSplitOptions.None)
      292. End Function
      293. End Class
      294. End Namespace
      295. End Namespace
      296. End Namespace


      C#
      Der C#-Code hat leider nicht mehr in den Post gepasst. Ich werde ihn noch nachreichen.


      Ich habe die Funktionen nicht alle getestet, weswegen sie möglicherweise kleine Fehler enthalten könnten (glaub ich zwar nicht, ich schreibs aber lieber mal dazu).
      Außerdem ist der VB-Code nur aus dem C#-Code konvertiert und ich weiß nicht, ob der Converter richtig gearbeitet hat (wenn euch was auffällt sagts mir bitte).

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

      Artentus schrieb:

      Außerdem ist der VB-Code nur aus dem C#-Code konvertiert und ich weiß nicht, ob der Converter richtig gearbeitet hat

      hmm hmm - findich schwach.
      Hättest mindestens einmal deine Extensions in ein VB-Projekt einbinden können, und lernen, welche Unterschiede zw. c#-Extensions und vb-Extensions bestehen.
      Also lauffähig sollte schon sein, was hier eingestellt wird.

      :(

      Und was soll dashier?

      VB.NET-Quellcode

      1. <System.Runtime.CompilerServices.Extension()> _
      2. Public Function StartsWith(sb As StringBuilder, value As Char) As Boolean
      3. If sb.Length < 1 Then
      4. Return False
      5. End If
      6. Dim charsSb = New Char(0) {}
      7. sb.CopyTo(0, charsSb, 0, 1)
      8. Return value = charsSb(0)
      9. End Function
      Das gehört doch wohl so:

      VB.NET-Quellcode

      1. <System.Runtime.CompilerServices.Extension()> _
      2. Public Function StartsWith(sb As StringBuilder, value As Char) As Boolean
      3. Return sb.Length > 0 AndAlso sb(0) = value
      4. End Function
      Benchmarks dazu: (höhere Werte sind schneller)

      Quellcode

      1. Artentus:
      2. string: 26393
      3. StringBuilder: 58972
      4. Edr:
      5. string: 26718
      6. StringBuilder: 145064


      Oder guggemol meine Verbesserung von

      VB.NET-Quellcode

      1. <System.Runtime.CompilerServices.Extension()> _
      2. Public Function StartsWith(sb As StringBuilder, value As String) As Boolean
      3. If sb.Length < value.Length Then
      4. Return False
      5. End If
      6. Dim charsSb = New Char(value.Length - 1) {}
      7. sb.CopyTo(0, charsSb, 0, value.Length)
      8. Dim charsS = value.ToCharArray()
      9. For i As Integer = 0 To charsSb.Length - 1
      10. If charsSb(i) <> charsS(i) Then
      11. Return False
      12. End If
      13. Next
      14. Return True
      15. End Function
      zu

      VB.NET-Quellcode

      1. <System.Runtime.CompilerServices.Extension()> _
      2. Public Function StartsWith(sb As StringBuilder, value As String) As Boolean
      3. Return sb.Length >= value.Length AndAlso sb.ToString(0, value.Length) = value
      4. End Function


      Benchmarks:

      Quellcode

      1. artentus:
      2. string: 7916
      3. StringBuilder: 9379
      4. stresstest edr:
      5. string: 7810
      6. StringBuilder: 19486


      also sb.Tostring scheint so schnell zu sein, dass man die String-Operationen, die dem SB zu fehlen scheinen, wohl besser einheitlich über

      VB.NET-Quellcode

      1. sb.Tostring().<DasFehlende>
      laufen lässt, statt Funktionalität selbst nachzuprogrammieren versuchen.

      ach - ich glaub schon deine Grundannahme ist fragwürdig:
      Leider findet Stringbuilder (zumindest bei mir) nicht sehr oft den Einsatz...
      wieso leider?
      Stringbuilder ist ein Instrument zur Performance-Optimierung bei String-Verkettungen.
      Beim Optimieren soll man sich immer möglichst zurückhalten, also was sollte dazu drängen, sb zu benutzen?
      Weiters kann man mit String.Concat und String.Join ebenfalls hervorragend performant Strings verketten.
      Ich mach mir lieber eine List(Of Object), und da schmeiß ich alles rein, was ich verketten möchte, und am Ende mit String.Concat(liste) in die Ausgabe.
      Bzw. ich nutze meine String.And - Extension, weilich String.Concat als statische Methode ziemlich blöde finde - AufrufBeispiel:

      VB.NET-Quellcode

      1. Public ReadOnly Property DebugInfo() As String
      2. Get
      3. Return "Count: ".And(Count, ", BindID: ", BindingSource.BindID)
      4. Return String.Concat("Count: ", Count, ", BindID: ", BindingSource.BindID)
      5. Return "Count: " & Count & ", BindID: " & BindingSource.BindID
      6. End Get
      7. End Property
      Das rührt einen String, einen Integer, nochmal einen String und wieder einen Integer zusammen. (Zeilen #4 + #5 sind äquivalente .Net-Bordmittel)

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

      Also hier erstmal der C#-Code, der sollte auf jeden Fall funktionieren:
      Spoiler anzeigen

      C-Quellcode

      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Text;
      5. using System.Threading.Tasks;
      6. using System.Runtime.CompilerServices;
      7. namespace Artentus
      8. {
      9. namespace Utils
      10. {
      11. namespace StringBuilderExtensions
      12. {
      13. public static class Extensions
      14. {
      15. public static bool StartsWith(this StringBuilder sb, string value)
      16. {
      17. if (sb.Length < value.Length)
      18. return false;
      19. for (int i = 0; i < value.Length; i++)
      20. if (sb[i] != value[i])
      21. return false;
      22. return true;
      23. }
      24. public static bool StartsWith(this StringBuilder sb, char value)
      25. {
      26. return sb.Length > 0 && sb[0] == value;
      27. }
      28. public static bool EndsWith(this StringBuilder sb, string value)
      29. {
      30. if (sb.Length < value.Length)
      31. return false;
      32. for (int i = 0; i < value.Length; i++)
      33. if (sb[(sb.Length - value.Length) + i] != value[i])
      34. return false;
      35. return true;
      36. }
      37. public static bool EndsWith(this StringBuilder sb, char value)
      38. {
      39. return sb.Length > 0 && sb[sb.Length - 1] == value;
      40. }
      41. public static int IndexOf(this StringBuilder sb, string value, int startIndex, int count)
      42. {
      43. var maxIndex = Math.Min(sb.Length - value.Length, startIndex + count);
      44. for (int i = startIndex; i < maxIndex; i++)
      45. {
      46. var found = true;
      47. for (int j = 0; j < value.Length; j++)
      48. if (sb[i + j] != value[j])
      49. {
      50. found = false;
      51. break;
      52. }
      53. if (found)
      54. return i;
      55. }
      56. return -1;
      57. }
      58. public static int IndexOf(this StringBuilder sb, char value, int startIndex, int count)
      59. {
      60. var maxIndex = Math.Min(sb.Length, startIndex + count);
      61. for (int i = startIndex; i < maxIndex; i++)
      62. if (sb[i] == value)
      63. return i;
      64. return -1;
      65. }
      66. public static int IndexOf(this StringBuilder sb, string value, int startIndex)
      67. {
      68. return sb.IndexOf(value, startIndex, sb.Length - startIndex);
      69. }
      70. public static int IndexOf(this StringBuilder sb, char value, int startIndex)
      71. {
      72. return sb.IndexOf(value, startIndex, sb.Length - startIndex);
      73. }
      74. public static int IndexOf(this StringBuilder sb, string value)
      75. {
      76. return sb.IndexOf(value, 0, sb.Length);
      77. }
      78. public static int IndexOf(this StringBuilder sb, char value)
      79. {
      80. return sb.IndexOf(value, 0, sb.Length);
      81. }
      82. public static int LastIndexOf(this StringBuilder sb, string value, int startIndex, int count)
      83. {
      84. var minIndex = Math.Min(-1, startIndex - count);
      85. for (int i = startIndex; i > minIndex; i--)
      86. {
      87. var found = true;
      88. for (int j = 0; j < value.Length; j++)
      89. if (sb[i + j] != value[j])
      90. {
      91. found = false;
      92. break;
      93. }
      94. if (found)
      95. return i;
      96. }
      97. return -1;
      98. }
      99. public static int LastIndexOf(this StringBuilder sb, char value, int startIndex, int count)
      100. {
      101. var minIndex = Math.Max(-1, startIndex - count);
      102. for (int i = startIndex; i > minIndex; i--)
      103. if (sb[i] == value)
      104. return i;
      105. return -1;
      106. }
      107. public static int LastIndexOf(this StringBuilder sb, string value, int startIndex)
      108. {
      109. return sb.LastIndexOf(value, startIndex, sb.Length - startIndex);
      110. }
      111. public static int LastIndexOf(this StringBuilder sb, char value, int startIndex)
      112. {
      113. return sb.LastIndexOf(value, startIndex, sb.Length - startIndex);
      114. }
      115. public static int LastIndexOf(this StringBuilder sb, string value)
      116. {
      117. return sb.LastIndexOf(value, 0, sb.Length);
      118. }
      119. public static int LastIndexOf(this StringBuilder sb, char value)
      120. {
      121. return sb.LastIndexOf(value, 0, sb.Length);
      122. }
      123. public static StringBuilder PadLeft(this StringBuilder sb, int totalWidth, char paddingChar)
      124. {
      125. while (sb.Length < totalWidth)
      126. sb.Insert(0, paddingChar);
      127. return sb;
      128. }
      129. public static StringBuilder PadLeft(this StringBuilder sb, int totalWidth)
      130. {
      131. return sb.PadLeft(totalWidth, ' ');
      132. }
      133. public static StringBuilder PadRight(this StringBuilder sb, int totalWidth, char paddingChar)
      134. {
      135. while (sb.Length < totalWidth)
      136. sb.Append(paddingChar);
      137. return sb;
      138. }
      139. public static StringBuilder PadRight(this StringBuilder sb, int totalWidth)
      140. {
      141. return sb.PadRight(totalWidth, ' ');
      142. }
      143. public static StringBuilder SubString(this StringBuilder sb, int startIndex, int length)
      144. {
      145. var newSb = new StringBuilder(length - startIndex);
      146. var chars = new char[length];
      147. sb.CopyTo(startIndex, chars, 0, length);
      148. newSb.Append(chars);
      149. return newSb;
      150. }
      151. public static StringBuilder SubString(this StringBuilder sb, int startIndex)
      152. {
      153. return sb.SubString(startIndex, sb.Length - startIndex);
      154. }
      155. public static StringBuilder TrimStart(this StringBuilder sb, char trimChar)
      156. {
      157. while (sb.StartsWith(trimChar))
      158. sb.Remove(0, 1);
      159. return sb;
      160. }
      161. public static StringBuilder TrimEnd(this StringBuilder sb, char trimChar)
      162. {
      163. while (sb.EndsWith(trimChar))
      164. sb.Remove(sb.Length - 1, 1);
      165. return sb;
      166. }
      167. public static StringBuilder Trim(this StringBuilder sb, char trimChar)
      168. {
      169. while (sb.StartsWith(trimChar))
      170. sb.Remove(0, 1);
      171. while (sb.EndsWith(trimChar))
      172. sb.Remove(sb.Length - 1, 1);
      173. return sb;
      174. }
      175. public static char[] ToCharArray(this StringBuilder sb)
      176. {
      177. var chars = new char[sb.Length];
      178. sb.CopyTo(0, chars, 0, sb.Length);
      179. return chars;
      180. }
      181. public static StringBuilder Replace(this StringBuilder sb, string oldString, string newString)
      182. {
      183. for (int i = sb.Length - oldString.Length; i > -1; i--)
      184. if (sb.SubString(i).StartsWith(oldString))
      185. {
      186. sb.Remove(i, oldString.Length);
      187. sb.Insert(i, newString);
      188. }
      189. return sb;
      190. }
      191. public static StringBuilder Replace(this StringBuilder sb, char oldChar, char newChar)
      192. {
      193. for (int i = 0; i < sb.Length; i++)
      194. if (sb[i] == oldChar)
      195. sb[i] = newChar;
      196. return sb;
      197. }
      198. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<string> separators, int count, StringSplitOptions options)
      199. {
      200. var parts = new List<StringBuilder>();
      201. var i = 0;
      202. while (i < sb.Length)
      203. {
      204. if (count > -1 && count == parts.Count)
      205. break;
      206. var builder = new StringBuilder();
      207. parts.Add(builder);
      208. while (i < sb.Length)
      209. {
      210. var foundEnd = false;
      211. foreach (var separator in separators)
      212. if ((i + separator.Length < sb.Length) && sb.SubString(i, separator.Length).StartsWith(separator))
      213. {
      214. i += separator.Length;
      215. foundEnd = true;
      216. break;
      217. }
      218. if (!foundEnd)
      219. {
      220. builder.Append(sb[i]);
      221. i++;
      222. }
      223. }
      224. }
      225. var result = new List<StringBuilder>();
      226. foreach (var part in parts)
      227. if (!((options == StringSplitOptions.RemoveEmptyEntries) && (part.Length == 0)))
      228. result.Add(part);
      229. return result.ToArray();
      230. }
      231. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<char> separators, int count, StringSplitOptions options)
      232. {
      233. var parts = new List<StringBuilder>();
      234. var i = 0;
      235. while (i < sb.Length)
      236. {
      237. if (count > -1 && count == parts.Count)
      238. break;
      239. var builder = new StringBuilder();
      240. parts.Add(builder);
      241. while (i < sb.Length)
      242. {
      243. var foundEnd = false;
      244. foreach (var separator in separators)
      245. if ((i + 1 < sb.Length) && (sb.SubString(i, 1)[0] == separator))
      246. {
      247. i++;
      248. foundEnd = true;
      249. break;
      250. }
      251. if (!foundEnd)
      252. {
      253. builder.Append(sb[i]);
      254. i++;
      255. }
      256. }
      257. }
      258. var result = new List<StringBuilder>();
      259. foreach (var part in parts)
      260. if (!((options == StringSplitOptions.RemoveEmptyEntries) && (part.Length == 0)))
      261. result.Add(part);
      262. return result.ToArray();
      263. }
      264. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<string> separators)
      265. {
      266. return sb.Split(separators, -1, StringSplitOptions.None);
      267. }
      268. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<char> separators)
      269. {
      270. return sb.Split(separators, -1, StringSplitOptions.None);
      271. }
      272. public static StringBuilder[] Split(this StringBuilder sb, string separator)
      273. {
      274. return sb.Split(new string[] { separator }, -1, StringSplitOptions.None);
      275. }
      276. public static StringBuilder[] Split(this StringBuilder sb, char separator)
      277. {
      278. return sb.Split(new char[] { separator }, -1, StringSplitOptions.None);
      279. }
      280. }
      281. }
      282. }
      283. }


      Also lauffähig sollte schon sein, was hier eingestellt wird.

      Also ich hab jetzt mal drübergeschaut, lauffähig sollten die VB-Funktionen schon sein. Ich mach die Klasse aber mal zu nem Modul, ist in VB wahrscheinlich schöner.

      Und was soll dashier?

      Da hast du natürlich Recht, werde ich ändern.


      Edit:
      So, hab den Code jetzt etwas optimiert.

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

      Hi, ich weiß das Thema ist alt, ich würde trotzdem gerne etwas dazu fragen.

      @ErfinderDesRades Du schreibst höhere Werte sind besser bei deinen Benchmarks, aber wenn ich das richtig verstehe dann ist "teststring".[beliebigeMethode] langsamer als New StringBuilder("teststring").ToString.[beliebigeMethode]. Aber das kann doch wohl unmöglich sein, weil nach .ToString sind beide Beispiele identisch.

      Oder verstehe ich falsch was du mit

      Quellcode

      1. artentus:
      2. string: 7916
      3. StringBuilder: 9379
      4. stresstest edr:
      5. string: 7810
      6. StringBuilder: 19486
      meinst?

      Ich frage, weil ich im Speziellen sowas brauche (Ersetze nur ersten Fund):

      VB.NET-Quellcode

      1. <Extension()>
      2. Friend Sub ReplaceFirst(sb As StringBuilder, searchText As String, replaceText As String)
      3. Dim idx = sb.ToString.IndexOf(searchText)
      4. If idx = -1 Then Exit Sub
      5. sb.Remove(idx, searchText.Length)
      6. sb.Insert(idx, replaceText)
      7. End Sub
      Und besser ists ich hab zumindest mal über Performance nachgedacht an der Stelle.

      Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von „Haudruferzappeltnoch“ ()

      Haudruferzappeltnoch schrieb:

      Du schreibst höhere Werte sind besser bei deinen Benchmarks,
      ja, richtig.

      Haudruferzappeltnoch schrieb:

      , aber wenn ich das richtig verstehe dann ist "teststring".[beliebigeMethode] langsamer als New StringBuilder("teststring").ToString.[beliebigeMethode]. Aber das kann doch wohl unmöglich sein, weil nach .ToString sind beide Beispiele identisch.
      Bin jetzt nicht sicher was du meinst. Hab ich iwo gesagt "teststring".[beliebigeMethode] sei langsamer als New StringBuilder("teststring").ToString.[beliebigeMethode]? - oder es gar getestet?
      Käme mir aus heutiger Sicht auch recht eigenartig vor.

      Haudruferzappeltnoch schrieb:

      Und besser ists ich hab zumindest mal über Performance nachgedacht an der Stelle.
      Weisst ja: Ich bin garnet Freund davon, allgemeine Performance-Überlegungen anzustellen.
      String ist reichlich schnell genug - wozu braucht man StringBuilder?
      Na, du schreibst
      String: [kleinere Zahl]
      StringBuilder: [größere Zahl]
      Wohl gemerkt an Stellen, wo du im Code sb.ToString nutzt.

      Deswegen frug ich ja was das bedeuten soll wenn größer schneller ist.
      (Anders gefragt wie sieht der Code aus der zu dem Ergebnis "String: 7810" führt? Damit komm ich vielleicht auch schon selbst dahinter, weil das ist das Verständnisproblem: ich weiß gar nicht vollständig was genau du getestet hast)
      ((sb.ToString.<dasFehlende> schreibst du statt sb.ToString.[beliebigeMethode]))

      Das sind keine allgemeinen Performance Überlegungen, ich kann da nicht irgendwas verwenden was zu schlimm wird. Ich wollts nur verstehen, damit ich das abschätzen kann.
      StringBuilder find ich außerdem gut wenn man wirklich Strings "builden" muss, wie ne Sandburg

      Dieser Beitrag wurde bereits 12 mal editiert, zuletzt von „Haudruferzappeltnoch“ ()