String verwenden oder gleich alles mit StringBuilder machen

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 13 Antworten in diesem Thema. Der letzte Beitrag () ist von EaranMaleasi.

    String verwenden oder gleich alles mit StringBuilder machen

    Mir geht gerade eine Frage durch den Kopf. StringBuilder ist in .Net viel schneller als das normale String.
    Sollte man dann nicht gleich alles als StringBuilder anlegen oder gibts weiterhin gute Gründe für den normalen String?
    Aktuelles Projekt: Z80 Disassembler für Schneider/Amstrad CPC :love:

    Code mit normalen Strings ist besser lesbar. Fast alle Methoden erwarten Strings - nicht StringBuilder. String stellt 200 KlassenMember bereit - ist also weitaus mächtiger als StringBuilder.

    Ich verwende StringBuilder sogut wie nie. Wenn ich Strings zusammenbauen muss, dann nehme ich eine List(Of Object), pack da meine Daten in richtiger Reihenfolge rein, und verwandle es am Ende in einen STring, mittels String.Join() oder String.Concat().
    Dassis viel komfortabler als StringBuilder, und vermutlich sogar schneller.

    Wobei die Geschwindigkeit ja eh egal ist.

    @oobdoo Ich verwende StringBuilder auch eher weniger, in einem übernommenen Projekt war mal einer, wo Strings aus vielen Zeilen aufgebaut wurden.
    Ich bin da auch eher bei einer List(Of String) und setz die dann wie der EDR zusammen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Noch nie benutzt... und trotzdem sind meine Programme nicht langsam. Ein Performance Verlust kommt dann eher von selbst geschriebenen Methoden oder DB/Dateisystem Zugriffen und nicht von Strings.

    Was programmierst du das die Nutzung eines StringBuilder spürbare Performance Vorteile bringt?
    "Gib einem Mann einen Fisch und du ernährst ihn für einen Tag. Lehre einen Mann zu fischen und du ernährst ihn für sein Leben."

    Wie debugge ich richtig? => Debuggen, Fehler finden und beseitigen
    Wie man VisualStudio nutzt? => VisualStudio richtig nutzen

    Ein StringBuilder zum Abholen von Texten aus nativen DLLs ist eine feine Sache.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    oobdoo schrieb:

    StringBuilder ist in .Net viel schneller als das normale String.
    Nein, das kannst du so pauschal nicht sagen. StringBuilder ist nur schneller, wenn viele Strings aneinander gereiht werden. Z.B. ​"A" + "B" + "C" + "D" + x + varabley + ": " + NewLine + ...... Oder wenn du dir SQL-Statements dynamisch selber zusammen baust und da kommen dann 200 ​WHERE Bedingungen rein, die du mit + aneinander kettest. Für ein paar Strings ist der StringBuilder nicht schneller.

    Kann ich bestätigen.

    Den Test habe ich vor Jahren schon gemacht. Jedoch nur String und Stringbuilder.
    Hab um die String.Join erweitert.

    Hinweis: Test mit Release-Mode und direkt die Exe ausgeführt

    Freundliche Grüsse

    exc-jdbi



    Spoiler anzeigen

    vb

    VB.NET-Quellcode

    1. Option Strict On
    2. Option Explicit On
    3. Imports System.Text
    5. Public Module Module1
    6. Private Rand As New Random
    7. Private AlphaString As String
    8. Private LstStr As List(Of List(Of Int32))
    9. Public Sub Main()
    10. Dim size = 1000
    11. Dim length = 1234
    12. AlphaStrings()
    13. RngCharNumber(size, length)
    15. 'Der eigentliche Test
    16. Console.WriteLine("VB.Net-Test")
    17. Console.WriteLine("***********")
    18. Console.WriteLine($"ListOfT.Length = {size}")
    19. Console.WriteLine($"String.Length = {length}")
    20. Console.WriteLine()
    21. TestString()
    22. TestStringBuilder()
    23. TestStringJoin()
    25. Console.ReadLine()
    26. End Sub
    27. Private Sub TestString()
    28. Dim str, s As String
    29. Dim sw = Stopwatch.StartNew
    31. str = String.Empty
    32. For i = 0 To LstStr.Count - 1
    33. s = String.Empty
    34. For j = 0 To LstStr(i).Count - 1
    35. s &= AlphaString(LstStr(i)(j))
    36. Next
    37. str &= s
    38. Next
    39. Console.WriteLine($"{NameOf(TestString)}: {sw.ElapsedMilliseconds}ms")
    40. GC.Collect()
    41. End Sub
    42. Private Sub TestStringBuilder()
    43. Dim str, s As StringBuilder
    44. Dim sw = Stopwatch.StartNew
    46. str = New StringBuilder
    47. For i = 0 To LstStr.Count - 1
    48. s = New StringBuilder
    49. For j = 0 To LstStr(i).Count - 1
    50. s.Append(AlphaString(LstStr(i)(j)))
    51. Next
    52. str.Append(s)
    53. Next
    54. Console.WriteLine($"{NameOf(TestStringBuilder)}: {sw.ElapsedMilliseconds}ms")
    55. GC.Collect()
    56. End Sub
    57. Private Sub TestStringJoin()
    58. Dim sw = Stopwatch.StartNew
    59. Dim lstr As New List(Of List(Of Char))(LstStr.Count)
    61. For i = 0 To LstStr.Count - 1
    62. lstr.Add(New List(Of Char)(LstStr(i).Count))
    63. For j = 0 To LstStr(i).Count - 1
    64. lstr(i).Add(AlphaString(LstStr(i)(j)))
    65. Next
    66. Next
    68. Dim stmp = lstr.Select(Function(s) String.Join("", s)).ToArray
    69. Dim str = String.Join("", stmp)
    70. Console.WriteLine($"{NameOf(TestStringJoin)}: {sw.ElapsedMilliseconds}ms")
    71. GC.Collect()
    72. End Sub
    73. Private Sub RngCharNumber(size As Int32, length As Int32)
    74. LstStr = New List(Of List(Of Int32))(size)
    75. For i = 0 To size - 1
    76. LstStr.Add(New List(Of Int32)(length))
    77. For j = 0 To length - 1
    78. LstStr(i).Add(Rand.Next(AlphaString.Length))
    79. Next
    80. Next
    81. End Sub
    82. Private Sub AlphaStrings()
    83. Dim res As New StringBuilder(62)
    84. Dim z() As Byte = {48, 57, 65, 90, 97, 122}
    85. For i As Int32 = 0 To z.Length - 1 Step 2
    86. For j As Byte = z(i) To z(i + 1)
    87. res.Append(Convert.ToChar(j))
    88. Next
    89. Next
    90. AlphaString = res.ToString
    91. End Sub
    92. End Module

    cs

    C#-Quellcode

    1. using System;
    2. using System.Linq;
    3. using System.Text;
    4. using System.Diagnostics;
    5. using System.Collections.Generic;
    7. namespace StringVsStringbuilderCs
    8. {
    9. public class Program
    10. {
    11. private static string AlphaString;
    12. private static List<List<int>> LstStr;
    13. private static Random Rand = new Random();
    14. public static void Main(string[] args)
    15. {
    16. int size = 1000;
    17. int length = 1234;
    18. AlphaStrings();
    19. RngCharNumber(size, length);
    21. // Der eigentliche Test
    22. Console.WriteLine("CSharp-Test");
    23. Console.WriteLine("***********");
    24. Console.WriteLine($"ListOfT.Length = {size}");
    25. Console.WriteLine($"String.Length = {length}");
    26. Console.WriteLine();
    27. TestString();
    28. TestStringBuilder();
    29. TestStringJoin();
    30. Console.ReadLine();
    31. }
    32. private static void TestString()
    33. {
    34. string str, s;
    35. var sw = Stopwatch.StartNew();
    36. str = string.Empty;
    37. for (int i = 0; i < LstStr.Count; i++)
    38. {
    39. s = string.Empty;
    40. for (int j = 0; j < LstStr[i].Count; j++)
    41. s += AlphaString[LstStr[i][j]];
    42. str += s;
    43. }
    45. Console.WriteLine($"{nameof(TestString)}: {sw.ElapsedMilliseconds}ms");
    46. GC.Collect();
    47. }
    49. private static void TestStringBuilder()
    50. {
    51. StringBuilder str, s;
    52. var sw = Stopwatch.StartNew();
    53. str = new StringBuilder();
    54. for (int i = 0; i < LstStr.Count; i++)
    55. {
    56. s = new StringBuilder();
    57. for (int j = 0; j < LstStr[i].Count; j++)
    58. s.Append(AlphaString[LstStr[i][j]]);
    59. str.Append(s);
    60. }
    62. Console.WriteLine($"{nameof(TestStringBuilder)}: {sw.ElapsedMilliseconds}ms");
    63. GC.Collect();
    64. }
    66. private static void TestStringJoin()
    67. {
    68. var sw = Stopwatch.StartNew();
    69. var lstr = new List<List<char>>(LstStr.Count);
    70. for (int i = 0; i < LstStr.Count; i++)
    71. {
    72. lstr.Add(new List<char>(LstStr[i].Count));
    73. for (int j = 0; j < LstStr[i].Count; j++)
    74. lstr[i].Add(AlphaString[LstStr[i][j]]);
    75. }
    77. var stmp = lstr.Select(s => string.Join("", s)).ToArray();
    78. string str = string.Join("", stmp);
    79. Console.WriteLine($"{nameof(TestStringJoin)}: {sw.ElapsedMilliseconds}ms");
    80. GC.Collect();
    81. }
    83. private static void RngCharNumber(int size, int length)
    84. {
    85. LstStr = new List<List<int>>(size);
    86. for (int i = 0, loopTo = size - 1; i <= loopTo; i++)
    87. {
    88. LstStr.Add(new List<int>(length));
    89. for (int j = 0, loopTo1 = length - 1; j <= loopTo1; j++)
    90. LstStr[i].Add(Rand.Next(AlphaString.Length));
    91. }
    92. }
    94. private static void AlphaStrings()
    95. {
    96. var res = new StringBuilder(62);
    97. var z = new byte[] { 48, 57, 65, 90, 97, 122 };
    98. for (int i = 0, loopTo = z.Length - 1; i <= loopTo; i += 2)
    99. {
    100. for (byte j = z[i], loopTo1 = z[i + 1]; j <= loopTo1; j++)
    101. res.Append(Convert.ToChar(j));
    102. }
    104. AlphaString = res.ToString();
    105. }
    106. }
    107. }

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „exc-jdbi“ ()

    Ich hab mich mal rangesetzt, und ebenfalls einen Benchmark gebastelt. Hier mal der Code, der in .NET Core 3.1 geschrieben wurde:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Diagnostics;
    4. using System.Linq;
    5. using System.Text;
    7. namespace StringBuilderTest
    8. {
    9. class Program
    10. {
    11. static Random rd = new Random(42);
    13. static void Main(string[] args)
    14. {
    15. int runs = 10;
    16. int iterations = 10000;
    17. int stringLength = 123;
    19. for (int r = 0; r < runs; r++)
    20. {
    21. List<long> ticksCreateRandom = new List<long>();
    22. List<long> ticksAddList = new List<long>();
    23. List<long> ticksAddBuilder = new List<long>();
    24. List<long> ticksJoinList = new List<long>();
    25. List<long> ticksToStringBuilder = new List<long>();
    27. List<string> list = new List<string>();
    28. StringBuilder builder = new StringBuilder();
    30. Stopwatch sw = new Stopwatch();
    32. for (int i = 0; i < iterations; i++)
    33. {
    34. sw.Restart();
    36. string randomString = CreatePassword(stringLength);
    38. sw.Stop();
    39. ticksCreateRandom.Add(sw.ElapsedTicks);
    40. sw.Restart();
    42. list.Add(randomString);
    44. sw.Stop();
    45. ticksAddList.Add(sw.ElapsedTicks);
    46. sw.Restart();
    48. builder.Append(randomString);
    50. sw.Stop();
    51. ticksAddBuilder.Add(sw.ElapsedTicks);
    52. }
    54. for (int i = 0; i < iterations; i++)
    55. {
    56. sw.Restart();
    58. string resultJoin = string.Join("", list);
    60. sw.Stop();
    61. ticksJoinList.Add(sw.ElapsedTicks);
    62. sw.Restart();
    64. string resultBuild = builder.ToString();
    66. sw.Stop();
    67. ticksToStringBuilder.Add(sw.ElapsedTicks);
    68. }
    70. long ticksListTotal = ticksCreateRandom.Sum() + ticksAddList.Sum() + ticksJoinList.Sum();
    71. long ticksBuilderTotal = ticksCreateRandom.Sum() + ticksAddBuilder.Sum() + ticksToStringBuilder.Sum();
    73. Console.WriteLine($"iterations : {iterations}");
    74. Console.WriteLine($"string length: {stringLength}");
    77. Console.WriteLine($"{"Creation Time",-21} - Min:{ticksCreateRandom.Min(),10} ticks | Avg:{ticksCreateRandom.Average(),10:f3} ticks | Max:{ticksCreateRandom.Max(),10} ticks | Total:{ticksCreateRandom.Sum(),10} ticks");
    78. Console.WriteLine($"{"Add List Time",-21} - Min:{ticksAddList.Min(),10} ticks | Avg:{ticksAddList.Average(),10:f3} ticks | Max:{ticksAddList.Max(),10} ticks | Total:{ticksAddList.Sum(),10} ticks");
    79. Console.WriteLine($"{"Add Builder Time",-21} - Min:{ticksAddBuilder.Min(),10} ticks | Avg:{ticksAddBuilder.Average(),10:f3} ticks | Max:{ticksAddBuilder.Max(),10} ticks | Total:{ticksAddBuilder.Sum(),10} ticks");
    80. Console.WriteLine($"{"Join List Time",-21} - Min:{ticksJoinList.Min(),10} ticks | Avg:{ticksJoinList.Average(),10:f3} ticks | Max:{ticksJoinList.Max(),10} ticks | Total:{ticksJoinList.Sum(),10} ticks");
    81. Console.WriteLine($"{"ToString Builder Time",-21} - Min:{ticksToStringBuilder.Min(),10} ticks | Avg:{ticksToStringBuilder.Average(),10:f3} ticks | Max:{ticksToStringBuilder.Max(),10} ticks | Total:{ticksToStringBuilder.Sum(),10} ticks");
    82. Console.WriteLine();
    83. Console.WriteLine($"{"Total List Time",-21}: {ticksListTotal,15} ticks | {ticksListTotal / (Stopwatch.Frequency / 1000.0),14:f3} ms | {ticksListTotal / (Stopwatch.Frequency / 1.0),10:f3} s");
    84. Console.WriteLine($"{"Total Builder Time",-21}: {ticksBuilderTotal,15} ticks | { ticksBuilderTotal / (Stopwatch.Frequency / 1000.0),14:f3} ms | {ticksBuilderTotal / (Stopwatch.Frequency / 1.0),10:f3} s");
    86. Console.WriteLine();
    87. Console.WriteLine();
    88. }
    90. Console.ReadKey(true);
    91. }
    94. public static string CreatePassword(int passwordLength, string AllChar = "ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz0123456789!@$?_-[](){}=§$%&/<>|;,:._-#'*+~€`´\\")
    95. {
    96. string allowedChars = AllChar;
    97. char[] chars = new char[passwordLength];
    98. for (int i = 0; i < passwordLength; i++)
    99. {
    100. chars[i] = allowedChars[rd.Next(0, allowedChars.Length)];
    101. }
    102. return new string(chars);
    103. }
    104. }
    105. }

    Und hier meine Ergebnisse von Links nach rechts:
    • Zuerst mal, die Parameter von @exc-jdbi
    • Weniger Iterationen, größerer String:
    • Noch weniger Iterationen, noch größerer String
    • Mehr iterationen, und kleinerer String
    • Und zum Schluss selbe Iterationen, String länge 1


    Bedeutet, je mehr Strings, aneinander gefügt werden, und je kleiner die Strings, desto schneller ist der StringBuilder gegenüber der String.Join Operation.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „EaranMaleasi“ ()

    ErfinderDesRades schrieb:

    dann nehme ich eine List(Of Object), pack da meine Daten in richtiger Reihenfolge rein, und verwandle es am Ende in einen STring, mittels String.Join() oder String.Concat()

    Interessant. Diesen Ansatz muss ich bei Gelegenheit mal testen. :)


    ErfinderDesRades schrieb:


    Wobei die Geschwindigkeit ja eh egal ist.

    Warum?


    mrMo schrieb:


    Was programmierst du das die Nutzung eines StringBuilder spürbare Performance Vorteile bringt?

    Ich? Einen Z80 Disassembler. Aktuell liegen die einzelnen Zeilen in einer ArrayList. Die wird ausgelesen und die einzelnen Teile per StringBuilder zusammen gesetzt.
    Der SB-String wird dann mit .ToString in einen normalen String umgewandelt und in einer RichTextBox angezeigt. Das ist aktuell mehr als schnell genug. Aber das
    Projekt wird langsam umfangreicher und da denke ich hin und wieder an Verbesserungsmöglichkeiten. Durch diesen Thread habe ich gute Hinweise bekommen. :)
    Aktuelles Projekt: Z80 Disassembler für Schneider/Amstrad CPC :love:

    oobdoo schrieb:

    ErfinderDesRades schrieb:

    Wobei die Geschwindigkeit ja eh egal ist.
    Warum?
    Es sollte eine Binsenweisheit sein, aber sie setzt und setzt und setzt sich nicht durch:

    Rules of Optimization! (bitte folge dem Link)


    Oder anderer Ansatz:

    oobdoo schrieb:

    ErfinderDesRades schrieb:

    Wobei die Geschwindigkeit ja eh egal ist.
    Warum?
    Weil es nunmal so ist.
    Bring mir ein Beispiel aus der Praxis, wo es die String-Performance war, die irgendeinen Vorgang spürbar behindert hätte.
    Und wenn du tatsächlich eines finden solltest, dann kann ich dir 10000 Beispiele aufzeigen, wo dem nicht so ist.
    Also zu 99.99% habe ich recht, und da erlaube ich mir aufzurunden, vor allem, wo's grad konkret drum geht, wegen der 0,01% nu anzufangen, Stringbuilder flächendeckend einzusetzen - und so Code auf breiter Front unleserlicher zu machen.

    @ErfinderDesRades:
    Das jetzt nicht, um gegen dich zu argumentieren, sondern weil ich die Geschichte sehr amüsant fand.
    Ein Freund hatte ein Programm, das Daten aus 'ner SQL-Datenbank holt und als XML exportiert. Hat pro Job ca. eine Stunde gedauert und ca. 20MB XML produziert.
    Er hat die Stringkonkatenationen (und ja, es ist in .NET unsinnig, XML durch Stringkonkatenation zu generieren) durch einen StringBuilder ersetzt und das hat die Jobs auf 3 Sekunden reduziert.
    Also... wenn man wirklich wirklich viele Strings verknüpft, hilft ein StringBuilder.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    ErfinderDesRades schrieb:

    Stringbuilder flächendeckend einzusetzen - und so Code auf breiter Front unleserlicher zu machen.
    Schau dir doch mal meinen Code oben an. Was genau ist jetzt am StringBuilder unleserlicher? Ob ich etliche Strings in ne List<string> Packe, und dann eine Methode benutze um daraus einen String zu machen, oder etliche Strings in einen StringBuilder packe, und dann eine Methode benutze um daraus einen String zu machen, kommt aufs selbe raus. Letzteres ist jedoch, sofern ich mir in meinem Benchmark keinen groben Schnitzer erlaubt habe, schneller. Wie viel schneller? sagen wir mal zwischen 1.5x - 10x schneller in der Praxis. Und wenn jemand wirklich Tag ein, Tag aus einzelne Zeichen zusammen fügt, der wird sich darüber freuen, dass der StringBuilder 57x schneller ist, als dein Vorschlag.

    Demnach ist diese Einschätzung:

    ErfinderDesRades schrieb:

    Dassis ... vermutlich sogar schneller.
    auf absolut Nichts basiert.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „EaranMaleasi“ ()

    ok - petaod hat ein Beispiel gefunden, wo Stringbuilder zur Optimierung nutzbar war.
    Und nun muss ich meine 10000 Beispiele bringen, wo's wie gesagt vollkommen irrelevant ist.
    Sorry - das ist mir zu mühsam, jetzt jede Verwendung von String in meinem kurzen Programmiererleben hier aufzulisten, und würde evtl. auch die Forum-Software überlasten.
    Daher Bitte: Glaubts mir einfach.


    @EaranMaleasi: Strings kann man auch ohne Stringbuilder verketten - das ist definitiv weniger Code, und somit leserlicher.
    Und zu 99% tut man das auch.
    Also einfach 2 Strings verketten ist ein Befehl, und mit StringBuilder sinds 3-4 Befehle. Wenn du da flächendeckend Bock drauf hast (so verstand ich post#1, dasser darauf abzielte) - bitte.
    Wie gesagt:
    Es sollte eine Binsenweisheit sein, aber sie setzt und setzt und setzt sich nicht durch:
    Rules of Optimization!     (bitte folge dem Link)
    Und geht mir schon wieder auf die Nerven, dass ich da jetzt wieder am herum-argumentieren bin - für etwas, das doch total banal ist.

    Oder anners: Stringbuilder ist ein Instrument (nicht unbedingt das beste!), wenn man String-Concatenationen aus Performance-Gründen optimieren muss.
    Nur muss man das so gut wie nie.


    EaranMaleasi schrieb:

    ErfinderDesRades schrieb:

    Dassis ... vermutlich sogar schneller.
    auf absolut Nichts basiert.
    wie dort ja steht: eine Vermutung. Und ist durchaus basiert! Nämlich auf dem Wissen, dass String.Concat - anders als eine sukzessive StringVerkettung - nicht für jedes Element den String umkopieren muss.
    Ich mach da jetzt aber keine Tests, weil das wie gesagt vollkommen irrelevant ist.
    Und wenn String.Concat nicht schneller ist, sondern mw. 100mal langsamer als StringBuilder.Append - was ich stark bezweifel - wen würde es interessieren?
    Meinen Listen-Trick mache ich nicht für performance, sondern um meine String-Frickeleien möglichst lesbar zu halten - und da ist Stringbuilder eben meist schlecht geeignet.
    Guck - hier - zB die Methode CustomFill aus Dataset->Db :

    VB.NET-Quellcode

    1. Public Sub CustomFill(table As DataTable, sqlAfterFrom As String, ParamArray args() As Object)
    2. Dim childrenFinder = New TopologicSort(_RankedTables, False)
    3. For Each tb In childrenFinder.GetRankedTables(table) : tb.Clear() : Next
    4. Using adp = DirectCast(DirectCast(_Adapters(table), ICloneable).Clone, SqlCeDataAdapter)
    5. Dim cmd = adp.SelectCommand
    6. Dim splits = sqlAfterFrom.Split("?"c)
    7. For i = 0 To args.Length - 1
    8. Dim name = "@p" & i
    9. cmd.Parameters.AddWithValue(name, args(i))
    10. splits(i) = String.Concat(splits(i), " ", name, " ")
    11. Next
    12. cmd.CommandText &= " " & String.Concat(splits)
    13. _Con.Open()
    14. adp.Fill(table)
    15. _Con.Close()
    16. End Using
    17. End Sub
    Kannste gerne auf Stringbuilder umstellen, und dann performance-tests machen.
    Und wenn die String-Operationen darin dann 50-mal schneller sind - was ich bezweifel - es wird immer noch irrelevant sein.
    Aber relevant wird sein, ob das Stringbuilder-Gefummel ebenso leserlich ist wie es jetzt ist.

    Hier noch weitere Beispiele, wie ich String.Join/Concat einem StringBuilder vorziehe.
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Text.RegularExpressions
    3. Public Class NoInject
    5. Private Class SqlInjectionException : Inherits Exception
    6. End Class
    8. Private Shared _SqlWhiteList As String = "ALL AND ANY AS ASC BEGIN BETWEEN BY CASE CONTAINS CONVERT DEFAULT DESC DISTINCT ELSE EXCEPT EXISTS FOR FROM FULL GROUP HAVING IF IIF IN INNER INTERSECT INTO IS JOIN LEFT LIKE NOT NULL NULLIF ON OR ORDER OUTER OVER PERCENT RIGHT SELECT SOME THEN TOP TRY_CONVERT TSEQUAL UNION WHEN WHERE WITH"
    9. Private Shared _ForbiddenSyntax As String() = "@ -- ; /* */".Split
    10. Private Shared _rgxWordBorder As New Regex("\b")
    11. Private Shared _rgxBracktet As New Regex("[\[\]]")
    13. ''' <summary>Converts sql to a sql-injection-safe version, or reject it by returning null</summary>
    14. Public Shared Function MakeSafe(sql As String) As String
    15. If sql Is Nothing Then Return Nothing
    16. Try
    17. Dim splits = sql.Split("'"c)
    18. If (splits.Length And 1) <> 1 Then Throw New SqlInjectionException ' an even splitCount indicates not-closed Quotes
    19. For i = 0 To splits.Length - 1 Step 2
    20. splits(i) = ProcessUnquotedPart(splits(i))
    21. Next
    22. Return String.Join("'"c, splits)
    23. Catch ex As SqlInjectionException
    24. Return Nothing
    25. End Try
    26. End Function
    28. Private Shared Function ProcessUnquotedPart(sNoQuotes As String) As String
    29. ValidateBrackets(sNoQuotes)
    30. Dim splits = _rgxBracktet.Split(sNoQuotes)
    31. For i = 0 To splits.Length - 1 Step 2 ' process nonBracket parts
    32. splits(i) = ProcessNonBracketPart(splits(i))
    33. Next
    34. If splits.Length = 1 Then Return splits(0) ' only one splt: sNoQuotes contained no Bracket
    35. Dim innerSegments = String.Join("][", splits.Skip(1).Take(splits.Length - 2))
    36. Return $"{ splits(0)}[{innerSegments}]{ splits.Last}" ' re-concat splits and restore Brackets
    37. End Function
    39. Private Shared Function ProcessNonBracketPart(sNoBracket As String) As String
    40. 'Ausserhalb von [], ''
    41. 'regeln: a) die in _ForbiddenSyntax geführten Zeichenfolgen sind nicht erlaubt
    42. 'b) nicht in _SqlWhiteList aufgeführte Worte werden mit [] gequotet
    43. If sNoBracket.Split(_ForbiddenSyntax, StringSplitOptions.None).Length > 1 Then Throw New SqlInjectionException
    44. Dim splits = _rgxWordBorder.Split(sNoBracket) ' _rgxWordBorder splittet an Wortgrenzen - verschluckt dabei keine Zeichen
    45. For i = 1 To splits.Length - 1 Step 2 ' process words
    46. If _SqlWhiteList.IndexOf(splits(i)) < 0 Then splits(i) = $"[{splits(i)}]" ' quote non-whitelist-words with []
    47. Next
    48. Return String.Concat(splits)
    49. End Function
    51. Private Shared Sub ValidateBrackets(sNoQuotes As String)
    52. 'Brackets: [] in Sql sind nicht schachtelbar.
    53. 'daher folgende regeln: erste Bracket muss öffnend sein, letzte schliessend. Dazwischen alternierend
    54. Dim prev = "]"
    55. For Each mt As Match In _rgxBracktet.Matches(sNoQuotes)
    56. If mt.Value = prev Then Throw New SqlInjectionException 'keine Verschachtelung erlaubt
    57. prev = mt.Value
    58. Next
    59. If prev <> "]" Then Throw New SqlInjectionException 'letzte muss geschlossen sein
    60. End Sub
    61. End Class
    Das ist eine Analyse-Komponente, um Sql-Injection abzuwehren - also ganz typischer Fall für verhältnismässig komplexe String-Verarbeitung - siehe Gegen SqlInjection ( + Tests )
    Und auch hier zeigt sich, dass die Performance irrelevant ist, sondern Lesbarkeit hinzukriegen ist die Herausforderung - weils eben ein schwieriges Thema ist.
    Wie gesagt:
    • Bei banalen Concatenationen ist StringBuilder Quatsch (zB dim truth = "StringBuilder" & "wäre" & "hier" & "Quatsch")
    • Und auch bei anspruchsvollen StringVerarbeitungen ist der Performance-Gewinn gradezu grotesk irrelevant.
      ABer SB ist bei anspruchsvollen StringVerarbeitungen in Punkto Lesbarkeit meist deutlich weniger geeignet als andere Mittel.

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

    ErfinderDesRades schrieb:

    Also einfach 2 Strings verketten ist eine Operation

    In dem Fall ist der StringBuilder, als auch die List absoluter Schwachsinn, und wenn deine erste Aussage, die ich zitiert habe, sich ausschließlich darauf bezog, dann habe ich das falsch verstanden.
    Auch was das voreilige Optimieren angeht, sehe ich das genau gleich. Keine Not also die Textform des Herumbrüllens zu verwenden.