System.Text.StringBuilder osztály

Megjegyzés

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

Az StringBuilder osztály egy sztringszerű objektumot jelöl, amelynek értéke egy módosítható karaktersorozat.

StringBuilder és Sztringtípus

StringBuilder Bár String mindkettő karaktersorozatokat jelöl, másképpen implementáljuk őket. String nem módosítható típus. Vagyis minden olyan művelet, amely úgy tűnik, hogy módosít egy objektumot String , valójában létrehoz egy új sztringet.

Az alábbi C#-példában a metódus hívása String.Concat például úgy tűnik, hogy megváltoztatja a nevesített valuesztringváltozó értékét. A metódus valójában egy Concat olyan objektumot ad vissza, value amelynek értéke és címe eltér a value metódusnak átadott objektumtól. Vegye figyelembe, hogy a példát a /unsafe fordítóval kell lefordítani.

using System;

public class Example7
{
    public unsafe static void Main()
    {
        string value = "This is the first sentence" + ".";
        fixed (char* start = value)
        {
            value = String.Concat(value, "This is the second sentence. ");
            fixed (char* current = value)
            {
                Console.WriteLine(start == current);
            }
        }
    }
}
// The example displays the following output:
//      False

    let mutable value = "This is the first sentence" + "."
    use start = fixed value
    value <- System.String.Concat(value, "This is the second sentence. ")
    use current = fixed value
    printfn $"{start = current}"
// The example displays the following output:
//      False

Az olyan rutinok esetében, amelyek széles körű sztringmanipulálást hajtanak végre (például olyan alkalmazásoknál, amelyek többször módosítják a sztringeket egy ciklusban), a sztring ismételt módosítása jelentős teljesítménybeli büntetést vonhat maga után. A másik lehetőség egy módosítható karakterlánc osztály használata, mint például StringBuilder. A módosíthatóság azt jelenti, hogy az osztály egy példányának létrehozása után a karakterek hozzáfűzésével, eltávolításával, cseréjével vagy beszúrásával módosítható.

Fontos

Bár az StringBuilder osztály általában jobb teljesítményt nyújt, mint az String osztály, nem szabad automatikusan lecserélni StringStringBuilder , amikor sztringeket szeretne manipulálni. A teljesítmény a sztring méretétől, az új sztringhez lefoglalt memória mennyiségétől, a kód végrehajtásának rendszerétől és a művelet típusától függ. Fel kell készülnie a kód tesztelésére, hogy megállapítsa, valóban jelentős teljesítménybeli javulást kínál-e StringBuilder .

Fontolja meg az String osztály használatát az alábbi feltételek mellett:

• Ha a kód által a karakterláncban végrehajtott módosítások száma kicsi. Ezekben az esetekben StringBuilder elhanyagolható vagy semmi javulást kínálhat a teljesítmény terén String-hez képest.
• Ha rögzített számú összefűzési műveletet hajt végre, különösen sztringkonstansokkal. Ebben az esetben a fordító egyetlen műveletbe egyesítheti az összefűzési műveleteket.
• Ha a karakterlánc létrehozásakor átfogó kereséseket kell végrehajtania. Az StringBuilder osztály nem rendelkezik olyan keresési módszerekkel, mint a IndexOf vagy StartsWith. Ezekhez a műveletekhez konvertálnia kell az StringBuilder objektumot egy String objektummá, és ez semmissé teheti a StringBuilder használatából származó teljesítményelőnyt. További információért lásd a StringBuilder objektumban történő keresés szakaszát.

Fontolja meg az StringBuilder osztály használatát az alábbi feltételek mellett:

• Ha azt várja, hogy a kód ismeretlen számú módosítást hajt végre egy sztringen a tervezéskor (például amikor hurkot használ a felhasználói bemenetet tartalmazó sztringek véletlenszerű számának összefűzéséhez).
• Amikor arra számít, hogy a kód jelentős számú módosítást hajt végre egy karakterláncon.

A StringBuilder működése

A StringBuilder.Length tulajdonság az objektum által jelenleg tartalmazott StringBuilder karakterek számát jelzi. Ha karaktereket ad hozzá az StringBuilder objektumhoz, annak hossza addig nő, amíg meg nem egyezik a StringBuilder.Capacity tulajdonság méretével, amely meghatározza az objektum által tartalmazhatott karakterek számát. Ha a hozzáadott karakterek száma miatt az objektum hossza meghaladja az StringBuilder aktuális kapacitást, új memória lesz lefoglalva, a Capacity tulajdonság értéke megduplázódik, új karaktereket ad hozzá az StringBuilder objektumhoz, és Length a tulajdonsága módosul. Az objektum további memóriája StringBuilder dinamikusan lesz lefoglalva, amíg el nem éri a StringBuilder.MaxCapacity tulajdonság által meghatározott értéket. A maximális kapacitás elérésekor nem lehet további memóriát lefoglalni az StringBuilder objektum számára, és ha megpróbál karaktereket hozzáadni vagy kibővíteni azon túl, akkor vagy ArgumentOutOfRangeException vagy OutOfMemoryException kivételt dob.

Az alábbi példa bemutatja, hogyan foglal le egy StringBuilder objektum új memóriát, és hogyan növeli dinamikusan a kapacitását az objektumhoz rendelt sztring kibontásával. A kód létrehoz egy objektumot StringBuilder az alapértelmezett (paraméter nélküli) konstruktor meghívásával. Az objektum alapértelmezett kapacitása 16 karakter, maximális kapacitása pedig több mint 2 milliárd karakter. Az "Ez egy mondat" sztring hozzáfűzése új memóriafoglalást eredményez, mert a karakterlánc hossza (19 karakter) meghaladja az StringBuilder objektum alapértelmezett kapacitását. Az objektum kapacitása 32 karakterre nő, az új sztring hozzáadódik, és az objektum hossza mostantól 19 karakter. A kód ezután hozzáfűzi az "Ez egy további mondat" sztringet az StringBuilder objektum értékéhez 11-szer. Amikor a hozzáfűzési művelet miatt az StringBuilder objektum hossza meghaladja a kapacitását, a meglévő kapacitás megduplázódik, és a Append művelet sikeres lesz.

using System;
using System.Reflection;
using System.Text;

public class Example4
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder();
        ShowSBInfo(sb);
        sb.Append("This is a sentence.");
        ShowSBInfo(sb);
        for (int ctr = 0; ctr <= 10; ctr++)
        {
            sb.Append("This is an additional sentence.");
            ShowSBInfo(sb);
        }
    }

    private static void ShowSBInfo(StringBuilder sb)
    {
        foreach (var prop in sb.GetType().GetProperties())
        {
            if (prop.GetIndexParameters().Length == 0)
                Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    Capacity: 16    MaxCapacity: 2,147,483,647    Length: 0
//    Capacity: 32    MaxCapacity: 2,147,483,647    Length: 19
//    Capacity: 64    MaxCapacity: 2,147,483,647    Length: 50
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 81
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 112
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 143
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 174
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 205
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 236
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 267
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 298
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 329
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 360

open System.Text

let showSBInfo (sb: StringBuilder) =
    for prop in sb.GetType().GetProperties() do
        if prop.GetIndexParameters().Length = 0 then
            printf $"{prop.Name}: {prop.GetValue sb:N0}    "

    printfn ""

let sb = StringBuilder()
showSBInfo sb
sb.Append "This is a sentence." |> ignore
showSBInfo sb

for i = 0 to 10 do
    sb.Append "This is an additional sentence." |> ignore
    showSBInfo sb

// The example displays the following output:
//    Capacity: 16    MaxCapacity: 2,147,483,647    Length: 0
//    Capacity: 32    MaxCapacity: 2,147,483,647    Length: 19
//    Capacity: 64    MaxCapacity: 2,147,483,647    Length: 50
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 81
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 112
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 143
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 174
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 205
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 236
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 267
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 298
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 329
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 360

Imports System.Reflection
Imports System.Text

Module Example5
    Public Sub Main()
        Dim sb As New StringBuilder()
        ShowSBInfo(sb)
        sb.Append("This is a sentence.")
        ShowSBInfo(sb)
        For ctr As Integer = 0 To 10
            sb.Append("This is an additional sentence.")
            ShowSBInfo(sb)
        Next
    End Sub

    Public Sub ShowSBInfo(sb As StringBuilder)
        For Each prop In sb.GetType().GetProperties
            If prop.GetIndexParameters().Length = 0 Then
                Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
            End If
        Next
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    Capacity: 16    MaxCapacity: 2,147,483,647    Length: 0
'    Capacity: 32    MaxCapacity: 2,147,483,647    Length: 19
'    Capacity: 64    MaxCapacity: 2,147,483,647    Length: 50
'    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 81
'    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 112
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 143
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 174
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 205
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 236
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 267
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 298
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 329
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 360

Memóriafoglalás

Egy StringBuilder objektum alapértelmezett kapacitása 16 karakter, és az alapértelmezett maximális kapacitása Int32.MaxValue. Ezeket az alapértelmezett értékeket használja a rendszer, ha meghívja a StringBuilder() konstruktorokat StringBuilder(String) .

Az objektumok kezdeti kapacitását StringBuilder az alábbi módokon határozhatja meg explicit módon:

• Az objektum létrehozásakor bármely StringBuilder konstruktor meghívásával, amely tartalmaz egy capacity paramétert.
• Ha explicit módon rendel hozzá egy új értéket a StringBuilder.Capacity tulajdonsághoz egy meglévő StringBuilder objektum kibontásához. (A tulajdonság kivételt jelent, ha az új kapacitás kisebb a meglévő kapacitásnál, vagy nagyobb az StringBuilder objektum maximális kapacitásánál.)
• Az új kapacitás megadásával hívja meg a StringBuilder.EnsureCapacity metódust. Az új kapacitás nem lehet nagyobb az StringBuilder objektum maximális kapacitásánál. A tulajdonság hozzárendelésétől Capacity eltérően azonban nem okoz kivételt, EnsureCapacity ha a kívánt új kapacitás kisebb, mint a meglévő kapacitás. Ebben az esetben a metódushívásnak nincs hatása.

Ha a konstruktorhívásban az StringBuilder objektumhoz rendelt sztring hossza meghaladja az alapértelmezett kapacitást vagy a megadott kapacitást, a Capacity tulajdonság a paraméterrel megadott sztring hosszára value van állítva.

A konstruktor meghívásával explicit módon meghatározhatja az StringBuilder objektumok maximális kapacitását StringBuilder(Int32, Int32) . A maximális kapacitás nem módosítható úgy, hogy új értéket rendel hozzá a MaxCapacity tulajdonsághoz, mert az csak olvasható.

Ahogy az előző szakaszban is látható, ha a meglévő kapacitás nem megfelelő, a rendszer további memóriát foglal le, és az StringBuilder objektum kapacitása a tulajdonság által MaxCapacity meghatározott értékre megduplázódik.

Általánosságban elmondható, hogy az alapértelmezett kapacitás és a maximális kapacitás a legtöbb alkalmazás számára megfelelő. Ezeket az értékeket a következő feltételek mellett érdemes lehet beállítani:

• Ha az StringBuilder objektum végső mérete valószínűleg rendkívül nagy, általában több megabájtot meghaladó méretű lesz. Ebben az esetben előfordulhat, hogy a kezdeti Capacity tulajdonságot jelentősen magas értékre állítsuk, hogy elkerüljük a túl sok memória-újrafoglalást.
• Ha a kód korlátozott memóriával rendelkező rendszeren fut. Ebben az esetben érdemes lehet a MaxCapacity tulajdonságot kisebbre állítani, mint Int32.MaxValue ha a kód nagy sztringeket kezel, amelyek miatt memóriakorlátozott környezetben fut.

StringBuilder-objektum példányosítása

StringBuilder objektumot példányosíthat az alábbi táblázatban felsorolt hat túlterhelt osztálykonstruktor egyikének meghívásával. A konstruktorok közül három példányosít egy StringBuilder objektumot, amelynek értéke egy üres karakterlánc, de a Capacity és MaxCapacity értékeit különbözőképpen állítja be. A fennmaradó három konstruktor meghatároz egy StringBuilder objektumot, amely egy adott sztringértéket és kapacitást tartalmaz. A három konstruktor közül kettő az alapértelmezett maximális kapacitást Int32.MaxValuehasználja, míg a harmadik lehetővé teszi a maximális kapacitás beállítását.

Konstruktor	Karakterlánc érték	Kapacitás	Maximális kapacitás
StringBuilder()	String.Empty	16	Int32.MaxValue
StringBuilder(Int32)	String.Empty	A capacity paraméter határozza meg	Int32.MaxValue
StringBuilder(Int32, Int32)	String.Empty	A capacity paraméter határozza meg	A maxCapacity paraméter határozza meg
StringBuilder(String)	A value paraméter határozza meg	16 vagy value. Length, amelyik nagyobb	Int32.MaxValue
StringBuilder(String, Int32)	A value paraméter határozza meg	Meghatározva a capacity paraméter vagy value által. Length, amelyik nagyobb.	Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32)	Definiálva: value. Substring(startIndex, length)	Meghatározva a capacity paraméter vagy value által. Length, amelyik nagyobb.	Int32.MaxValue

Az alábbi példa három konstruktor túlterhelést használ a StringBuilder objektumok példányosításához.

using System;
using System.Text;

public class Example8
{
    public static void Main()
    {
        string value = "An ordinary string";
        int index = value.IndexOf("An ") + 3;
        int capacity = 0xFFFF;

        // Instantiate a StringBuilder from a string.
        StringBuilder sb1 = new StringBuilder(value);
        ShowSBInfo(sb1);

        // Instantiate a StringBuilder from string and define a capacity.  
        StringBuilder sb2 = new StringBuilder(value, capacity);
        ShowSBInfo(sb2);

        // Instantiate a StringBuilder from substring and define a capacity.  
        StringBuilder sb3 = new StringBuilder(value, index,
                                              value.Length - index,
                                              capacity);
        ShowSBInfo(sb3);
    }

    public static void ShowSBInfo(StringBuilder sb)
    {
        Console.WriteLine($"\nValue: {sb.ToString()}");
        foreach (var prop in sb.GetType().GetProperties())
        {
            if (prop.GetIndexParameters().Length == 0)
                Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    Value: An ordinary string
//    Capacity: 18    MaxCapacity: 2,147,483,647    Length: 18
//    
//    Value: An ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 18
//    
//    Value: ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 15

open System.Text

let showSBInfo (sb: StringBuilder) =
    for prop in sb.GetType().GetProperties() do
        if prop.GetIndexParameters().Length = 0 then
            printf $"{prop.Name}: {prop.GetValue sb:N0}    "

    printfn ""

let value = "An ordinary string"
let index = value.IndexOf "An " + 3
let capacity = 0xFFFF

// Instantiate a StringBuilder from a string.
let sb1 = StringBuilder value
showSBInfo sb1

// Instantiate a StringBuilder from string and define a capacity.
let sb2 = StringBuilder(value, capacity)
showSBInfo sb2

// Instantiate a StringBuilder from substring and define a capacity.
let sb3 = StringBuilder(value, index, value.Length - index, capacity)
showSBInfo sb3

// The example displays the following output:
//    Value: An ordinary string
//    Capacity: 18    MaxCapacity: 2,147,483,647    Length: 18
//
//    Value: An ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 18
//
//    Value: ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 15

Imports System.Text

Module Example8
    Public Sub Main()
        Dim value As String = "An ordinary string"
        Dim index As Integer = value.IndexOf("An ") + 3
        Dim capacity As Integer = &HFFFF

        ' Instantiate a StringBuilder from a string.
        Dim sb1 As New StringBuilder(value)
        ShowSBInfo(sb1)

        ' Instantiate a StringBuilder from string and define a capacity.  
        Dim sb2 As New StringBuilder(value, capacity)
        ShowSBInfo(sb2)

        ' Instantiate a StringBuilder from substring and define a capacity.  
        Dim sb3 As New StringBuilder(value, index,
                                   value.Length - index,
                                   capacity)
        ShowSBInfo(sb3)
    End Sub

    Public Sub ShowSBInfo(sb As StringBuilder)
        Console.WriteLine()
        Console.WriteLine("Value: {0}", sb.ToString())
        For Each prop In sb.GetType().GetProperties
            If prop.GetIndexParameters().Length = 0 Then
                Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
            End If
        Next
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    Value: An ordinary string
'    Capacity: 18    MaxCapacity: 2,147,483,647    Length: 18
'    
'    Value: An ordinary string
'    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 18
'    
'    Value: ordinary string
'    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 15

StringBuilder metódusok meghívása

A StringBuilder példány stringjét módosító metódusok többsége ugyanarra a példányra mutató hivatkozást ad vissza. Kétféleképpen hívhatja meg a StringBuilder metódusokat:

• Egyéni metódushívásokat kezdeményezhet, és figyelmen kívül hagyhatja a visszatérési értéket, ahogy az alábbi példában is látható.

  using System;
  using System.Text;
  
  public class Example
  {
     public static void Main()
     {
        StringBuilder sb = new StringBuilder();
        sb.Append("This is the beginning of a sentence, ");
        sb.Replace("the beginning of ", "");
        sb.Insert(sb.ToString().IndexOf("a ") + 2, "complete ");
        sb.Replace(",", ".");
        Console.WriteLine(sb.ToString());
     }
  }
  // The example displays the following output:
  //        This is a complete sentence.
  

  open System.Text
  
  let sb = StringBuilder()
  sb.Append "This is the beginning of a sentence, " |> ignore
  sb.Replace("the beginning of ", "") |> ignore
  sb.Insert((string sb).IndexOf "a " + 2, "complete ") |> ignore
  sb.Replace(",", ".") |> ignore
  printfn $"{sb}"
  // The example displays the following output:
  //        This is a complete sentence.
  

  Imports System.Text
  
  Module Example2
      Public Sub Main()
          Dim sb As New StringBuilder()
          sb.Append("This is the beginning of a sentence, ")
          sb.Replace("the beginning of ", "")
          sb.Insert(sb.ToString().IndexOf("a ") + 2, "complete ")
          sb.Replace(",", ".")
          Console.WriteLine(sb.ToString())
      End Sub
  End Module
  ' The example displays the following output:
  '       This is a complete sentence.
  

• Egyetlen utasításban sorozatos metódushívásokat is kezdeményezhet. Ez akkor lehet kényelmes, ha egyetlen utasítást szeretne írni, amely egymást követő műveleteket láncba láncolni. Az alábbi példa három metódushívást összesít az előző példából egyetlen kódsorba.

  using System;
  using System.Text;
  
  public class Example2
  {
      public static void Main()
      {
          StringBuilder sb = new StringBuilder("This is the beginning of a sentence, ");
          sb.Replace("the beginning of ", "").Insert(sb.ToString().IndexOf("a ") + 2,
                                                     "complete ").Replace(",", ".");
          Console.WriteLine(sb.ToString());
      }
  }
  // The example displays the following output:
  //        This is a complete sentence.
  

  open System.Text
  
  let sb = StringBuilder "This is the beginning of a sentence, "
  
  sb
      .Replace("the beginning of ", "")
      .Insert((string sb).IndexOf "a " + 2, "complete ")
      .Replace(",", ".")
  |> ignore
  
  printfn $"{sb}"
  // The example displays the following output:
  //        This is a complete sentence.
  

  Imports System.Text
  
  Module Example3
      Public Sub Main()
          Dim sb As New StringBuilder("This is the beginning of a sentence, ")
          sb.Replace("the beginning of ", "").Insert(sb.ToString().IndexOf("a ") + 2,
                                                   "complete ").Replace(", ", ".")
          Console.WriteLine(sb.ToString())
      End Sub
  End Module
  ' The example displays the following output:
  '       This is a complete sentence.
  

StringBuilder-műveletek végrehajtása

Az osztály metódusaival StringBuilder iterálhat, adhat hozzá, törölhet vagy módosíthat karaktereket egy StringBuilder objektumban.

Sztringbuilder-karakterek iterálása

Az objektumban lévő StringBuilder karaktereket a StringBuilder.Chars[] tulajdonság használatával érheti el. A C#- Chars[] ban indexelő; a Visual Basicben ez az StringBuilder osztály alapértelmezett tulajdonsága. Ez lehetővé teszi, hogy az egyes karaktereket csak az indexük használatával állítsa be vagy kérje le anélkül, hogy explicit módon hivatkozik a Chars[Int32] tulajdonságra. Az StringBuilder objektum karakterei a 0 indexnél (nulla) kezdődnek, és továbbra is indexelnek Length – 1.

Az alábbi példa a tulajdonságot szemlélteti Chars[Int32] . Tíz véletlenszerű számot fűz hozzá egy StringBuilder objektumhoz, majd iterálja az egyes karaktereket. Ha a karakter Unicode-kategóriája, UnicodeCategory.DecimalDigitNumberakkor 1-sel csökkenti a számot (vagy 9-esre módosítja a számot, ha értéke 0). A példa az objektum tartalmát jeleníti meg az StringBuilder egyes karakterek értékeinek módosítása előtt és után is.

using System;
using System.Globalization;
using System.Text;

public class Example3
{
    public static void Main()
    {
        Random rnd = new Random();
        StringBuilder sb = new StringBuilder();

        // Generate 10 random numbers and store them in a StringBuilder.
        for (int ctr = 0; ctr <= 9; ctr++)
            sb.Append(rnd.Next().ToString("N5"));

        Console.WriteLine("The original string:");
        Console.WriteLine(sb.ToString());

        // Decrease each number by one.
        for (int ctr = 0; ctr < sb.Length; ctr++)
        {
            if (Char.GetUnicodeCategory(sb[ctr]) == UnicodeCategory.DecimalDigitNumber)
            {
                int number = (int)Char.GetNumericValue(sb[ctr]);
                number--;
                if (number < 0) number = 9;

                sb[ctr] = number.ToString()[0];
            }
        }
        Console.WriteLine("\nThe new string:");
        Console.WriteLine(sb.ToString());
    }
}
// The example displays the following output:
//    The original string:
//    1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
//    000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
//    .00000
//    
//    The new string:
//    0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
//    999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
//    .99999

open System
open System.Globalization
open System.Text

let rnd = Random()
let sb = new StringBuilder()

// Generate 10 random numbers and store them in a StringBuilder.
for _ = 0 to 9 do
    rnd.Next().ToString "N5" |> sb.Append |> ignore

printfn "The original string:"
printfn $"{sb}"

// Decrease each number by one.
for i = 0 to sb.Length - 1 do
    if Char.GetUnicodeCategory(sb[i]) = UnicodeCategory.DecimalDigitNumber then
        let number = Char.GetNumericValue sb.[i] |> int
        let number = number - 1
        let number = if number < 0 then 9 else number
        sb.[i] <- number.ToString()[0]

printfn "\nThe new string:"
printfn $"{sb}"

// The example displays the following output:
//    The original string:
//    1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
//    000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
//    .00000
//
//    The new string:
//    0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
//    999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
//    .99999

Imports System.Globalization
Imports System.Text

Module Example4
    Public Sub Main()
        Dim rnd As New Random()
        Dim sb As New StringBuilder()

        ' Generate 10 random numbers and store them in a StringBuilder.
        For ctr As Integer = 0 To 9
            sb.Append(rnd.Next().ToString("N5"))
        Next
        Console.WriteLine("The original string:")
        Console.WriteLine(sb.ToString())
        Console.WriteLine()

        ' Decrease each number by one.
        For ctr As Integer = 0 To sb.Length - 1
            If Char.GetUnicodeCategory(sb(ctr)) = UnicodeCategory.DecimalDigitNumber Then
                Dim number As Integer = CType(Char.GetNumericValue(sb(ctr)), Integer)
                number -= 1
                If number < 0 Then number = 9

                sb(ctr) = number.ToString()(0)
            End If
        Next
        Console.WriteLine("The new string:")
        Console.WriteLine(sb.ToString())
    End Sub
End Module
' The example displays the following output:
'    The original string:
'    1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
'    000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
'    .00000
'    
'    The new string:
'    0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
'    999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
'    .99999

A karakteralapú indexelés a tulajdonsággal Chars[Int32] rendkívül lassú lehet a következő feltételek mellett:

• A StringBuilder példány nagy (például több tízezer karakterből áll).
• Az StringBuilder "darabos". Más szóval, az olyan metódusok ismételt hívásai, mint a StringBuilder.Append, automatikusan kibővítették az objektum StringBuilder.Capacity tulajdonságát, és új memóriaegységeket allokáltak hozzá.

A teljesítményre súlyos hatással van, mert minden karakterhozzáférés végigvezeti az adattömbök teljes csatolt listáját, hogy megtalálja a megfelelő puffert az indexeléshez.

Megjegyzés

Még egy nagy méretű, "masszív" StringBuilder objektum esetén is az Chars[Int32] tulajdonság használata indexalapú eléréshez egy vagy kevés számú karakter esetében elhanyagolható teljesítménybeli hatással jár; rendszerint ez egy O(n) művelet. A jelentős teljesítményhatás az objektum karaktereinek StringBuilder iterálásakor jelentkezik, amely egy O(n^2) művelet.

Ha teljesítményproblémákat tapasztal a karakteralapú indexelés objektumokkal StringBuilder való használatakor, az alábbi megkerülő megoldások bármelyikét használhatja:

• A StringBuilder példányt alakítsa át String-é a ToString metódus meghívásával, majd férjen hozzá a karakterekhez a sztringben.

• Másolja a meglévő StringBuilder objektum tartalmát egy új előméretű StringBuilder objektumba. A teljesítmény javul, mert az új StringBuilder objektum nem darabos. Példa:

  // sbOriginal is the existing StringBuilder object
  var sbNew = new StringBuilder(sbOriginal.ToString(), sbOriginal.Length);
  

  ' sbOriginal is the existing StringBuilder object
  Dim sbNew = New StringBuilder(sbOriginal.ToString(), sbOriginal.Length)
  

• A konstruktor meghívásával állítsa az StringBuilder objektum kezdeti kapacitását olyan értékre, amely körülbelül megegyezik a StringBuilder(Int32) maximálisan várt mérettel. Vegye figyelembe, hogy ez akkor is lefoglalja a teljes memóriablokkot, ha az ritkán éri el a StringBuilder maximális kapacitást.

Szöveg hozzáadása StringBuilder-objektumhoz

Az StringBuilder osztály az alábbi metódusokat tartalmazza egy StringBuilder objektum tartalmának kibontásához:

• A Append metódus sztringet, alsztringet, karaktertömböt, egy karaktertömb egy részét, egy többször ismétlődő karaktert vagy egy primitív adattípus sztringképét fűzi hozzá egy StringBuilder objektumhoz.

• A AppendLine metódus hozzáfűz egy vonal-terminátort vagy egy sztringet, valamint egy vonal-terminátort egy StringBuilder objektumhoz.

• A AppendFormat metódus egy összetett formátumú sztringet fűz egy StringBuilder objektumhoz. Az eredménysztringben szereplő objektumok sztringreprezentációi tükrözhetik az aktuális rendszerkultúra vagy egy adott kultúra formázási konvencióit.

• A Insert metódus beszúr egy sztringet, egy részsztringet, egy sztring több ismétlését, egy karaktertömböt, egy karaktertömb egy részét, vagy egy primitív adattípus sztring-ábrázolását az StringBuilder objektum adott helyén. A pozíciót egy nulla alapú index határozza meg.

Az alábbi példa a Append, AppendLine, AppendFormatés Insert metódusok használatával bontja ki egy StringBuilder objektum szövegét.

using System;
using System.Text;

public class Example6
{
    public static void Main()
    {
        // Create a StringBuilder object with no text.
        StringBuilder sb = new StringBuilder();
        // Append some text.
        sb.Append('*', 10).Append(" Adding Text to a StringBuilder Object ").Append('*', 10);
        sb.AppendLine("\n");
        sb.AppendLine("Some code points and their corresponding characters:");
        // Append some formatted text.
        for (int ctr = 50; ctr <= 60; ctr++)
        {
            sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr));
            sb.AppendLine();
        }
        // Find the end of the introduction to the column.
        int pos = sb.ToString().IndexOf("characters:") + 11 +
                  Environment.NewLine.Length;
        // Insert a column header.
        sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit",
                                     "Character", "\n"));

        // Convert the StringBuilder to a string and display it.      
        Console.WriteLine(sb.ToString());
    }
}
// The example displays the following output:
//    ********** Adding Text to a StringBuilder Object **********
//    
//    Some code points and their corresponding characters:
//    
//       Code Unit    Character
//            0032            2
//            0033            3
//            0034            4
//            0035            5
//            0036            6
//            0037            7
//            0038            8
//            0039            9
//            003A            :
//            003B            ;
//            003C            <

open System
open System.Text

// Create a StringBuilder object with no text.
let sb = StringBuilder()
// Append some text.
sb
    .Append('*', 10)
    .Append(" Adding Text to a StringBuilder Object ")
    .Append('*', 10)
|> ignore

sb.AppendLine "\n" |> ignore
sb.AppendLine "Some code points and their corresponding characters:" |> ignore
// Append some formatted text.
for i = 50 to 60 do
    sb.AppendFormat("{0,12:X4} {1,12}", i, Convert.ToChar i) |> ignore
    sb.AppendLine() |> ignore

// Find the end of the introduction to the column.
let pos = (string sb).IndexOf("characters:") + 11 + Environment.NewLine.Length
// Insert a column header.
sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit", "Character", "\n"))
|> ignore

// Convert the StringBuilder to a string and display it.
printfn $"{sb}"


// The example displays the following output:
//    ********** Adding Text to a StringBuilder Object **********
//
//    Some code points and their corresponding characters:
//
//       Code Unit    Character
//            0032            2
//            0033            3
//            0034            4
//            0035            5
//            0036            6
//            0037            7
//            0038            8
//            0039            9
//            003A            :
//            003B            ;
//            003C            <

Imports System.Text

Module Example7
    Public Sub Main()
        ' Create a StringBuilder object with no text.
        Dim sb As New StringBuilder()
        ' Append some text.
        sb.Append("*"c, 10).Append(" Adding Text to a StringBuilder Object ").Append("*"c, 10)
        sb.AppendLine()
        sb.AppendLine()
        sb.AppendLine("Some code points and their corresponding characters:")
        ' Append some formatted text.
        For ctr = 50 To 60
            sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr))
            sb.AppendLine()
        Next
        ' Find the end of the introduction to the column.
        Dim pos As Integer = sb.ToString().IndexOf("characters:") + 11 +
                           Environment.NewLine.Length
        ' Insert a column header.
        sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit",
                                   "Character", vbCrLf))

        ' Convert the StringBuilder to a string and display it.      
        Console.WriteLine(sb.ToString())
    End Sub
End Module
' The example displays the following output:
'       ********** Adding Text to a StringBuilder Object **********
'       
'       Some code points and their corresponding characters:
'       
'          Code Unit    Character
'               0032            2
'               0033            3
'               0034            4
'               0035            5
'               0036            6
'               0037            7
'               0038            8
'               0039            9
'               003A            :
'               003B            ;
'               003C            <

Szöveg törlése StringBuilder-objektumból

Az StringBuilder osztály olyan metódusokat tartalmaz, amelyek csökkenthetik az aktuális StringBuilder példány méretét. A Clear metódus eltávolítja az összes karaktert, és nullára állítja a Length tulajdonságot. A Remove metódus egy megadott számú karaktert töröl egy adott indexpozíciótól kezdve. Ezenkívül eltávolíthat karaktereket az StringBuilder objektumok végéről úgy, hogy a tulajdonságát Length az aktuális példány hosszánál kisebb értékre állítja.

Az alábbi példa eltávolítja a szöveg egy részét egy StringBuilder objektumból, megjeleníti az eredményként kapott kapacitást, maximális kapacitást és hossztulajdonság-értékeket, majd meghívja a Clear metódust, hogy távolítsa el az összes karaktert az StringBuilder objektumból.

using System;
using System.Text;

public class Example5
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder("A StringBuilder object");
        ShowSBInfo(sb);
        // Remove "object" from the text.
        string textToRemove = "object";
        int pos = sb.ToString().IndexOf(textToRemove);
        if (pos >= 0)
        {
            sb.Remove(pos, textToRemove.Length);
            ShowSBInfo(sb);
        }
        // Clear the StringBuilder contents.
        sb.Clear();
        ShowSBInfo(sb);
    }

    public static void ShowSBInfo(StringBuilder sb)
    {
        Console.WriteLine($"\nValue: {sb.ToString()}");
        foreach (var prop in sb.GetType().GetProperties())
        {
            if (prop.GetIndexParameters().Length == 0)
                Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    Value: A StringBuilder object
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 22
//    
//    Value: A StringBuilder
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 16
//    
//    Value:
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 0

open System.Text

let showSBInfo (sb: StringBuilder) =
    for prop in sb.GetType().GetProperties() do
        if prop.GetIndexParameters().Length = 0 then
            printf $"{prop.Name}: {prop.GetValue sb:N0}    "

    printfn ""

let sb = StringBuilder "A StringBuilder object"
showSBInfo sb
// Remove "object" from the text.
let textToRemove = "object"
let pos = (string sb).IndexOf textToRemove

if pos >= 0 then
    sb.Remove(pos, textToRemove.Length) |> ignore
    showSBInfo sb

// Clear the StringBuilder contents.
sb.Clear() |> ignore
showSBInfo sb

// The example displays the following output:
//    Value: A StringBuilder object
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 22
//
//    Value: A StringBuilder
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 16
//
//    Value:
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 0

Imports System.Text

Module Example6
    Public Sub Main()
        Dim sb As New StringBuilder("A StringBuilder object")
        ShowSBInfo(sb)
        ' Remove "object" from the text.
        Dim textToRemove As String = "object"
        Dim pos As Integer = sb.ToString().IndexOf(textToRemove)
        If pos >= 0 Then
            sb.Remove(pos, textToRemove.Length)
            ShowSBInfo(sb)
        End If
        ' Clear the StringBuilder contents.
        sb.Clear()
        ShowSBInfo(sb)
    End Sub

    Public Sub ShowSBInfo(sb As StringBuilder)
        Console.WriteLine()
        Console.WriteLine("Value: {0}", sb.ToString())
        For Each prop In sb.GetType().GetProperties
            If prop.GetIndexParameters().Length = 0 Then
                Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
            End If
        Next
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    Value: A StringBuilder object
'    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 22
'    
'    Value: A StringBuilder
'    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 16
'    
'    Value:
'    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 0

Szöveg módosítása StringBuilder-objektumban

A StringBuilder.Replace metódus lecseréli egy karakter vagy egy sztring összes előfordulását a teljes StringBuilder objektumban vagy egy adott karaktertartományban. Az alábbi példa a Replace metódust használja, hogy az összes felkiáltójelet (!) kérdőjellé (?) cserélje az StringBuilder objektumban.

using System;
using System.Text;

public class Example13
{
    public static void Main()
    {
        StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
        MyStringBuilder.Replace('!', '?');
        Console.WriteLine(MyStringBuilder);
    }
}
// The example displays the following output:
//       Hello World?

open System.Text

let myStringBuilder = StringBuilder "Hello World!"
myStringBuilder.Replace('!', '?') |> ignore
printfn $"{myStringBuilder}"

// The example displays the following output:
//       Hello World?

Imports System.Text

Module Example
   Public Sub Main()
      Dim MyStringBuilder As New StringBuilder("Hello World!")
      MyStringBuilder.Replace("!"c, "?"c)
      Console.WriteLine(MyStringBuilder)
   End Sub
End Module
' The example displays the following output:
'       Hello World?

Szöveg keresése StringBuilder-objektumban

Az StringBuilder osztály nem tartalmaz olyan metódusokat, amelyek hasonlóak a String.Contains osztály által nyújtott String.IndexOf, String.StartsWith és String metódusokhoz, amelyek lehetővé teszik az objektumban egy adott karakter vagy alsztring keresését. A részszekvenciák jelenlétének vagy kezdőkarakter pozíciójának meghatározásához vagy sztringkeresési módszert, vagy reguláris kifejezési módszert alkalmazva keresnie kell egy String értéket. Az ilyen keresések megvalósításának négy módja van, ahogy az alábbi táblázat is mutatja.

Módszer	Előnyök	Hátrányok
Sztringértékek keresése, mielőtt hozzáadja őket az StringBuilder objektumhoz.	Hasznos annak meghatározásához, hogy létezik-e egy részszöveg.	Nem használható, ha egy részsztring indexpozíciója fontos.
Hívja meg ToString és keresse meg a visszaadott String objektumot.	Könnyen használható, ha az összes szöveget egy StringBuilder objektumhoz rendeli, majd elkezdi módosítani.	Nehézkes a többszöri hívás ToString , ha módosításokat kell végrehajtania, mielőtt az összes szöveg hozzá lesz adva az StringBuilder objektumhoz. Ha módosításokat végez, ne felejtse el az objektum szövegének StringBuilder végéről dolgoznia.
Chars[Int32] A tulajdonság használatával egymás után kereshet egy karaktertartományt.	Hasznos, ha egyéni karaktereket vagy kis részstringeket szeretne használni.	Nehézkes, ha a keresendő karakterek száma nagy, vagy ha a keresési logika összetett. Az ismétlődő metódushívások által nagyon megnövekedett méretű objektumok teljesítménye rendkívül gyenge.
Alakítsa át az StringBuilder objektumot objektummá String , és végezze el a módosításokat az String objektumon.	Akkor hasznos, ha a módosítások száma kicsi.	Az StringBuilder osztály teljesítménybeli előnyét tagadja, ha a módosítások száma nagy.

Vizsgáljuk meg részletesebben ezeket a technikákat.

• Ha a keresés célja annak megállapítása, hogy létezik-e egy adott részsztring (vagyis ha nem érdekli az alsztring helye), sztringeket kereshet, mielőtt az StringBuilder objektumban tárolhatja őket. Az alábbi példa egy lehetséges implementációt kínál. Definiál egy osztályt StringBuilderFinder , amelynek konstruktorát egy objektumra StringBuilder mutató hivatkozás és a sztringben keresendő részsztring adja meg. Ebben az esetben a példa megpróbálja megállapítani, hogy a rögzített hőmérsékletek Fahrenheitben vagy Celsiusban vannak-e, és hozzáadja a megfelelő bevezető szöveget az StringBuilder objektum elejéhez. A véletlenszerű számgenerátor egy olyan tömb kiválasztására szolgál, amely Celsius-fokban vagy Fahrenheit-fokban lévő adatokat tartalmaz.

  using System;
  using System.Text;
  
  public class Example9
  {
      public static void Main()
      {
          Random rnd = new Random();
          string[] tempF = { "47.6F", "51.3F", "49.5F", "62.3F" };
          string[] tempC = { "21.2C", "16.1C", "23.5C", "22.9C" };
          string[][] temps = { tempF, tempC };
  
          StringBuilder sb = new StringBuilder();
          var f = new StringBuilderFinder(sb, "F");
          var baseDate = new DateTime(2013, 5, 1);
          String[] temperatures = temps[rnd.Next(2)];
          bool isFahrenheit = false;
          foreach (var temperature in temperatures)
          {
              if (isFahrenheit)
                  sb.AppendFormat("{0:d}: {1}\n", baseDate, temperature);
              else
                  isFahrenheit = f.SearchAndAppend(String.Format("{0:d}: {1}\n",
                                                   baseDate, temperature));
              baseDate = baseDate.AddDays(1);
          }
          if (isFahrenheit)
          {
              sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit");
              sb.Insert(47, "\n\n");
          }
          else
          {
              sb.Insert(0, "Average Daily Temperature in Degrees Celsius");
              sb.Insert(44, "\n\n");
          }
          Console.WriteLine(sb.ToString());
      }
  }
  
  public class StringBuilderFinder
  {
      private StringBuilder sb;
      private String text;
  
      public StringBuilderFinder(StringBuilder sb, String textToFind)
      {
          this.sb = sb;
          this.text = textToFind;
      }
  
      public bool SearchAndAppend(String stringToSearch)
      {
          sb.Append(stringToSearch);
          return stringToSearch.Contains(text);
      }
  }
  // The example displays output similar to the following:
  //    Average Daily Temperature in Degrees Celsius
  //    
  //    5/1/2013: 21.2C
  //    5/2/2013: 16.1C
  //    5/3/2013: 23.5C
  //    5/4/2013: 22.9C
  

  open System
  open System.Text
  
  type StringBuilderFinder(sb: StringBuilder, textToFind: string) =
      member _.SearchAndAppend(stringToSearch: string) =
          sb.Append stringToSearch |> ignore
          stringToSearch.Contains textToFind
  
  let tempF = [| "47.6F"; "51.3F"; "49.5F"; "62.3F" |]
  let tempC = [| "21.2C"; "16.1C"; "23.5C"; "22.9C" |]
  let temps = [| tempF; tempC |]
  
  let sb = StringBuilder()
  let f = StringBuilderFinder(sb, "F")
  let temperatures = temps[Random.Shared.Next(2)]
  let mutable baseDate = DateTime(2013, 5, 1)
  let mutable isFahrenheit = false
  
  for temperature in temperatures do
      if isFahrenheit then
          sb.AppendFormat("{0:d}: {1}\n", baseDate, temperature) |> ignore
      else
          isFahrenheit <- $"{baseDate:d}: {temperature}\n" |> f.SearchAndAppend
  
      baseDate <- baseDate.AddDays 1
  
  if isFahrenheit then
      sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit") |> ignore
      sb.Insert(47, "\n\n") |> ignore
  
  else
      sb.Insert(0, "Average Daily Temperature in Degrees Celsius") |> ignore
      sb.Insert(44, "\n\n") |> ignore
  
  printfn $"{sb}"
  
  // The example displays output similar to the following:
  //    Average Daily Temperature in Degrees Celsius
  //
  //    5/1/2013: 21.2C
  //    5/2/2013: 16.1C
  //    5/3/2013: 23.5C
  //    5/4/2013: 22.9C
  

  Imports System.Text
  
  Module Example9
      Public Sub Main()
          Dim rnd As New Random()
          Dim tempF() As String = {"47.6F", "51.3F", "49.5F", "62.3F"}
          Dim tempC() As String = {"21.2C", "16.1C", "23.5C", "22.9C"}
          Dim temps()() As String = {tempF, tempC}
  
          Dim sb As StringBuilder = New StringBuilder()
          Dim f As New StringBuilderFinder(sb, "F")
          Dim baseDate As New DateTime(2013, 5, 1)
          Dim temperatures() As String = temps(rnd.Next(2))
          Dim isFahrenheit As Boolean = False
          For Each temperature In temperatures
              If isFahrenheit Then
                  sb.AppendFormat("{0:d}: {1}{2}", baseDate, temperature, vbCrLf)
              Else
                  isFahrenheit = f.SearchAndAppend(String.Format("{0:d}: {1}{2}",
                                               baseDate, temperature, vbCrLf))
              End If
              baseDate = baseDate.AddDays(1)
          Next
          If isFahrenheit Then
              sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit")
              sb.Insert(47, vbCrLf + vbCrLf)
          Else
              sb.Insert(0, "Average Daily Temperature in Degrees Celsius")
              sb.Insert(44, vbCrLf + vbCrLf)
          End If
          Console.WriteLine(sb.ToString())
      End Sub
  End Module
  
  Public Class StringBuilderFinder
     Private sb As StringBuilder
     Private text As String
     
     Public Sub New(sb As StringBuilder, textToFind As String)
        Me.sb = sb
        text = textToFind
     End Sub
     
     Public Function SearchAndAppend(stringToSearch As String) As Boolean
        sb.Append(stringToSearch)
        Return stringToSearch.Contains(text)
     End Function
  End Class
  ' The example displays output similar to the following:
  '    Average Daily Temperature in Degrees Celsius
  '    
  '    5/1/2013: 21.2C
  '    5/2/2013: 16.1C
  '    5/3/2013: 23.5C
  '    5/4/2013: 22.9C
  

• Az StringBuilder.ToString objektum StringBuilder objektummá alakításához hívja meg a String metódust. Kereshet a sztringben olyan módszerekkel, mint a String.LastIndexOf vagy String.StartsWith, vagy használhatja a reguláris kifejezéseket és az Regex osztályt a minták kereséséhez. Mivel mind StringBuilder az String objektumok UTF-16 kódolással tárolják a karaktereket, a karakterek indexpozíciója, az alsztringek és a reguláris kifejezési egyezések mindkét objektumban megegyeznek. Ez lehetővé teszi, hogy StringBuilder metódusokkal módosításokat hajthat végre ugyanazon a helyen, ahol a szöveg található az String objektumban.

  Megjegyzés

  Ha ezt a megközelítést alkalmazza, az objektum végétől az StringBuilder elejéig kell dolgoznia, hogy ne kelljen ismételten karakterlánccá alakítania az StringBuilder objektumot.

  Az alábbi példa ezt a megközelítést szemlélteti. Az angol ábécé betűinek négy előfordulását tárolja egy StringBuilder objektumban. Ezután objektummá alakítja a szöveget String , és egy reguláris kifejezéssel azonosítja az egyes négy karakterből álló sorozatok kezdő pozícióját. Végül hozzáad egy aláhúzásjelet minden négykarakteres sorozat előtt, kivéve az első sorozatot, és a sorozat első karakterét nagybetűssé alakítja.

  using System;
  using System.Text;
  using System.Text.RegularExpressions;
  
  public class Example10
  {
      public static void Main()
      {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort)'a'; ctr <= (ushort)'z'; ctr++)
              sb.Append(Convert.ToChar(ctr), 4);
  
          // Create a parallel string object.
          String sbString = sb.ToString();
          // Determine where each new character sequence begins.
          String pattern = @"(\w)\1+";
          MatchCollection matches = Regex.Matches(sbString, pattern);
  
          // Uppercase the first occurrence of the sequence, and separate it
          // from the previous sequence by an underscore character.
          for (int ctr = matches.Count - 1; ctr >= 0; ctr--)
          {
              Match m = matches[ctr];
              sb[m.Index] = Char.ToUpper(sb[m.Index]);
              if (m.Index > 0) sb.Insert(m.Index, "_");
          }
          // Display the resulting string.
          sbString = sb.ToString();
          int line = 0;
          do
          {
              int nChars = line * 80 + 79 <= sbString.Length ?
                                  80 : sbString.Length - line * 80;
              Console.WriteLine(sbString.Substring(line * 80, nChars));
              line++;
          } while (line * 80 < sbString.Length);
      }
  }
  // The example displays the following output:
  //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

  open System
  open System.Text
  open System.Text.RegularExpressions
  
  // Create a StringBuilder object with 4 successive occurrences
  // of each character in the English alphabet.
  let sb = StringBuilder()
  
  for char in 'a' .. 'z' do
      sb.Append(char, 4) |> ignore
  
  // Create a parallel string object.
  let sbString = string sb
  // Determine where each new character sequence begins.
  let pattern = @"(\w)\1+"
  let matches = Regex.Matches(sbString, pattern)
  
  // Uppercase the first occurrence of the sequence, and separate it
  // from the previous sequence by an underscore character.
  for i = matches.Count - 1 downto 0 do
      let m = matches[i]
      sb[m.Index] <- Char.ToUpper sb[m.Index]
  
      if m.Index > 0 then
          sb.Insert(m.Index, "_") |> ignore
  
  // Display the resulting string.
  let sbString2 = string sb
  
  for line = 0 to (sbString2.Length - 1) / 80 do
      let nChars =
          if line * 80 + 79 <= sbString2.Length then
              80
          else
              sbString2.Length - line * 80
  
      printfn $"{sbString2.Substring(line * 80, nChars)}"
  
  
  // The example displays the following output:
  //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

  Imports System.Text
  Imports System.Text.RegularExpressions
  
  Module Example10
      Public Sub Main()
          ' Create a StringBuilder object with 4 successive occurrences 
          ' of each character in the English alphabet. 
          Dim sb As New StringBuilder()
          For ctr As UShort = AscW("a") To AscW("z")
              sb.Append(ChrW(ctr), 4)
          Next
          ' Create a parallel string object.
          Dim sbString As String = sb.ToString()
          ' Determine where each new character sequence begins.
          Dim pattern As String = "(\w)\1+"
          Dim matches As MatchCollection = Regex.Matches(sbString, pattern)
  
          ' Uppercase the first occurrence of the sequence, and separate it
          ' from the previous sequence by an underscore character.
          For ctr As Integer = matches.Count - 1 To 0 Step -1
              Dim m As Match = matches(ctr)
              sb.Chars(m.Index) = Char.ToUpper(sb.Chars(m.Index))
              If m.Index > 0 Then sb.Insert(m.Index, "_")
          Next
          ' Display the resulting string.
          sbString = sb.ToString()
          Dim line As Integer = 0
          Do
              Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length,
                                      80, sbString.Length - line * 80)
              Console.WriteLine(sbString.Substring(line * 80, nChars))
              line += 1
          Loop While line * 80 < sbString.Length
      End Sub
  End Module
  ' The example displays the following output:
  '    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  '    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

• StringBuilder.Chars[] A tulajdonság használatával egymás után kereshet egy objektum karaktertartományábanStringBuilder. Ez a megközelítés nem feltétlenül praktikus, ha a keresendő karakterek száma nagy, vagy a keresési logika különösen összetett. A karakterenkénti indexalapú hozzáférés teljesítménybeli következményeiről a nagyméretű és darabolt StringBuilder objektumok esetében a StringBuilder.Chars[] tulajdonság dokumentációja nyújt tájékoztatást.

  Az alábbi példa az előző példával azonos funkcionalitással rendelkezik, de a megvalósításban eltér. A tulajdonság segítségével Chars[Int32] észleli a karakterértékek változását, beszúr egy aláhúzásjelet erre a pozícióra, és nagybetűssé alakítja az új sorozat első karakterét.

  using System;
  using System.Text;
  
  public class Example11
  {
      public static void Main()
      {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort)'a'; ctr <= (ushort)'z'; ctr++)
              sb.Append(Convert.ToChar(ctr), 4);
  
          // Iterate the text to determine when a new character sequence occurs.
          int position = 0;
          Char current = '\u0000';
          do
          {
              if (sb[position] != current)
              {
                  current = sb[position];
                  sb[position] = Char.ToUpper(sb[position]);
                  if (position > 0)
                      sb.Insert(position, "_");
                  position += 2;
              }
              else
              {
                  position++;
              }
          } while (position <= sb.Length - 1);
          // Display the resulting string.
          String sbString = sb.ToString();
          int line = 0;
          do
          {
              int nChars = line * 80 + 79 <= sbString.Length ?
                                  80 : sbString.Length - line * 80;
              Console.WriteLine(sbString.Substring(line * 80, nChars));
              line++;
          } while (line * 80 < sbString.Length);
      }
  }
  // The example displays the following output:
  //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

  open System
  open System.Text
  
  // Create a StringBuilder object with 4 successive occurrences
  // of each character in the English alphabet.
  let sb = StringBuilder()
  
  for char in 'a' .. 'z' do
      sb.Append(char, 4) |> ignore
  
  // Iterate the text to determine when a new character sequence occurs.
  let mutable position = 0
  let mutable current = '\u0000'
  
  while position <= sb.Length - 1 do
      if sb[position] <> current then
          current <- sb[position]
          sb[position] <- Char.ToUpper sb[position]
  
          if position > 0 then
              sb.Insert(position, "_") |> ignore
  
          position <- position + 2
  
      else
          position <- position + 1
  
  // Display the resulting string.
  let sbString = string sb
  
  for line = 0 to (sbString.Length - 1) / 80 do
      let nChars =
          if line * 80 + 79 <= sbString.Length then
              80
          else
              sbString.Length - line * 80
  
      printfn $"{sbString.Substring(line * 80, nChars)}"
  
  // The example displays the following output:
  //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

  Imports System.Text
  
  Module Example11
      Public Sub Main()
          ' Create a StringBuilder object with 4 successive occurrences 
          ' of each character in the English alphabet. 
          Dim sb As New StringBuilder()
          For ctr As UShort = AscW("a") To AscW("z")
              sb.Append(ChrW(ctr), 4)
          Next
          ' Iterate the text to determine when a new character sequence occurs.
          Dim position As Integer = 0
          Dim current As Char = ChrW(0)
          Do
              If sb(position) <> current Then
                  current = sb(position)
                  sb(position) = Char.ToUpper(sb(position))
                  If position > 0 Then sb.Insert(position, "_")
                  position += 2
              Else
                  position += 1
              End If
          Loop While position <= sb.Length - 1
          ' Display the resulting string.
          Dim sbString As String = sb.ToString()
          Dim line As Integer = 0
          Do
              Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length,
                                      80, sbString.Length - line * 80)
              Console.WriteLine(sbString.Substring(line * 80, nChars))
              line += 1
          Loop While line * 80 < sbString.Length
      End Sub
  End Module
  ' The example displays the following output:
  '    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  '    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

• Tárolja az objektumban StringBuilder az összes nem módosított szöveget, hívja meg a StringBuilder.ToString metódust az StringBuilder objektum objektummá String alakításához, és hajtsa végre a módosításokat az String objektumon. Ezt a megközelítést akkor használhatja, ha csak néhány módosítást alkalmaz; ellenkező esetben a nem módosítható sztringek használatának költsége nehezítheti az objektumok használatának StringBuilder teljesítménybeli előnyeit.

  Az alábbi példa a funkcionalitásban megegyezik az előző két példával, de a megvalósításban eltér. Létrehoz egy StringBuilder objektumot, átalakítja azt objektummá String , majd egy reguláris kifejezéssel végrehajtja a sztring összes fennmaradó módosítását. A Regex.Replace(String, String, MatchEvaluator) metódus egy lambda kifejezést használ arra, hogy az egyes egyezéseket lecserélje.

  using System;
  using System.Text;
  using System.Text.RegularExpressions;
  
  public class Example12
  {
      public static void Main()
      {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort)'a'; ctr <= (ushort)'z'; ctr++)
              sb.Append(Convert.ToChar(ctr), 4);
  
          // Convert it to a string.
          String sbString = sb.ToString();
  
          // Use a regex to uppercase the first occurrence of the sequence, 
          // and separate it from the previous sequence by an underscore.
          string pattern = @"(\w)(\1+)";
          sbString = Regex.Replace(sbString, pattern,
                                   m => (m.Index > 0 ? "_" : "") +
                                   m.Groups[1].Value.ToUpper() +
                                   m.Groups[2].Value);
  
          // Display the resulting string.
          int line = 0;
          do
          {
              int nChars = line * 80 + 79 <= sbString.Length ?
                                  80 : sbString.Length - line * 80;
              Console.WriteLine(sbString.Substring(line * 80, nChars));
              line++;
          } while (line * 80 < sbString.Length);
      }
  }
  // The example displays the following output:
  //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

  open System.Text
  open System.Text.RegularExpressions
  
  // Create a StringBuilder object with 4 successive occurrences
  // of each character in the English alphabet.
  let sb = StringBuilder()
  
  for char in 'a' .. 'z' do
      sb.Append(char, 4) |> ignore
  
  // Convert it to a string.
  let sbString = string sb
  
  // Use a regex to uppercase the first occurrence of the sequence,
  // and separate it from the previous sequence by an underscore.
  let pattern = @"(\w)(\1+)"
  
  let sbStringReplaced =
      Regex.Replace(
          sbString,
          pattern,
          fun m ->
              (if m.Index > 0 then "_" else "")
              + m.Groups[ 1 ].Value.ToUpper()
              + m.Groups[2].Value
      )
  
  // Display the resulting string.
  for line = 0 to (sbStringReplaced.Length - 1) / 80 do
      let nChars =
          if line * 80 + 79 <= sbStringReplaced.Length then
              80
          else
              sbStringReplaced.Length - line * 80
  
      printfn $"{sbStringReplaced.Substring(line * 80, nChars)}"
  
  // The example displays the following output:
  //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

  Imports System.Text
  Imports System.Text.RegularExpressions
  
  Module Example12
      Public Sub Main()
          ' Create a StringBuilder object with 4 successive occurrences 
          ' of each character in the English alphabet. 
          Dim sb As New StringBuilder()
          For ctr As UShort = AscW("a") To AscW("z")
              sb.Append(ChrW(ctr), 4)
          Next
          ' Convert it to a string.
          Dim sbString As String = sb.ToString()
  
          ' Use a regex to uppercase the first occurrence of the sequence, 
          ' and separate it from the previous sequence by an underscore.
          Dim pattern As String = "(\w)(\1+)"
          sbString = Regex.Replace(sbString, pattern,
                                 Function(m) If(m.Index > 0, "_", "") +
                                             m.Groups(1).Value.ToUpper +
                                             m.Groups(2).Value)
  
          ' Display the resulting string.
          Dim line As Integer = 0
          Do
              Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length,
                                      80, sbString.Length - line * 80)
              Console.WriteLine(sbString.Substring(line * 80, nChars))
              line += 1
          Loop While line * 80 < sbString.Length
      End Sub
  End Module
  ' The example displays the following output:
  '    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
  '    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
  

A StringBuilder objektum átalakítása sztringgé

Az objektumot át kell alakítania objektummá StringBuilderString , mielőtt átadhatja az StringBuilder objektum által képviselt sztringet egy String paraméterrel rendelkező metódusnak, vagy megjelenítheti azt a felhasználói felületen. Ezt az átalakítást a StringBuilder.ToString metódus meghívásával hajthatja végre. Az ábrát az előző példában találja, amely meghívja a ToString metódust StringBuilder egy objektum sztringgé alakítására, hogy az átadható legyen egy normál kifejezési metódusnak.