StringBuilder.Chars[Int32] Propriété

Définition

Obtient ou définit le caractère situé à la position de caractère spécifiée dans cette instance.Gets or sets the character at the specified character position in this instance.

public:
 property char default[int] { char get(int index); void set(int index, char value); };
public char this[int index] { get; set; }
member this.Chars(int) : char with get, set
Default Public Property Chars(index As Integer) As Char

Paramètres

index
Int32

Position du caractère.The position of the character.

Valeur de propriété

Char

Caractère Unicode à la position index.The Unicode character at position index.

Exceptions

index est en dehors des limites de cette instance lors de la définition d’un caractère.index is outside the bounds of this instance while setting a character.

index est en dehors des limites de cette instance lors de l’obtention d’un caractère.index is outside the bounds of this instance while getting a character.

Remarques

Le paramètre index est la position d’un caractère dans le StringBuilder.The index parameter is the position of a character within the StringBuilder. Le premier caractère de la chaîne est à l’index 0.The first character in the string is at index 0. La longueur d’une chaîne est le nombre de caractères qu’elle contient.The length of a string is the number of characters it contains. Le dernier caractère accessible d’une instance de StringBuilder se trouve à l’index Length-1.The last accessible character of a StringBuilder instance is at index Length - 1.

Chars[] est la propriété par défaut de la classe StringBuilder.Chars[] is the default property of the StringBuilder class. Dans C#, il s’agit d’un indexeur.In C#, it is an indexer. Cela signifie que les caractères individuels peuvent être récupérés à partir de la propriété Chars[], comme indiqué dans l’exemple suivant, qui compte le nombre de caractères alphabétiques, d’espace blanc et de ponctuation dans une chaîne.This means that individual characters can be retrieved from the Chars[] property as shown in the following example, which counts the number of alphabetic, white-space, and punctuation characters in a string.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      int nAlphabeticChars = 0;
      int nWhitespace = 0;
      int nPunctuation = 0;  
      StringBuilder sb = new StringBuilder("This is a simple sentence.");
      
      for (int ctr = 0; ctr < sb.Length; ctr++) {
         char ch = sb[ctr];
         if (Char.IsLetter(ch)) { nAlphabeticChars++;  continue; }
         if (Char.IsWhiteSpace(ch)) { nWhitespace++;  continue; }
         if (Char.IsPunctuation(ch)) nPunctuation++;  
      }    

      Console.WriteLine("The sentence '{0}' has:", sb);
      Console.WriteLine("   Alphabetic characters: {0}", nAlphabeticChars);
      Console.WriteLine("   White-space characters: {0}", nWhitespace);
      Console.WriteLine("   Punctuation characters: {0}", nPunctuation);
   }
}
// The example displays the following output:
//       The sentence 'This is a simple sentence.' has:
//          Alphabetic characters: 21
//          White-space characters: 4
//          Punctuation characters: 1
Imports System.Text

Module Example
   Public Sub Main()
      Dim nAlphabeticChars As Integer = 0
      Dim nWhitespace As Integer = 0
      Dim nPunctuation As Integer = 0  
      Dim sb As New StringBuilder("This is a simple sentence.")
      
      For ctr As Integer = 0 To sb.Length - 1
         Dim ch As Char = sb(ctr)
         If Char.IsLetter(ch) Then nAlphabeticChars += 1 : Continue For
         If Char.IsWhiteSpace(ch) Then nWhitespace += 1 : Continue For
         If Char.IsPunctuation(ch) Then nPunctuation += 1
      Next    

      Console.WriteLine("The sentence '{0}' has:", sb)
      Console.WriteLine("   Alphabetic characters: {0}", nAlphabeticChars)
      Console.WriteLine("   White-space characters: {0}", nWhitespace)
      Console.WriteLine("   Punctuation characters: {0}", nPunctuation)
   End Sub
End Module
' The example displays the following output:
'       The sentence 'This is a simple sentence.' has:
'          Alphabetic characters: 21
'          White-space characters: 4
'          Punctuation characters: 1

Performances et indexation basée sur des caractèresPerformance and character-based indexing

L’utilisation de l’indexation basée sur des caractères avec la propriété Chars[] peut être très lente dans les conditions suivantes :Using character-based indexing with the Chars[] property can be extremely slow under the following conditions:

  • L’instance de StringBuilder est grande (par exemple, elle est constituée de plusieurs dizaines de milliers de caractères).The StringBuilder instance is large (for example, it consists of several tens of thousands of characters).
  • StringBuilder contient des grands blocs.The StringBuilder is "chunky." Autrement dit, des appels répétés à des méthodes comme StringBuilder.Append ont développé automatiquement la propriété StringBuilder.Capacity de l’objet et lui ont alloué de nouveaux blocs de mémoire.That is, repeated calls to methods such as StringBuilder.Append have automatically expanded the object's StringBuilder.Capacity property and allocated new chunks of memory to it.

Les performances sont gravement affectées, car chaque accès aux caractères doit parcourir toute la liste chaînée des blocs pour trouver la mémoire tampon correcte où indexer.Performance is severely impacted because each character access walks the entire linked list of chunks to find the correct buffer to index into.

Notes

Même pour un grand objet StringBuilder avec des gros blocs, l’utilisation de la propriété Chars[] pour l’accès basé sur un index à un seul caractère ou à un petit nombre de caractères a un impact négligeable sur les performances ; en général, il s’agit d’une opération 0(n) .Even for a large "chunky" StringBuilder object, using the Chars[] property for index-based access to one or a small number of characters has a negligible performance impact; typically, it is an 0(n) operation. Un impact significatif sur les performances se produit par contre lors de l’itération dans les caractères contenus dans l’objet StringBuilder, qui est une opération O(n^2) .The significant performance impact occurs when iterating the characters in the StringBuilder object, which is an O(n^2) operation.

Si vous rencontrez des problèmes de performances lors de l’utilisation de l’indexation basée sur des caractères avec des objets StringBuilder, vous pouvez utiliser une des solutions de contournement suivantes :If you encounter performance issues when using character-based indexing with StringBuilder objects, you can use any of the following workarounds:

  • Convertissez l’instance de StringBuilder en String en appelant la méthode ToString, puis accédez aux caractères de la chaîne.Convert the StringBuilder instance to a String by calling the ToString method, then access the characters in the string.

  • Copiez le contenu de l’objet StringBuilder existant dans un objet StringBuilder prédimensionné.Copy the contents of the existing StringBuilder object to a new pre-sized StringBuilder object. Les performances s’améliorent, car le nouvel objet StringBuilder ne contient pas de gros blocs.Performance improves because the new StringBuilder object is not chunky. Par exemple :For example:

    // 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)
    
  • Définissez la capacité initiale de l’objet StringBuilder à une valeur approximativement égale à sa taille maximale attendue en appelant le constructeur StringBuilder(Int32).Set the initial capacity of the StringBuilder object to a value that is approximately equal to its maximum expected size by calling the StringBuilder(Int32) constructor. Notez que ceci alloue l’intégralité du bloc de mémoire, même si StringBuilder atteint rarement sa capacité maximale.Note that this allocates the entire block of memory even if the StringBuilder rarely reaches its maximum capacity.

S’applique à

Voir aussi