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
      7. Namespace Artentus
      8. Namespace Utils
      9. Namespace StringBuilderExtensions
      10. Public Module Extensions
      11. <System.Runtime.CompilerServices.Extension> _
      12. Public Shared Function StartsWith(sb As StringBuilder, value As String) As Boolean
      13. If sb.Length < value.Length Then
      14. Return False
      15. End If
      17. For i As Integer = 0 To charsSb.Length - 1
      18. If sb(i) <> value(i) Then
      19. Return False
      20. End If
      21. Next
      23. Return True
      24. End Function
      26. <System.Runtime.CompilerServices.Extension> _
      27. Public Shared Function StartsWith(sb As StringBuilder, value As Char) As Boolean
      28. Return sb.Length > 0 AndAlso sb(0) = value
      29. End Function
      31. <System.Runtime.CompilerServices.Extension> _
      32. Public Shared Function EndsWith(sb As StringBuilder, value As String) As Boolean
      33. If sb.Length < value.Length Then
      34. Return False
      35. End If
      37. For i As Integer = 0 To charsSb.Length - 1
      38. If charsSb((sb.Length - value.Length) + i) <> value(i) Then
      39. Return False
      40. End If
      41. Next
      43. Return True
      44. End Function
      46. <System.Runtime.CompilerServices.Extension> _
      47. Public Shared Function EndsWith(sb As StringBuilder, value As Char) As Boolean
      48. Return sb.Length > 0 AndAlso sb(sb.Length - 1) = value
      49. End Function
      51. <System.Runtime.CompilerServices.Extension> _
      52. Public Shared Function IndexOf(sb As StringBuilder, value As String, startIndex As Integer, count As Integer) As Integer
      53. Dim maxIndex = Math.Min(sb.Length - value.Length, startIndex + count)
      55. For i As Integer = startIndex To maxIndex - 1
      56. Dim found = True
      57. For j As Integer = 0 To value.Length - 1
      58. If sb(i + j) <> value(j) Then
      59. found = False
      60. Exit For
      61. End If
      62. Next
      64. If found Then
      65. Return i
      66. End If
      67. Next
      69. Return -1
      70. End Function
      72. <System.Runtime.CompilerServices.Extension> _
      73. Public Shared Function IndexOf(sb As StringBuilder, value As Char, startIndex As Integer, count As Integer) As Integer
      74. Dim maxIndex = Math.Min(sb.Length, startIndex + count)
      76. For i As Integer = startIndex To maxIndex - 1
      77. If sb(i) = value Then
      78. Return i
      79. End If
      80. Next
      82. Return -1
      83. End Function
      85. <System.Runtime.CompilerServices.Extension> _
      86. Public Shared Function IndexOf(sb As StringBuilder, value As String, startIndex As Integer) As Integer
      87. Return sb.IndexOf(value, startIndex, sb.Length - startIndex)
      88. End Function
      90. <System.Runtime.CompilerServices.Extension> _
      91. Public Shared Function IndexOf(sb As StringBuilder, value As Char, startIndex As Integer) As Integer
      92. Return sb.IndexOf(value, startIndex, sb.Length - startIndex)
      93. End Function
      95. <System.Runtime.CompilerServices.Extension> _
      96. Public Shared Function IndexOf(sb As StringBuilder, value As String) As Integer
      97. Return sb.IndexOf(value, 0, sb.Length)
      98. End Function
      100. <System.Runtime.CompilerServices.Extension> _
      101. Public Shared Function IndexOf(sb As StringBuilder, value As Char) As Integer
      102. Return sb.IndexOf(value, 0, sb.Length)
      103. End Function
      105. <System.Runtime.CompilerServices.Extension> _
      106. Public Shared Function LastIndexOf(sb As StringBuilder, value As String, startIndex As Integer, count As Integer) As Integer
      107. Dim minIndex = Math.Min(-1, startIndex - count)
      109. For i As Integer = startIndex To minIndex + 1 Step -1
      110. Dim found = True
      111. For j As Integer = 0 To value.Length - 1
      112. If sb(i + j) <> value(j) Then
      113. found = False
      114. Exit For
      115. End If
      116. Next
      118. If found Then
      119. Return i
      120. End If
      121. Next
      123. Return -1
      124. End Function
      126. <System.Runtime.CompilerServices.Extension> _
      127. Public Shared Function LastIndexOf(sb As StringBuilder, value As Char, startIndex As Integer, count As Integer) As Integer
      128. Dim minIndex = Math.Max(-1, startIndex - count)
      130. For i As Integer = startIndex To minIndex + 1 Step -1
      131. If sb(i) = value Then
      132. Return i
      133. End If
      134. Next
      136. Return -1
      137. End Function
      139. <System.Runtime.CompilerServices.Extension> _
      140. Public Shared Function LastIndexOf(sb As StringBuilder, value As String, startIndex As Integer) As Integer
      141. Return sb.LastIndexOf(value, startIndex, sb.Length - startIndex)
      142. End Function
      144. <System.Runtime.CompilerServices.Extension> _
      145. Public Shared Function LastIndexOf(sb As StringBuilder, value As Char, startIndex As Integer) As Integer
      146. Return sb.LastIndexOf(value, startIndex, sb.Length - startIndex)
      147. End Function
      149. <System.Runtime.CompilerServices.Extension> _
      150. Public Shared Function LastIndexOf(sb As StringBuilder, value As String) As Integer
      151. Return sb.LastIndexOf(value, 0, sb.Length)
      152. End Function
      154. <System.Runtime.CompilerServices.Extension> _
      155. Public Shared Function LastIndexOf(sb As StringBuilder, value As Char) As Integer
      156. Return sb.LastIndexOf(value, 0, sb.Length)
      157. End Function
      159. <System.Runtime.CompilerServices.Extension> _
      160. Public Shared Function PadLeft(sb As StringBuilder, totalWidth As Integer, paddingChar As Char) As StringBuilder
      161. While sb.Length < totalWidth
      162. sb.Insert(0, paddingChar)
      163. End While
      165. Return sb
      166. End Function
      168. <System.Runtime.CompilerServices.Extension> _
      169. Public Shared Function PadLeft(sb As StringBuilder, totalWidth As Integer) As StringBuilder
      170. Return sb.PadLeft(totalWidth, " "C)
      171. End Function
      173. <System.Runtime.CompilerServices.Extension> _
      174. Public Shared Function PadRight(sb As StringBuilder, totalWidth As Integer, paddingChar As Char) As StringBuilder
      175. While sb.Length < totalWidth
      176. sb.Append(paddingChar)
      177. End While
      179. Return sb
      180. End Function
      182. <System.Runtime.CompilerServices.Extension> _
      183. Public Shared Function PadRight(sb As StringBuilder, totalWidth As Integer) As StringBuilder
      184. Return sb.PadRight(totalWidth, " "C)
      185. End Function
      187. <System.Runtime.CompilerServices.Extension> _
      188. Public Shared Function SubString(sb As StringBuilder, startIndex As Integer, length As Integer) As StringBuilder
      189. Dim newSb = New StringBuilder(length - startIndex)
      190. Dim chars = New Char(length - 1) {}
      191. sb.CopyTo(startIndex, chars, 0, length)
      192. newSb.Append(chars)
      193. Return newSb
      194. End Function
      196. <System.Runtime.CompilerServices.Extension> _
      197. Public Shared Function SubString(sb As StringBuilder, startIndex As Integer) As StringBuilder
      198. Return sb.SubString(startIndex, sb.Length - startIndex)
      199. End Function
      201. <System.Runtime.CompilerServices.Extension> _
      202. Public Shared Function TrimStart(sb As StringBuilder, trimChar As Char) As StringBuilder
      203. While sb.StartsWith(trimChar)
      204. sb.Remove(0, 1)
      205. End While
      207. Return sb
      208. End Function
      210. <System.Runtime.CompilerServices.Extension> _
      211. Public Shared Function TrimEnd(sb As StringBuilder, trimChar As Char) As StringBuilder
      212. While sb.EndsWith(trimChar)
      213. sb.Remove(sb.Length - 1, 1)
      214. End While
      216. Return sb
      217. End Function
      219. <System.Runtime.CompilerServices.Extension> _
      220. Public Shared Function Trim(sb As StringBuilder, trimChar As Char) As StringBuilder
      221. While sb.StartsWith(trimChar)
      222. sb.Remove(0, 1)
      223. End While
      225. While sb.EndsWith(trimChar)
      226. sb.Remove(sb.Length - 1, 1)
      227. End While
      229. Return sb
      230. End Function
      232. <System.Runtime.CompilerServices.Extension> _
      233. Public Shared Function ToCharArray(sb As StringBuilder) As Char()
      234. Dim chars = New Char(sb.Length - 1) {}
      235. sb.CopyTo(0, chars, 0, sb.Length)
      236. Return chars
      237. End Function
      239. <System.Runtime.CompilerServices.Extension> _
      240. Public Shared Function Replace(sb As StringBuilder, oldString As String, newString As String) As StringBuilder
      241. For i As Integer = sb.Length - oldString.Length To -1 + 1 Step -1
      242. If sb.SubString(i).StartsWith(oldString) Then
      243. sb.Remove(i, oldString.Length)
      244. sb.Insert(i, newString)
      245. End If
      246. Next
      248. Return sb
      249. End Function
      251. <System.Runtime.CompilerServices.Extension> _
      252. Public Shared Function Replace(sb As StringBuilder, oldChar As Char, newChar As Char) As StringBuilder
      253. For i As Integer = 0 To sb.Length - 1
      254. If sb(i) = oldChar Then
      255. sb(i) = newChar
      256. End If
      257. Next
      259. Return sb
      260. End Function
      262. <System.Runtime.CompilerServices.Extension> _
      263. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of String), count As Integer, options As StringSplitOptions) As StringBuilder()
      264. Dim parts = New List(Of StringBuilder)()
      266. Dim i = 0
      267. While i < sb.Length
      268. If count > -1 AndAlso count = parts.Count Then
      269. Exit While
      270. End If
      272. Dim builder = New StringBuilder()
      273. parts.Add(builder)
      275. While i < sb.Length
      276. Dim foundEnd = False
      278. For Each separator As var In separators
      279. If (i + separator.Length < sb.Length) AndAlso sb.SubString(i, separator.Length).StartsWith(separator) Then
      280. i += separator.Length
      282. foundEnd = True
      283. Exit For
      284. End If
      285. Next
      287. If Not foundEnd Then
      288. builder.Append(sb(i))
      289. i += 1
      290. End If
      291. End While
      292. End While
      294. Dim result = New List(Of StringBuilder)()
      295. For Each part As var In parts
      296. If Not ((options = StringSplitOptions.RemoveEmptyEntries) AndAlso (part.Length = 0)) Then
      297. result.Add(part)
      298. End If
      299. Next
      301. Return result.ToArray()
      302. End Function
      304. <System.Runtime.CompilerServices.Extension> _
      305. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of Char), count As Integer, options As StringSplitOptions) As StringBuilder()
      306. Dim parts = New List(Of StringBuilder)()
      308. Dim i = 0
      309. While i < sb.Length
      310. If count > -1 AndAlso count = parts.Count Then
      311. Exit While
      312. End If
      314. Dim builder = New StringBuilder()
      315. parts.Add(builder)
      317. While i < sb.Length
      318. Dim foundEnd = False
      320. For Each separator As var In separators
      321. If (i + 1 < sb.Length) AndAlso (sb.SubString(i, 1)(0) = separator) Then
      322. i += 1
      324. foundEnd = True
      325. Exit For
      326. End If
      327. Next
      329. If Not foundEnd Then
      330. builder.Append(sb(i))
      331. i += 1
      332. End If
      333. End While
      334. End While
      336. Dim result = New List(Of StringBuilder)()
      337. For Each part As var In parts
      338. If Not ((options = StringSplitOptions.RemoveEmptyEntries) AndAlso (part.Length = 0)) Then
      339. result.Add(part)
      340. End If
      341. Next
      343. Return result.ToArray()
      344. End Function
      346. <System.Runtime.CompilerServices.Extension> _
      347. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of String)) As StringBuilder()
      348. Return sb.Split(separators, -1, StringSplitOptions.None)
      349. End Function
      351. <System.Runtime.CompilerServices.Extension> _
      352. Public Shared Function Split(sb As StringBuilder, separators As IEnumerable(Of Char)) As StringBuilder()
      353. Return sb.Split(separators, -1, StringSplitOptions.None)
      354. End Function
      356. <System.Runtime.CompilerServices.Extension> _
      357. Public Shared Function Split(sb As StringBuilder, separator As String) As StringBuilder()
      358. Return sb.Split(New String() {separator}, -1, StringSplitOptions.None)
      359. End Function
      361. <System.Runtime.CompilerServices.Extension> _
      362. Public Shared Function Split(sb As StringBuilder, separator As Char) As StringBuilder()
      363. Return sb.Split(New Char() {separator}, -1, StringSplitOptions.None)
      364. End Function
      365. End Class
      366. End Namespace
      367. End Namespace
      368. 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
      5. Edr:
      6. string: 26718
      7. 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
      5. stresstest edr:
      6. string: 7810
      7. 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;
      8. namespace Artentus
      9. {
      10. namespace Utils
      11. {
      12. namespace StringBuilderExtensions
      13. {
      14. public static class Extensions
      15. {
      16. public static bool StartsWith(this StringBuilder sb, string value)
      17. {
      18. if (sb.Length < value.Length)
      19. return false;
      21. for (int i = 0; i < value.Length; i++)
      22. if (sb[i] != value[i])
      23. return false;
      25. return true;
      26. }
      28. public static bool StartsWith(this StringBuilder sb, char value)
      29. {
      30. return sb.Length > 0 && sb[0] == value;
      31. }
      33. public static bool EndsWith(this StringBuilder sb, string value)
      34. {
      35. if (sb.Length < value.Length)
      36. return false;
      38. for (int i = 0; i < value.Length; i++)
      39. if (sb[(sb.Length - value.Length) + i] != value[i])
      40. return false;
      42. return true;
      43. }
      45. public static bool EndsWith(this StringBuilder sb, char value)
      46. {
      47. return sb.Length > 0 && sb[sb.Length - 1] == value;
      48. }
      50. public static int IndexOf(this StringBuilder sb, string value, int startIndex, int count)
      51. {
      52. var maxIndex = Math.Min(sb.Length - value.Length, startIndex + count);
      54. for (int i = startIndex; i < maxIndex; i++)
      55. {
      56. var found = true;
      57. for (int j = 0; j < value.Length; j++)
      58. if (sb[i + j] != value[j])
      59. {
      60. found = false;
      61. break;
      62. }
      64. if (found)
      65. return i;
      66. }
      68. return -1;
      69. }
      71. public static int IndexOf(this StringBuilder sb, char value, int startIndex, int count)
      72. {
      73. var maxIndex = Math.Min(sb.Length, startIndex + count);
      75. for (int i = startIndex; i < maxIndex; i++)
      76. if (sb[i] == value)
      77. return i;
      79. return -1;
      80. }
      82. public static int IndexOf(this StringBuilder sb, string value, int startIndex)
      83. {
      84. return sb.IndexOf(value, startIndex, sb.Length - startIndex);
      85. }
      87. public static int IndexOf(this StringBuilder sb, char value, int startIndex)
      88. {
      89. return sb.IndexOf(value, startIndex, sb.Length - startIndex);
      90. }
      92. public static int IndexOf(this StringBuilder sb, string value)
      93. {
      94. return sb.IndexOf(value, 0, sb.Length);
      95. }
      97. public static int IndexOf(this StringBuilder sb, char value)
      98. {
      99. return sb.IndexOf(value, 0, sb.Length);
      100. }
      102. public static int LastIndexOf(this StringBuilder sb, string value, int startIndex, int count)
      103. {
      104. var minIndex = Math.Min(-1, startIndex - count);
      106. for (int i = startIndex; i > minIndex; i--)
      107. {
      108. var found = true;
      109. for (int j = 0; j < value.Length; j++)
      110. if (sb[i + j] != value[j])
      111. {
      112. found = false;
      113. break;
      114. }
      116. if (found)
      117. return i;
      118. }
      120. return -1;
      121. }
      123. public static int LastIndexOf(this StringBuilder sb, char value, int startIndex, int count)
      124. {
      125. var minIndex = Math.Max(-1, startIndex - count);
      127. for (int i = startIndex; i > minIndex; i--)
      128. if (sb[i] == value)
      129. return i;
      131. return -1;
      132. }
      134. public static int LastIndexOf(this StringBuilder sb, string value, int startIndex)
      135. {
      136. return sb.LastIndexOf(value, startIndex, sb.Length - startIndex);
      137. }
      139. public static int LastIndexOf(this StringBuilder sb, char value, int startIndex)
      140. {
      141. return sb.LastIndexOf(value, startIndex, sb.Length - startIndex);
      142. }
      144. public static int LastIndexOf(this StringBuilder sb, string value)
      145. {
      146. return sb.LastIndexOf(value, 0, sb.Length);
      147. }
      149. public static int LastIndexOf(this StringBuilder sb, char value)
      150. {
      151. return sb.LastIndexOf(value, 0, sb.Length);
      152. }
      154. public static StringBuilder PadLeft(this StringBuilder sb, int totalWidth, char paddingChar)
      155. {
      156. while (sb.Length < totalWidth)
      157. sb.Insert(0, paddingChar);
      159. return sb;
      160. }
      162. public static StringBuilder PadLeft(this StringBuilder sb, int totalWidth)
      163. {
      164. return sb.PadLeft(totalWidth, ' ');
      165. }
      167. public static StringBuilder PadRight(this StringBuilder sb, int totalWidth, char paddingChar)
      168. {
      169. while (sb.Length < totalWidth)
      170. sb.Append(paddingChar);
      172. return sb;
      173. }
      175. public static StringBuilder PadRight(this StringBuilder sb, int totalWidth)
      176. {
      177. return sb.PadRight(totalWidth, ' ');
      178. }
      180. public static StringBuilder SubString(this StringBuilder sb, int startIndex, int length)
      181. {
      182. var newSb = new StringBuilder(length - startIndex);
      183. var chars = new char[length];
      184. sb.CopyTo(startIndex, chars, 0, length);
      185. newSb.Append(chars);
      186. return newSb;
      187. }
      189. public static StringBuilder SubString(this StringBuilder sb, int startIndex)
      190. {
      191. return sb.SubString(startIndex, sb.Length - startIndex);
      192. }
      194. public static StringBuilder TrimStart(this StringBuilder sb, char trimChar)
      195. {
      196. while (sb.StartsWith(trimChar))
      197. sb.Remove(0, 1);
      199. return sb;
      200. }
      202. public static StringBuilder TrimEnd(this StringBuilder sb, char trimChar)
      203. {
      204. while (sb.EndsWith(trimChar))
      205. sb.Remove(sb.Length - 1, 1);
      207. return sb;
      208. }
      210. public static StringBuilder Trim(this StringBuilder sb, char trimChar)
      211. {
      212. while (sb.StartsWith(trimChar))
      213. sb.Remove(0, 1);
      215. while (sb.EndsWith(trimChar))
      216. sb.Remove(sb.Length - 1, 1);
      218. return sb;
      219. }
      221. public static char[] ToCharArray(this StringBuilder sb)
      222. {
      223. var chars = new char[sb.Length];
      224. sb.CopyTo(0, chars, 0, sb.Length);
      225. return chars;
      226. }
      228. public static StringBuilder Replace(this StringBuilder sb, string oldString, string newString)
      229. {
      230. for (int i = sb.Length - oldString.Length; i > -1; i--)
      231. if (sb.SubString(i).StartsWith(oldString))
      232. {
      233. sb.Remove(i, oldString.Length);
      234. sb.Insert(i, newString);
      235. }
      237. return sb;
      238. }
      240. public static StringBuilder Replace(this StringBuilder sb, char oldChar, char newChar)
      241. {
      242. for (int i = 0; i < sb.Length; i++)
      243. if (sb[i] == oldChar)
      244. sb[i] = newChar;
      246. return sb;
      247. }
      249. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<string> separators, int count, StringSplitOptions options)
      250. {
      251. var parts = new List<StringBuilder>();
      253. var i = 0;
      254. while (i < sb.Length)
      255. {
      256. if (count > -1 && count == parts.Count)
      257. break;
      259. var builder = new StringBuilder();
      260. parts.Add(builder);
      262. while (i < sb.Length)
      263. {
      264. var foundEnd = false;
      266. foreach (var separator in separators)
      267. if ((i + separator.Length < sb.Length) && sb.SubString(i, separator.Length).StartsWith(separator))
      268. {
      269. i += separator.Length;
      271. foundEnd = true;
      272. break;
      273. }
      275. if (!foundEnd)
      276. {
      277. builder.Append(sb[i]);
      278. i++;
      279. }
      280. }
      281. }
      283. var result = new List<StringBuilder>();
      284. foreach (var part in parts)
      285. if (!((options == StringSplitOptions.RemoveEmptyEntries) && (part.Length == 0)))
      286. result.Add(part);
      288. return result.ToArray();
      289. }
      291. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<char> separators, int count, StringSplitOptions options)
      292. {
      293. var parts = new List<StringBuilder>();
      295. var i = 0;
      296. while (i < sb.Length)
      297. {
      298. if (count > -1 && count == parts.Count)
      299. break;
      301. var builder = new StringBuilder();
      302. parts.Add(builder);
      304. while (i < sb.Length)
      305. {
      306. var foundEnd = false;
      308. foreach (var separator in separators)
      309. if ((i + 1 < sb.Length) && (sb.SubString(i, 1)[0] == separator))
      310. {
      311. i++;
      313. foundEnd = true;
      314. break;
      315. }
      317. if (!foundEnd)
      318. {
      319. builder.Append(sb[i]);
      320. i++;
      321. }
      322. }
      323. }
      325. var result = new List<StringBuilder>();
      326. foreach (var part in parts)
      327. if (!((options == StringSplitOptions.RemoveEmptyEntries) && (part.Length == 0)))
      328. result.Add(part);
      330. return result.ToArray();
      331. }
      333. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<string> separators)
      334. {
      335. return sb.Split(separators, -1, StringSplitOptions.None);
      336. }
      338. public static StringBuilder[] Split(this StringBuilder sb, IEnumerable<char> separators)
      339. {
      340. return sb.Split(separators, -1, StringSplitOptions.None);
      341. }
      343. public static StringBuilder[] Split(this StringBuilder sb, string separator)
      344. {
      345. return sb.Split(new string[] { separator }, -1, StringSplitOptions.None);
      346. }
      348. public static StringBuilder[] Split(this StringBuilder sb, char separator)
      349. {
      350. return sb.Split(new char[] { separator }, -1, StringSplitOptions.None);
      351. }
      352. }
      353. }
      354. }
      355. }


      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
      5. stresstest edr:
      6. string: 7810
      7. 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“ ()