String String String String Class

Definição

Representa o texto como uma sequência de unidades de código UTF-16.Represents text as a sequence of UTF-16 code units.

public ref class String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Herança
StringStringStringString
Atributos
Implementações

Comentários

Uma cadeia de caracteres é uma coleção sequencial de caracteres que é usada para representar texto.A string is a sequential collection of characters that is used to represent text. Um String objeto é uma coleção sequencial System.Char de objetos que representam uma cadeia de System.Char caracteres; um objeto corresponde a uma unidade de código UTF-16.A String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. O valor do String objeto é o conteúdo da coleção sequencial de System.Char objetos e esse valor é imutável (ou seja, é somente leitura).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). Para obter mais informações sobre a imutabilidade de cadeias de caracteres, consulte a seção imutabilidade e a classe StringBuilder mais adiante neste tópico.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. O tamanho máximo de um String objeto na memória é de 2GB ou cerca de 1.000.000.000 caracteres.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

Observação

Alguns dos exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Quando presente, selecione o botão Executar para executar um exemplo em uma janela interativa.When present, select the Run button to run an example in an interactive window. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente.Once you execute the code, you can modify it and run the modified code by selecting Run again. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Nesta seção:In this section:

Criando uma instância de um objeto de cadeia de caracteres Instantiating a String object
Objetos char e caracteres Unicode Char objects and Unicode characters
Cadeias de caracteres e o padrão Unicode Strings and The Unicode Standard
Strings e caracteres nulos inseridos Strings and embedded null characters
Cadeias de caracteres e índices Strings and indexes
Cadeias de caracteres nulas e vazias Null strings and empty strings
Imutabilidade e a classe StringBuilder Immutability and the StringBuilder class
Ordinal vs. operações sensíveis à cultura Ordinal vs. culture-sensitive operations
Normalização Normalization
Operações de cadeia de caracteres por categoriaString operations by category

Criando uma instância de um objeto StringInstantiating a String object

Você pode criar uma String instância de um objeto das seguintes maneiras:You can instantiate a String object in the following ways:

  • Atribuindo um literal de cadeia de caracteres a String uma variável.By assigning a string literal to a String variable. Esse é o método mais comumente usado para criar uma cadeia de caracteres.This is the most commonly used method for creating a string. O exemplo a seguir usa a atribuição para criar várias cadeias de caracteres.The following example uses assignment to create several strings. Observe que no C#, como a barra invertida\() é um caractere de escape, as barras invertidas literais em uma cadeia de caracteres devem ter @-quotedescape ou a cadeia de caracteres inteira deve ser.Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-quoted.

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc 
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc      
    
  • Chamando um construtor String de classe.By calling a String class constructor. O exemplo a seguir instancia cadeias de caracteres chamando vários construtores de classe.The following example instantiates strings by calling several class constructors. Observe que alguns dos construtores incluem ponteiros para matrizes de caracteres ou matrizes de bytes assinadas como parâmetros.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic não dá suporte a chamadas para esses construtores.Visual Basic does not support calls to these constructors. Para obter informações detalhadas String sobre construtores, consulte o String Resumo do construtor.For detailed information about String constructors, see the String constructor summary.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word  
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc      
    
  • Usando o operador de concatenação de cadeia de caracteres C# (+ in e & ou + em Visual Basic) para criar uma única cadeia de String caracteres de qualquer combinação de instâncias e literais de cadeia de caracteres.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. O exemplo a seguir ilustra o uso do operador de concatenação de cadeia de caracteres.The following example illustrates the use of the string concatenation operator.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • Recuperando uma propriedade ou chamando um método que retorna uma cadeia de caracteres.By retrieving a property or calling a method that returns a string. O exemplo a seguir usa os métodos da String classe para extrair uma subcadeia de caracteres de uma cadeia maior.The following example uses the methods of the String class to extract a substring from a larger string.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • Chamando um método de formatação para converter um valor ou objeto em sua representação de cadeia de caracteres.By calling a formatting method to convert a value or object to its string representation. O exemplo a seguir usa o recurso de formatação composta para inserir a representação de cadeia de caracteres de dois objetos em uma cadeia de caracteres.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

    DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
    Double temperature = 68.3;
    String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                   dateAndTime, temperature);
    Console::WriteLine(result);
    // The example displays the following output: 
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    

Objetos Char e caracteres UnicodeChar objects and Unicode characters

Cada caractere em uma cadeia de caracteres é definido por um valor escalar Unicode, também chamado de ponto de código Unicode ou valor ordinal (numérico) do caractere Unicode.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Cada ponto de código é codificado usando a codificação UTF-16 e o valor numérico de cada elemento da codificação é representado por um Char objeto.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

Observação

Observe que, como uma String instância consiste em uma coleção sequencial de unidades de código UTF-16, é possível criar um String objeto que não seja uma cadeia de caracteres Unicode bem formada.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. Por exemplo, é possível criar uma cadeia de caracteres que tenha um substituto baixo sem um substituto alto correspondente.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. Embora alguns métodos, como os métodos de codificação e decodificação de objetos no namespace System.Text , o possa executar verificações para garantir que as cadeias de caracteres sejam String bem formadas, os membros da classe não garantem que uma cadeia de caracteres esteja bem formada.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

Um único Char objeto geralmente representa um único ponto de código; ou seja, o valor numérico Char de é igual ao ponto de código.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Por exemplo, o ponto de código para o caractere "a" é U + 0061.For example, the code point for the character "a" is U+0061. No entanto, um ponto de código pode exigir mais de um elemento codificado ( Char mais de um objeto).However, a code point might require more than one encoded element (more than one Char object). O padrão Unicode define dois tipos de caracteres que correspondem a vários Char objetos: graphemes e pontos de código suplementares Unicode que correspondem aos caracteres nos planos suplementares Unicode.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • Um grafemas é representado por um caractere base seguido por um ou mais caracteres combináveis.A grapheme is represented by a base character followed by one or more combining characters. Por exemplo, o caractere ä é representado por um Char objeto cujo ponto de código é u + 0061 seguido por Char um objeto cujo ponto de código é u + 0308.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. Esse caractere também pode ser definido por um único Char objeto que tem um ponto de código de U + 00E4.This character can also be defined by a single Char object that has a code point of U+00E4. Como mostra o exemplo a seguir, uma comparação sensível à cultura para igualdade indica que essas duas representações são iguais, embora uma comparação ordinal comum não.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. No entanto, se as duas cadeias de caracteres forem normalizadas, uma comparação ordinal também indicará que elas são iguais.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (Para obter mais informações sobre como Normalizar cadeias de caracteres, consulte a seção normalização.)(For more information on normalizing strings, see the Normalization section.)

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Um ponto de código suplementar Unicode (um par substituto) é representado por Char um objeto cujo ponto de código é um substituto alto seguido Char por um objeto cujo ponto de código é um substituto baixo.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. As unidades de código de substitutos altos variam de U + D800 para U + DBFF.The code units of high surrogates range from U+D800 to U+DBFF. As unidades de código de substitutos baixos variam de U + DC00 para U + DFFF.The code units of low surrogates range from U+DC00 to U+DFFF. Pares substitutos são usados para representar caracteres nos planos suplementares de 16 Unicode.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. O exemplo a seguir cria um caractere substituto e o passa para Char.IsSurrogatePair(Char, Char) o método para determinar se ele é um par alternativo.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
    Console.WriteLine();
    Console.WriteLine("   Is Surrogate Pair: {0}", 
                      Char.IsSurrogatePair(surrogate[0], surrogate[1]));
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    Module Example
       Public Sub Main()
          Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
          For ctr As Integer = 0 To surrogate.Length - 1
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
          Next   
          Console.WriteLine()
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate(0), surrogate(1)))
       End Sub
    End Module
    
    ' The example displays the following output:
    '       U+D800 U+DC03
    '          Is Surrogate Pair: True
    

Cadeias de caracteres e o padrão UnicodeStrings and the Unicode Standard

Os caracteres em uma cadeia de caracteres são representados por unidades de código codificadas em Char UTF-16, que correspondem aos valores.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Cada caractere em uma cadeia de caracteres tem uma categoria de caractere Unicode associada, que é representada no UnicodeCategory .net pela enumeração.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. A categoria de um caractere ou um par substituto pode ser determinada chamando o CharUnicodeInfo.GetUnicodeCategory método.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

O .NET mantém sua própria tabela de caracteres e suas categorias correspondentes, o que garante que uma versão específica de uma implementação do .NET em execução em diferentes plataformas retorne informações de categoria de caracteres idênticos..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. No .NET Core em execução no Linux e macOS, informações de categoria do caractere são fornecidas por bibliotecas do International Components for Unicode.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

A tabela a seguir lista as versões do .NET e as versões do Padrão Unicode nas quais suas categorias de caracteres são baseadas.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

Versão do .NET.NET version Versão do Padrão UnicodeVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 O Padrão Unicode, versão 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 O Padrão Unicode, versão 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3,5.NET Framework 3.5 O Padrão Unicode, versão 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 O Padrão Unicode, versão 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 O Padrão Unicode, versão 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.51.NET Framework 4.51 O Padrão Unicode, versão 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.52.NET Framework 4.52 O Padrão Unicode, versão 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 O Padrão Unicode, versão 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.61.NET Framework 4.61 O Padrão Unicode, versão 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.2 e versões posteriores.NET Framework 4.6.2 and later versions O Padrão Unicode, versão 8.0.0The Unicode Standard, Version 8.0.0
.NET Core (todas as versões).NET Core (all versions) O Padrão Unicode, versão 8.0.0The Unicode Standard, Version 8.0.0

Além disso, o .NET dá suporte à comparação e à classificação de cadeia de caracteres com base no padrão Unicode.In addition, .NET supports string comparison and sorting based on the Unicode standard. Em versões do .NET Framework por meio do .NET Framework 4.NET Framework 4, o .NET Framework mantém sua própria tabela de dados de cadeia de caracteres.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. Isso também é verdadeiro nas versões do .NET Framework a .NET Framework 4.5.NET Framework 4.5 partir do em execução no Windows 7.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. Começando com o .NET Framework 4.5.NET Framework 4.5 em execução na janela 8 e versões posteriores do sistema operacional Windows, o tempo de execução delega a comparação de cadeias de caracteres e as operações de classificação para o sistema operacional.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. No .NET Core, as informações de comparação e classificação de cadeia de caracteres são fornecidas por componentes internacionais para bibliotecas Unicode . A tabela a seguir lista as versões do .NET e as versões do padrão Unicode nas quais a comparação de caracteres e a classificação são baseadas.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

Versão do .NET.NET version Versão do Padrão UnicodeVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 O Padrão Unicode, versão 4.0.0The Unicode Standard, Version 4.0.0
O .NET Framework 2,0The .NET Framework 2.0 O Padrão Unicode, versão 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3,5.NET Framework 3.5 O Padrão Unicode, versão 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 O Padrão Unicode, versão 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5e posterior no Windows 7and later on Windows 7 O Padrão Unicode, versão 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5e posterior no Windows 8 e sistemas operacionais Windows posterioresand later on Windows 8 and later Windows operating systems O Padrão Unicode, versão 6.3.0The Unicode Standard, Version 6.3.0
.NET Core (todas as versões).NET Core (all versions) Depende da versão do padrão Unicode compatível com o sistema operacional subjacente.Depends on the version of the Unicode Standard supported by the underlying operating system.

Cadeias de caracteres e caracteres nulos inseridosStrings and embedded null characters

No .net, um String objeto pode incluir caracteres nulos inseridos, que contam como parte do comprimento da cadeia de caracteres.In .NET, a String object can include embedded null characters, which count as a part of the string's length. No entanto, em alguns idiomas, como C++C e, um caractere nulo indica o final de uma cadeia de caracteres; Ela não é considerada uma parte da cadeia de caracteres e não é contada como parte do comprimento da cadeia de caracteres.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. Isso significa que as seguintes suposições comuns que C e C++ programadores ou bibliotecas escritas em c ou C++ que podem fazer sobre cadeias de caracteres não são necessariamente String válidas quando aplicadas a objetos:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • O valor retornado pelas strlen funções ou wcslen não é necessariamente igual. String.LengthThe value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • A cadeia de caracteres criada strcpy_s pelas wcscpy_s funções ou não é necessariamente idêntica à cadeia de caracteres criada String.Copy pelo método.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

Você deve garantir que o C nativo C++ e o código que String instanciam objetos e o código que String são passados para objetos por meio de invocação de plataforma, não presuma que um caractere nulo inserido marque o final da cadeia de caracteres.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

Caracteres NULL inseridos em uma cadeia de caracteres também são tratados de forma diferente quando uma cadeia de caracteres é classificada (ou comparada) e quando uma cadeia de caracteres é pesquisadaEmbedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. Caracteres nulos são ignorados ao executar comparações que diferenciam culturas entre duas cadeias de caracteres, incluindo comparações usando a cultura invariável.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Eles são considerados apenas para comparações ordinais ou não diferenciam maiúsculas de minúsculas.They are considered only for ordinal or case-insensitive ordinal comparisons. Por outro lado, os caracteres nulos inseridos são sempre considerados ao pesquisar uma cadeia de caracteres Containscom StartsWithmétodos como IndexOf, e.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Cadeias de caracteres e índicesStrings and indexes

Um índice é a posição de um Char objeto (não um caractere Unicode) em um String.An index is the position of a Char object (not a Unicode character) in a String. Um índice é um número não negativo com base em zero que começa da primeira posição na cadeia de caracteres, que é a posição do índice zero.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. Vários métodos de pesquisa, IndexOf como e LastIndexOf, retornam o índice de um caractere ou uma subcadeia de caracteres na instância de cadeia de caracteres.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

A Chars[Range] propriedade permite que você acesse objetos individuais Char por sua posição de índice na cadeia de caracteres.The Chars[Range] property lets you access individual Char objects by their index position in the string. Como a Chars[Range] propriedade é a propriedade padrão (em Visual Basic) ou o indexador (em C#), você pode acessar os objetos Char individuais em uma cadeia de caracteres usando um código como o seguinte.Because the Chars[Range] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. Esse código procura espaço em branco ou caracteres de pontuação em uma cadeia de caracteres para determinar quantas palavras a cadeia de caracteres contém.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for (int ctr = 0; ctr < s1->Length; ctr++) {
         if (Char::IsPunctuation(s1[ctr]) | Char::IsWhiteSpace(s1[ctr]))
            nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                     s1, nWords);           
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
for (int ctr = 0; ctr < s1.Length; ctr++) {
   if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For ctr As Integer = 0 To s1.Length - 1
         If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr)) 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Como a String classe implementa a IEnumerable interface, você também pode iterar os Char objetos em uma cadeia de caracteres usando foreach uma construção, como mostra o exemplo a seguir.Because the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for each (Char ch in s1)
   {
      if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
         nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                      s1, nWords);  
   Console::ReadLine();
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
foreach (var ch in s1) {
   if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For Each ch In s1
         If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Os valores de índice consecutivos podem não corresponder a caracteres Unicode consecutivos, pois um caractere Unicode pode ser codificado Char como mais de um objeto.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. Em particular, uma cadeia de caracteres pode conter unidades de vários caracteres de texto que são formadas por um caractere base seguido por um ou mais caracteres combináveis ou por pares substitutos.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Para trabalhar com caracteres Unicode em vez Char de objetos, use System.Globalization.StringInfo as TextElementEnumerator classes e.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. O exemplo a seguir ilustra a diferença entre o código que Char funciona com objetos e código que funciona com caracteres Unicode.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Ele compara o número de caracteres ou elementos de texto em cada palavra de uma frase.It compares the number of characters or text elements in each word of a sentence. A cadeia de caracteres inclui duas sequências de um caractere base, seguido por um caractere de combinação.The string includes two sequences of a base character followed by a combining character.

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;

void main()
{
   // First sentence of The Mystery of the Yellow Room, by Leroux. 
   String^ opening = L"Ce n'est pas sans une certaine émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

   for each (Char ch in opening) {
      // Skip the ' character. 
      if (ch == '\x0027') continue;

      if (Char::IsWhiteSpace(ch) | (Char::IsPunctuation(ch))) {
         chars->Add(nChars);
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   TextElementEnumerator^ te = StringInfo::GetTextElementEnumerator(opening);
   while (te->MoveNext()) {
      String^ s = te->GetTextElement();   
      // Skip the ' character. 
      if (s == "\x0027") continue;
      if ( String::IsNullOrEmpty(s->Trim()) | (s->Length == 1 && Char::IsPunctuation(Convert::ToChar(s)))) {
         elements->Add(nChars);         
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12
// First sentence of The Mystery of the Yellow Room, by Leroux.
string opening = "Ce n'est pas sans une certaine émotion que "+
                 "je commence à raconter ici les aventures " +
                 "extraordinaires de Joseph Rouletabille."; 
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int> chars = new List<int>();
List<int> elements = new List<int>();

foreach (var ch in opening) {
   // Skip the ' character.
   if (ch == '\u0027') continue;
        
   if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
      chars.Add(nChars);
      nChars = 0;
   }
   else {
      nChars++;
   }
}

System.Globalization.TextElementEnumerator te = 
   System.Globalization.StringInfo.GetTextElementEnumerator(opening);
while (te.MoveNext()) {
   string s = te.GetTextElement();   
   // Skip the ' character.
   if (s == "\u0027") continue;
   if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
      elements.Add(nChars);         
      nChars = 0;
   }
   else {
      nChars++;
   }
}

// Display character counts.
Console.WriteLine("{0,6} {1,20} {2,20}",
                  "Word #", "Char Objects", "Characters"); 
for (int ctr = 0; ctr < chars.Count; ctr++) 
   Console.WriteLine("{0,6} {1,20} {2,20}",
                     ctr, chars[ctr], elements[ctr]); 
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      ' First sentence of The Mystery of the Yellow Room, by Leroux.
      Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille." 
      ' Character counters.
      Dim nChars As Integer = 0
      ' Objects to store word count.
      Dim chars As New List(Of Integer)()
      Dim elements As New List(Of Integer)()
      
      For Each ch In opening
         ' Skip the ' character.
         If ch = ChrW(&h0027) Then Continue For
              
         If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
            chars.Add(nChars)
            nChars = 0
         Else 
            nChars += 1
         End If
      Next

      Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
      Do While te.MoveNext()
         Dim s As String = te.GetTextElement()   
         ' Skip the ' character.
         If s = ChrW(&h0027) Then Continue Do
         If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) 
            elements.Add(nChars)         
            nChars = 0
         Else 
            nChars += 1
         End If
      Loop

      ' Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters") 
      For ctr As Integer = 0 To chars.Count - 1 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars(ctr), elements(ctr)) 
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Word #         Char Objects           Characters
'         0                    2                    2
'         1                    4                    4
'         2                    3                    3
'         3                    4                    4
'         4                    3                    3
'         5                    8                    8
'         6                    8                    7
'         7                    3                    3
'         8                    2                    2
'         9                    8                    8
'        10                    2                    1
'        11                    8                    8
'        12                    3                    3
'        13                    3                    3
'        14                    9                    9
'        15                   15                   15
'        16                    2                    2
'        17                    6                    6
'        18                   12                   12

Este exemplo funciona com elementos de texto usando o StringInfo.GetTextElementEnumerator método e a TextElementEnumerator classe para enumerar todos os elementos de texto em uma cadeia de caracteres.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. Você também pode recuperar uma matriz que contém o índice inicial de cada elemento de texto chamando o StringInfo.ParseCombiningCharacters método.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Para obter mais informações sobre como trabalhar com unidades de texto em Char vez de valores individuais StringInfo , consulte a classe.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Cadeias de caracteres nulas e cadeias de caracteres vaziasNull strings and empty strings

Uma cadeia de caracteres que foi declarada mas não recebeu um valor null.A string that has been declared but has not been assigned a value is null. A tentativa de chamar métodos nessa cadeia de caracteres gera NullReferenceExceptionum.Attempting to call methods on that string throws a NullReferenceException. Uma cadeia de caracteres nula é diferente de uma cadeia de caracteres vazia, que é uma cadeia de caracteres String.Emptycujo valor é "" ou.A null string is different from an empty string, which is a string whose value is "" or String.Empty. Em alguns casos, passar uma cadeia de caracteres nula ou vazia como um argumento em uma chamada de método gera uma exceção.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Por exemplo, a passagem de uma cadeia de Int32.Parse caracteres nula para ArgumentNullExceptiono método gera um e a passagem de FormatExceptionuma cadeia de caracteres vazia gera um.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. Em outros casos, um argumento de método pode ser uma cadeia de caracteres nula ou vazia.In other cases, a method argument can be either a null string or an empty string. Por exemplo, se você estiver fornecendo uma IFormattable implementação para uma classe, você deseja equiparar uma cadeia de caracteres nula e uma cadeia de caracteres vazia com o especificador de formato geral ("G").For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

A String classe inclui os dois métodos de conveniência a seguir que permitem testar se uma cadeia de null caracteres está ou vazia:The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, que indica se uma cadeia de caracteres null é ou não igual String.Emptya.IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Esse método elimina a necessidade de usar código como o seguinte:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, que indica se uma cadeia de nullcaracteres é String.Empty, Equals ou consiste exclusivamente em espaços em branco.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Esse método elimina a necessidade de usar código como o seguinte:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

O exemplo a seguir usa IsNullOrEmpty o método IFormattable.ToString na implementação de uma classe Temperature personalizada.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. O método dá suporte às cadeias de caracteres de formato "G", "C", "F" e "K".The method supports the "G", "C", "F", and "K" format strings. Se uma cadeia de caracteres de formato vazio ou uma cadeia de null caracteres de formato cujo valor é passado para o método, seu valor será alterado para a cadeia de caracteres de formato "G".If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }
public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
                Implements IFormattable.ToString
   If String.IsNullOrEmpty(fmt) Then fmt = "G"  
   If provider Is Nothing Then provider = CultureInfo.CurrentCulture
   
   Select Case fmt.ToUpperInvariant()
      ' Return degrees in Celsius.    
      Case "G", "C"
         Return temp.ToString("F2", provider) + "°C"
      ' Return degrees in Fahrenheit.
      Case "F" 
         Return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F"
      ' Return degrees in Kelvin.
      Case "K"   
         Return (temp + 273.15).ToString()
      Case Else
         Throw New FormatException(
               String.Format("The {0} format string is not supported.", 
                             fmt))
    End Select                                   
End Function

Imutabilidade e a classe StringBuilderImmutability and the StringBuilder class

Um String objeto é chamado de imutável (somente leitura), pois seu valor não pode ser modificado após ter sido criado.A String object is called immutable (read-only), because its value cannot be modified after it has been created. Os métodos que parecem modificar um String objeto retornam, na String verdade, um novo objeto que contém a modificação.Methods that appear to modify a String object actually return a new String object that contains the modification.

Como as cadeias de caracteres são imutáveis, as rotinas de manipulação de cadeia que executam adições ou exclusões repetidas para o que parece ser uma única cadeia de caracteres podem ser exatamente uma penalidade de desempenho significativa.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. Por exemplo, o código a seguir usa um gerador de números aleatórios para criar uma cadeia com 1000 caracteres no intervalo de 0x0001 a 0x052F.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Embora o código pareça usar a concatenação de cadeia de caracteres para acrescentar um novo caractere à cadeia strde caracteres existente chamada, ele String , na verdade, cria um novo objeto para cada operação de concatenação.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   String^ str = String::Empty;
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      str += Convert::ToChar(rnd->Next(1, 0x0530)); 
      if (str->Length % 60 == 0)
         str += Environment::NewLine;          
   }                    
   sw->Write(str);
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      Dim str As String = String.Empty
      Dim sw As New StreamWriter(".\StringFile.txt", 
                           False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         str += ChrW(rnd.Next(1, &h0530)) 
         If str.Length Mod 60 = 0 Then str += vbCrLf          
      Next                    
      sw.Write(str)
      sw.Close()
   End Sub
End Module

Você pode usar a StringBuilder classe em vez String da classe para operações que fazem várias alterações no valor de uma cadeia de caracteres.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. Ao contrário de instâncias String da classe StringBuilder , os objetos são mutáveis; quando você concatena, acrescenta ou exclui subcadeias de caracteres de uma cadeia de texto, as operações são executadas em uma única cadeia de caracteres.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. Quando você terminar de modificar o valor de um StringBuilder objeto, poderá chamar seu StringBuilder.ToString método para convertê-lo em uma cadeia de caracteres.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. O exemplo a seguir substitui String o usado no exemplo anterior para concatenar 1000 caracteres aleatórios no intervalo de 0x0001 a 0x052F com um StringBuilder objeto.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   StringBuilder^ sb = gcnew StringBuilder();
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      sb->Append(Convert::ToChar(rnd->Next(1, 0x0530))); 
      if (sb->Length % 60 == 0)
         sb->AppendLine();          
   }                    
   sw->Write(sb->ToString());
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      Dim sw As New StreamWriter(".\StringFile.txt", 
                                 False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         sb.Append(ChrW(rnd.Next(1, &h0530))) 
         If sb.Length Mod 60 = 0 Then sb.AppendLine()          
      Next                    
      sw.Write(sb.ToString())
      sw.Close()
   End Sub
End Module

Ordinal x operações sensíveis à culturaOrdinal vs. culture-sensitive operations

Os membros da String classe executam operações de ordinal ou de distinção de cultura (linguísticos String ) em um objeto.Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Uma operação ordinal atua no valor numérico de cada Char objeto.An ordinal operation acts on the numeric value of each Char object. Uma operação sensível à cultura atua no valor do String objeto e usa as regras específicas de cultura, classificação, formatação e análise em conta.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. As operações que fazem distinção de cultura são executadas no contexto de uma cultura declarada explicitamente ou da cultura atual implícita.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. Os dois tipos de operações podem produzir resultados muito diferentes quando são executados na mesma cadeia de caracteres.The two kinds of operations can produce very different results when they are performed on the same string.

O .net também dá suporte a operações de cadeia de caracteres lingüísticas que não fazemCultureInfo.InvariantCulturedistinção entre culturas usando a cultura invariável (), que é livremente baseada nas configurações de cultura do idioma inglês independente da região..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. Ao contrário System.Globalization.CultureInfo de outras configurações, as configurações da cultura invariável têm garantia de permanecer consistentes em um único computador, de sistema para sistema e entre versões do .net.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. A cultura invariável pode ser vista como um tipo de caixa preta que garante a estabilidade de comparações de cadeias de caracteres e a ordenação entre todas as culturas.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Importante

Se o seu aplicativo tomar uma decisão de segurança sobre um identificador simbólico, como um nome de arquivo ou pipe nomeado, ou sobre dados persistentes, como os dados baseados em texto em um arquivo XML, a operação deverá usar uma comparação ordinal em vez de uma comparação sensível à cultura.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. Isso ocorre porque uma comparação sensível à cultura pode produzir resultados diferentes dependendo da cultura em vigor, enquanto uma comparação ordinal depende exclusivamente do valor binário dos caracteres comparados.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

Importante

A maioria dos métodos que executam operações de cadeia de caracteres incluem uma sobrecarga StringComparisonque tem um parâmetro do tipo, que permite que você especifique se o método executa uma operação ordinal ou sensível à cultura.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. Em geral, você deve chamar essa sobrecarga para tornar a intenção do seu método chamar Clear.In general, you should call this overload to make the intent of your method call clear. Para obter as práticas recomendadas e as diretrizes para usar operações ordinais e sensíveis à cultura em cadeias de caracteres, consulte práticas recomendadas para usar cadeias de caracteres.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

Operações para uso de maiúsculas e minúsculas, análise e formatação, comparação e classificaçãoe teste para igualdade podem ser um ordinal ou uma diferenciação de cultura.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. As seções a seguir discutem cada categoria de operação.The following sections discuss each category of operation.

Dica

Você sempre deve chamar uma sobrecarga de método que torna a intenção da chamada do método clara.You should always call a method overload that makes the intent of your method call clear. Por exemplo, em vez de chamar Compare(String, String) o método para executar uma comparação sensível à cultura de duas cadeias de caracteres usando as convenções da cultura atual, você deve Compare(String, String, StringComparison) chamar o método com um StringComparison.CurrentCulture valor de comparisonType para o argumento.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. Para obter mais informações, consulte Práticas recomendadas para o uso de cadeias de caracteres.For more information, see Best Practices for Using Strings.

Você pode baixar as Tabelas de peso de classificação, um conjunto de arquivos de texto que contêm informações sobre os pesos de caracteres usados em operações de classificação e comparação dos sistemas operacionais Windows, e a Tabela de elemento de ordenação Unicode padrão, a tabela de peso de classificação para Linux e macOS.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

MaiúsculasCasing

Regras de maiúsculas e minúsculas determinam como alterar a capitalização de um caractere Unicode; por exemplo, de minúsculas a maiúsculas.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Geralmente, uma operação de maiúsculas e minúsculas é executada antes de uma comparação de cadeia de caracteresOften, a casing operation is performed before a string comparison. Por exemplo, uma cadeia de caracteres pode ser convertida em letras maiúsculas para que possa ser comparada com outra cadeia de caracteres em maiúsculas.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. Você pode converter os caracteres em uma cadeia de caracteres em minúsculas chamando ToLower o ToLowerInvariant método ou e pode convertê-los em maiúsculas chamando ToUpper o ToUpperInvariant método ou.You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. Além disso, você pode usar o TextInfo.ToTitleCase método para converter uma cadeia de caracteres em caso de título.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Observação

.NET Core em execução apenas em sistemas Linux e macOS: O comportamento de ordenação das culturas do C e do Posix sempre diferencia maiúsculas de minúsculas porque essas culturas não usam a sequência de ordenação Unicode esperada..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. Recomendamos usar uma cultura diferente de C ou Posix para executar operações de classificação que diferenciam culturas e maiúsculas de minúsculas.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

As operações de maiúsculas e minúsculas podem ser baseadas nas regras da cultura atual, uma cultura especificada ou a cultura invariável.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. Como os mapeamentos de casos podem variar dependendo da cultura usada, o resultado de operações de maiúsculas e minúsculas pode variar com base na cultura.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. As diferenças reais em maiúsculas são de três tipos:The actual differences in casing are of three kinds:

  • Diferenças no mapeamento de casos da letra latina maiúscula I (U + 0049), letra latina minúscula I (U + 0069), letra latina maiúscula I com ponto acima (U + 0130) e letra latina minúscula I sem ponto (U + 0131).Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). Nas culturas tr-TR (Turco (Turquia)) e az-Latn-AZ (Azerbaijão, Latin) e nas culturas do TR, AZ e az-Latn neutral, o equivalente em minúsculas da letra latina maiúscula I é a letra latina minúscula i sem ponto e o equivalente em maiúsculas da letra latina minúscula I é LETRA LATINA MAIÚSCULA I COM PONTO ACIMA.In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. Em todas as outras culturas, incluindo a cultura invariável, letra latina minúscula I e letra latina maiúscula I são minúsculas e equivalentes maiúsculos.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    O exemplo a seguir demonstra como uma comparação de cadeia de caracteres projetada para evitar o acesso ao sistema de arquivos pode falhar se ele se basear em uma comparação de maiúsculas e minúsculas.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (As convenções de maiúsculas e minúsculas da cultura invariável devem ter sido usadas.)(The casing conventions of the invariant culture should have been used.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • Diferenças no caso de mapeamentos entre a cultura invariável e todas as outras culturas.Differences in case mappings between the invariant culture and all other cultures. Nesses casos, usar as regras de maiúsculas e minúsculas da cultura invariável para alterar um caractere para maiúsculas ou minúsculas retorna o mesmo caractere.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Para todas as outras culturas, ele retorna um caractere diferente.For all other cultures, it returns a different character. Alguns dos caracteres afetados estão listados na tabela a seguir.Some of the affected characters are listed in the following table.

    CaractereCharacter Se alterado paraIf changed to RetornaReturns
    SINAL DE MÍCRON (U + 00B5)MICRON SIGN (U+00B5) MaiúsculasUppercase LETRA GREGA MAIÚSCULA MU (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    LETRA LATINA MAIÚSCULA I COM PONTO ACIMA (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) MinúsculasLowercase LETRA LATINA MINÚSCULA I (U + 0069)LATIN SMALL LETTER I (U+0069)
    LETRA LATINA MINÚSCULA I SEM PONTO (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) MaiúsculasUppercase LETRA LATINA MAIÚSCULA I (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    LETRA LATINA MINÚSCULA LONG S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) MaiúsculasUppercase LETRA LATINA MAIÚSCULA S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    LETRA LATINA MAIÚSCULA D COM LETRA MINÚSCULA Z COM CARON (U + 01C5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) MinúsculasLowercase LETRA LATINA MINÚSCULA DZ COM CARON (U + 01C6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    YPOGEGRAMMENI GREGO COMBINÁVEL (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) MaiúsculasUppercase LETRA GREGA MAIÚSCULA IOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • Diferenças nos mapeamentos de maiúsculas e minúsculas de pares de casos mistos de duas letras no intervalo de caracteres ASCII.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. Na maioria das culturas, um par de maiúsculas e minúsculas com duas letras é igual ao par equivalente em maiúsculas ou minúsculos.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. Isso não é verdadeiro para os pares de duas letras a seguir nas seguintes culturas, porque em cada caso eles são comparados a um digrafo:This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • "lJ" e "nJ" na cultura HR-HR (Croata (Croácia))."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" nas culturas CS-CZ (tcheco (República Tcheca)) e SK-SK (Eslovaco (Eslováquia))."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" na cultura da-DK (dinamarquês (Dinamarca))."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" e "zS" na cultura hu-HU (húngaro (Hungria))."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" e "lL" na cultura es-ES_tradnl (espanhol (Espanha, classificação tradicional))."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "gI", "kH", "nG" "nH", "pH", "t", "tH" e "tR" na cultura vi-VN (vietnamita (Vietnã))."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    No entanto, é incomum encontrar uma situação em que uma comparação sensível à cultura desses pares cria problemas, pois esses pares não são comuns em cadeias de caracteres fixas ou identificadores.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

O exemplo a seguir ilustra algumas das diferenças em regras de maiúsculas e minúsculas entre culturas ao converter cadeias de caracteres em letras maiúsculas.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

   for each (String^ word in words) {
      sw->WriteLine("{0}:", word);
      for each (CultureInfo^ culture in cultures) {
         String^ name = String::IsNullOrEmpty(culture->Name) ? 
                              "Invariant" : culture->Name;
         String^ upperWord = word->ToUpper(culture);
         sw->WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                        upperWord, ShowHexValue(upperWord));

      }
      sw->WriteLine();  
   }
   sw->Close();
}

String^ ShowHexValue(String^ s)
{
   String^ retval = nullptr;
   for each (Char ch in s) {
      array<Byte>^ bytes = BitConverter::GetBytes(ch);
      retval += String::Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
   }
   return retval;
} 
// The example displays the following output: 
//    file: 
//        Invariant:    FILE               00 46 00 49 00 4C 00 45  
//            en-US:    FILE               00 46 00 49 00 4C 00 45  
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45  
//     
//    sıfır: 
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52  
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//     
//    Dženana: 
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));
     
         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\case.txt")   
      Dim words As String() = { "file", "sıfır", "Dženana" }
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"),  
                                        New CultureInfo("tr-TR") }

      For Each word In words
         sw.WriteLine("{0}:", word)
         For Each culture In cultures
            Dim name As String = If(String.IsNullOrEmpty(culture.Name),  
                                 "Invariant", culture.Name)
            Dim upperWord As String = word.ToUpper(culture)
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord))
     
         Next
         sw.WriteLine()  
      Next
      sw.Close()
   End Sub

   Private Function ShowHexValue(s As String) As String
      Dim retval As String = Nothing
      For Each ch In s
         Dim bytes() As Byte = BitConverter.GetBytes(ch)
         retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))     
      Next
      Return retval
   End Function
End Module
' The example displays the following output:
'    file:
'        Invariant:    FILE               00 46 00 49 00 4C 00 45 
'            en-US:    FILE               00 46 00 49 00 4C 00 45 
'            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
'    
'    sıfır:
'        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
'            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'    
'    Dženana:
'        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  

Análise e formataçãoParsing and formatting

A formatação e a análise são operações inversas.Formatting and parsing are inverse operations. As regras de formatação determinam como converter um valor, como uma data e hora ou um número, em sua representação de cadeia de caracteres, enquanto as regras de análise determinam como converter uma representação de cadeia de caracteres em um valor como uma data e hora.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. As regras de formatação e de análise são dependentes das convenções culturais.Both formatting and parsing rules are dependent on cultural conventions. O exemplo a seguir ilustra a ambiguidade que pode surgir ao interpretar uma cadeia de caracteres de data específica da cultura.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. Sem conhecer as convenções da cultura que foi usada para produzir uma cadeia de caracteres de data, não é possível saber se 03/01/2011, 3/1/2011 e 01/03/2011 representam 3 de Janeiro, 2011 ou 1 de março de 2011.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 2011.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

   for each (CultureInfo^ culture in cultures)
      Console::WriteLine("{0,-12} {1}", String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date->ToString("d", culture));                                    
}
// The example displays the following output: 
//       Invariant    03/01/2011 
//       en-US        3/1/2011 
//       fr-FR        01/03/2011
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat As Date = #3/1/2011#
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }

      For Each culture In cultures
         Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.ToString("d", culture))
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Invariant    03/01/2011
'       en-US        3/1/2011
'       fr-FR        01/03/2011

Da mesma forma, como mostra o exemplo a seguir, uma única cadeia de caracteres pode produzir datas diferentes dependendo da cultura cujas convenções são usadas na operação de análise.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

using namespace System;
using namespace System::Globalization;

void main()
{
   String^ dateString = "07/10/2011";
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               CultureInfo::CreateSpecificCulture("en-GB"), 
                                                               CultureInfo::CreateSpecificCulture("en-US") };
   Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                "Month", "Day");
   for each (CultureInfo^ culture in cultures) {
      DateTime date = DateTime::Parse(dateString, culture);
      Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                        String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date.Month, date.Day);
   }                      
}
// The example displays the following output: 
//       Date String     Culture    Month      Day 
//        
//       07/10/2011    Invariant        7       10 
//       07/10/2011        en-GB       10        7 
//       07/10/2011        en-US        7       10

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString As String = "07/10/2011"
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        CultureInfo.CreateSpecificCulture("en-GB"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture", 
                                                 "Month", "Day")
      Console.WriteLine()                                                 
      For Each culture In cultures
         Dim dat As Date = DateTime.Parse(dateString, culture)
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.Month, dat.Day)
      Next
   End Sub
End Module
' The example displays the following output:
'       Date String     Culture    Month      Day
'       
'       07/10/2011    Invariant        7       10
'       07/10/2011        en-GB       10        7
'       07/10/2011        en-US        7       10

Comparação da cadeia de caracteres e classificaçãoString comparison and sorting

As convenções para comparar e classificar cadeias de caracteres variam de cultura para cultura.Conventions for comparing and sorting strings vary from culture to culture. Por exemplo, a ordem de classificação pode ser baseada em fonética ou na representação visual de caracteres.For example, the sort order may be based on phonetics or on the visual representation of characters. Em idiomas do leste asiático, os caracteres são classificados pelo traço e radical de ideogramas.In East Asian languages, characters are sorted by the stroke and radical of ideographs. A classificação também depende das linguagens de pedido e do uso de culturas para o alfabeto.Sorting also depends on the order languages and cultures use for the alphabet. Por exemplo, o idioma dinamarquês tem um caractere "Æ" que ele classifica após "Z" no alfabeto.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. Além disso, as comparações podem diferenciar maiúsculas de minúsculas ou não diferenciar maiúsculas de minúsculas e, em alguns casos, as regras também diferem por cultura.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. A comparação ordinal, por outro lado, usa os pontos de código Unicode de caracteres individuais em uma cadeia de caracteres ao comparar e classificar as cadeias.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

As regras de classificação determinam a ordem alfabética de caracteres Unicode e a comparação entre duas cadeias.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Por exemplo, o String.Compare(String, String, StringComparison) método compara duas cadeias de caracteres StringComparison com base no parâmetro.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Se o valor do parâmetro StringComparison.CurrentCulturefor, o método executará uma comparação linguística que usa as convenções da cultura atual; se o valor do StringComparison.Ordinalparâmetro for, o método executará uma comparação ordinal.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. Consequentemente, como mostra o exemplo a seguir, se a cultura atual for americana Inglês, a primeira chamada para o String.Compare(String, String, StringComparison) método (usando a comparação sensível à cultura) considera "a" menor que "a", mas a segunda chamada para o mesmo método (usando a comparação ordinal) considera "a" maior que "a".Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "A".

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       1                                                                                     
'       -32

O .NET oferece suporte a regras de classificação de palavras, cadeias de caracteres e ordinais:.NET supports word, string, and ordinal sort rules:

  • Uma classificação de palavra executa uma comparação de cadeias de caracteres sensível a cultura, em que determinados caracteres não alfanuméricos Unicode podem ter pesos especiais atribuídos a eles.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Por exemplo, o hífen (-) pode ter um peso muito pequeno atribuído a ele para que "Coop" e "co-op" apareçam ao lado um do outro em uma lista classificada.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Para obter uma lista dos String métodos que comparam duas cadeias de caracteres usando regras de classificação de palavras, consulte a seção operações de cadeia de caracteres por categoria .For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Uma classificação de cadeia de caracteres também executa uma comparação sensível à cultura.A string sort also performs a culture-sensitive comparison. É semelhante a uma classificação de palavras, exceto que não há casos especiais, e todos os símbolos não alfanuméricos são apresentados antes de todos os caracteres Unicode alfanuméricos.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. Duas cadeias de caracteres podem ser comparadas com o CompareInfo.Compare uso de regras de classificação de String options chamando as sobrecargas de método CompareOptions.StringSortque têm um parâmetro que é fornecido como um valor de.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. Observe que esse é o único método que o .NET fornece para comparar duas cadeias de caracteres usando regras de classificação de cadeias.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Uma classificação ordinal compara as cadeias de caracteres com base no valor numérico de cada objeto Char na cadeia de caracteres.An ordinal sort compares strings based on the numeric value of each Char object in the string. Uma comparação ordinal é automaticamente sensível a maiúsculas e minúsculas porque as versões minúsculas e maiúsculas de um caractere têm pontos de código diferentes.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. No entanto, se o caso não for importante, você poderá especificar uma comparação ordinal que ignora maiúsculas e minúsculas.However, if case is not important, you can specify an ordinal comparison that ignores case. Isso é equivalente a converter a cadeia de caracteres em maiúsculas usando a cultura invariável e, em seguida, executando uma comparação ordinal no resultado.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Para obter uma lista dos String métodos que comparam duas cadeias de caracteres usando as regras de classificação ordinal, consulte a seção operações de cadeia de caracteres por categoria .For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Uma comparação sensível à cultura é qualquer comparação que use explicitamente ou implicitamente um CultureInfo objeto, incluindo a cultura invariável especificada CultureInfo.InvariantCulture pela propriedade.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. A cultura implícita é a cultura atual, que é especificada pelas Thread.CurrentCulture Propriedades e. CultureInfo.CurrentCultureThe implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Há uma variação considerável na ordem de classificação de caracteres alfabéticos (ou seja, caracteres para os Char.IsLetter quais a truepropriedade retorna) entre culturas.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. Você pode especificar uma comparação sensível à cultura que usa as convenções de uma cultura específica fornecendo um CultureInfo objeto a um método de comparação de cadeia de caracteres, como. Compare(String, String, CultureInfo, CompareOptions)You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). Você pode especificar uma comparação sensível à cultura que usa as convenções da cultura atual fornecendo StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase CompareOptions ou qualquer membro CompareOptions.Ordinal da enumeração que não seja ou CompareOptions.OrdinalIgnoreCase a uma sobrecarga do Compare método.You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. Uma comparação sensível à cultura geralmente é apropriada para classificação, enquanto uma comparação ordinal não é.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. Uma comparação ordinal geralmente é apropriada para determinar se duas cadeias de caracteres são iguais (ou seja, para determinar a identidade), enquanto uma comparação sensível à cultura não é.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

O exemplo a seguir ilustra a diferença entre a comparação entre as culturas e a ordinal.The following example illustrates the difference between culture-sensitive and ordinal comparison. O exemplo avalia três cadeias de caracteres, "Apple", "æble" e "AEble", usando a comparação ordinal e as convenções das culturas da-DK e en-US (cada uma delas é a cultura padrão no momento em Compare que o método é chamado).The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). Como o idioma dinamarquês trata o caractere "Æ" como uma letra individual e o classifica após "Z" no alfabeto, a cadeia de caracteres "æble" é maior que "Apple".Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". No entanto, "æble" não é considerado equivalente a "AEble", portanto, "æble" também é maior que "AEble".However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". A cultura en-US não inclui a letra "Æ", mas a trata como equivalente a "AE", que explica por que "æble" é menor que "Apple", mas é igual a "AEble".The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". A comparação ordinal, por outro lado, considera que "Apple" seja menor que "æble" e "æble" para ser maior que "AEble".Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "AEble".

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      Dim str3 As String = "AEble"
      
      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison")
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Current culture: da-DK
'       Comparison of Apple with Æble: -1
'       Comparison of Æble with AEble: 1
'       
'       Current culture: en-US
'       Comparison of Apple with Æble: 1
'       Comparison of Æble with AEble: 0
'       
'       Ordinal comparison
'       Comparison of Apple with Æble: -133
'       Comparison of Æble with AEble: 133

Use as seguintes diretrizes gerais para escolher um método de comparação de classificação ou cadeia de caracteres apropriado:Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • Se você quiser que as cadeias de caracteres sejam ordenadas com base na cultura do usuário, solicite-as com base nas convenções da cultura atual.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. Se a cultura do usuário for alterada, a ordem das cadeias de caracteres classificadas também será alterada de acordo.If the user's culture changes, the order of sorted strings will also change accordingly. Por exemplo, um aplicativo de dicionário de sinônimos sempre deve classificar palavras com base na cultura do usuário.For example, a thesaurus application should always sort words based on the user's culture.

  • Se desejar que as cadeias de caracteres sejam ordenadas com base nas convenções de uma cultura específica, você deverá solicitá- CultureInfo las fornecendo um objeto que represente a cultura a um método de comparação.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. Por exemplo, em um aplicativo projetado para ensinar aos alunos um idioma específico, você deseja que as cadeias de caracteres sejam ordenadas com base nas convenções de uma das culturas que fala esse idioma.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • Se você quiser que a ordem das cadeias de caracteres permaneça inalterada entre culturas, solicite-as com base nas convenções da cultura invariável ou use uma comparação ordinal.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. Por exemplo, você usaria uma classificação ordinal para organizar os nomes de arquivos, processos, mutexes ou pipes nomeados.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • Para uma comparação que envolve uma decisão de segurança (como se um nome de usuário é válido), você sempre deve executar um teste ordinal para igualdade chamando uma sobrecarga do Equals método.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

Observação

As regras de classificação e uso sensível à cultura usadas na comparação de cadeias de caracteres dependem da versão do .NET.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. No .NET Framework 4,5 e versões posteriores em execução no Windows 8Windows 8 sistema operacional, a classificação, a maiúsculas e minúsculas, a normalização e as informações de caracteres Unicode estão em conformidade com o padrão Unicode 6,0.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. Em outros sistemas operacionais Windows, ele está em conformidade com o padrão Unicode 5,0.On other Windows operating systems, it conforms to the Unicode 5.0 standard. No .NET Core, depende da versão do padrão Unicode com suporte do sistema operacional subjacente.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Para obter mais informações sobre as regras de classificação de palavras, cadeias de System.Globalization.CompareOptions caracteres e ordinais, consulte o tópico.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Para obter recomendações adicionais sobre quando usar cada regra, consulte práticas recomendadas para usar cadeias de caracteres.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

Normalmente, você não chama métodos de comparação de cadeias de caracteres, como Compare diretamente, para determinar a ordem de classificação das cadeias.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. Em vez disso, os métodos de comparação são chamados por Array.Sort métodos List<T>.Sortde classificação, como ou.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. O exemplo a seguir executa quatro operações de classificação diferentes (classificação de palavras usando a cultura atual, classificação de palavras usando a cultura invariável, classificação Ordinal e classificação de cadeia de caracteres usando a cultura invariável) sem chamar explicitamente um método de comparação de cadeia de caracteres, Embora eles especifiquem o tipo de comparação a ser usado.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. Observe que cada tipo de classificação produz uma ordenação exclusiva de cadeias de caracteres em sua matriz.Note that each type of sort produces a unique ordering of strings in its array.

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;

// IComparer<String> implementation to perform string sort. 
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
   SCompare() {};

   virtual int Compare(String^ x, String^ y)
   {
      return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
   }
};

void main()
{
   array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative", 
                                                    L"co\x00ADoperative", L"c�ur", "coeur" };

   // Perform a word sort using the current (en-US) culture. 
   array<String^>^ current = gcnew array<String^>(strings->Length); 
   strings->CopyTo(current, 0); 
   Array::Sort(current, StringComparer::CurrentCulture);

   // Perform a word sort using the invariant culture. 
   array<String^>^ invariant = gcnew array<String^>(strings->Length);
   strings->CopyTo(invariant, 0); 
   Array::Sort(invariant, StringComparer::InvariantCulture);

   // Perform an ordinal sort. 
   array<String^>^ ordinal = gcnew array<String^>(strings->Length);
   strings->CopyTo(ordinal, 0); 
   Array::Sort(ordinal, StringComparer::Ordinal);

   // Perform a string sort using the current culture. 
   array<String^>^ stringSort = gcnew array<String^>(strings->Length);
   strings->CopyTo(stringSort, 0); 
   Array::Sort(stringSort, gcnew SCompare());

   // Display array values
   Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                     "Original", "Word Sort", "Invariant Word", 
                     "Ordinal Sort", "String Sort");
   for (int ctr = 0; ctr < strings->Length; ctr++)
      Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                         strings[ctr], current[ctr], invariant[ctr], 
                         ordinal[ctr], stringSort[ctr] );          
}
// The example displays the following output: 
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort 
//     
//             coop          c�ur            c�ur         co-op         co-op 
//            co-op         coeur           coeur         coeur          c�ur 
//      cooperative          coop            coop          coop         coeur 
//      co�operative         co-op           co-op   cooperative          coop 
//             c�ur   cooperative     cooperative   co�operative   cooperative 
//            coeur   co�operative     co�operative          c�ur   co�operative
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim strings() As String = { "coop", "co-op", "cooperative", 
                                  "co" + ChrW(&h00AD) + "operative", 
                                  "cœur", "coeur" }

      ' Perform a word sort using the current (en-US) culture.
      Dim current(strings.Length - 1) As String  
      strings.CopyTo(current, 0) 
      Array.Sort(current, StringComparer.CurrentCulture)

      ' Perform a word sort using the invariant culture.
      Dim invariant(strings.Length - 1) As String
      strings.CopyTo(invariant, 0) 
      Array.Sort(invariant, StringComparer.InvariantCulture)

      ' Perform an ordinal sort.
      Dim ordinal(strings.Length - 1) As String
      strings.CopyTo(ordinal, 0) 
      Array.Sort(ordinal, StringComparer.Ordinal)

      ' Perform a string sort using the current culture.
      Dim stringSort(strings.Length - 1) As String
      strings.CopyTo(stringSort, 0) 
      Array.Sort(stringSort, new SCompare())

      ' Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort")
      Console.WriteLine()
                                                      
      For ctr As Integer = 0 To strings.Length - 1
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings(ctr), current(ctr), invariant(ctr), 
                           ordinal(ctr), stringSort(ctr))   
      Next                                  
   End Sub
End Module

' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
   Public Function Compare(x As String, y As String) As Integer _
                   Implements IComparer(Of String).Compare
      Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
   End Function
End Class
' The example displays the following output:
'         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
'    
'             coop          cœur            cœur         co-op         co-op
'            co-op         coeur           coeur         coeur          cœur
'      cooperative          coop            coop          coop         coeur
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

Dica

Internamente, o .NET usa chaves de classificação para dar suporte à comparação de cadeia de caracteres culturalmente sensível.Internally, .NET uses sort keys to support culturally sensitive string comparison. Cada caractere em uma cadeia de caracteres recebe várias categorias de pesos de classificação, incluindo alfabeto, maiúsculas e minúsculas.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. Uma chave de classificação, representada pela SortKey classe, fornece um repositório desses pesos para uma cadeia de caracteres específica.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. Se seu aplicativo executar um grande número de operações de pesquisa ou classificação no mesmo conjunto de cadeias de caracteres, você poderá melhorar seu desempenho gerando e armazenando chaves de classificação para todas as cadeias de caracteres que ele usa.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. Quando uma operação de classificação ou comparação é necessária, você usa as chaves de classificação em vez das cadeias de caracteres.When a sort or comparison operation is required, you use the sort keys instead of the strings. Para obter mais informações, consulte a classe SortKey.For more information, see the SortKey class.

Se você não especificar uma Convenção de comparação de cadeia de caracteres, Array.Sort(Array) os métodos de classificação, como a execução de uma classificação de diferenciação de maiúsculas e minúsculas, em seqüências.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. O exemplo a seguir ilustra como a alteração da cultura atual afeta a ordem das cadeias de caracteres classificadas em uma matriz.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Ele cria uma matriz de três cadeias de caracteres.It creates an array of three strings. Primeiro, ele define a System.Threading.Thread.CurrentThread.CurrentCulture Propriedade como en-US e chama o Array.Sort(Array) método.First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. A ordem de classificação resultante é baseada em convenções de classificação para a cultura em inglês (Estados Unidos).The resulting sort order is based on sorting conventions for the English (United States) culture. Em seguida, o exemplo define System.Threading.Thread.CurrentThread.CurrentCulture a propriedade como da-DK e chama Array.Sort o método novamente.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. Observe como a ordem de classificação resultante difere dos resultados en-US porque ela usa as convenções de classificação para dinamarquês (Dinamarca).Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble
Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
      
      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

Aviso

Se a sua principal finalidade na comparação de cadeias de caracteres é determinar se elas são iguais, String.Equals você deve chamar o método.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. Normalmente, você deve usar Equals para executar uma comparação ordinal.Typically, you should use Equals to perform an ordinal comparison. O String.Compare método destina-se principalmente a classificar cadeias de caracteres.The String.Compare method is intended primarily to sort strings.

Os String.StartsWith métodos de pesquisa de cadeia de String.IndexOfcaracteres, como e, também podem executar comparações de cadeias de caracteres de cultura ou ordinais.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. O exemplo a seguir ilustra as diferenças entre as comparações ordinais e com distinção IndexOf de cultura usando o método.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. Uma pesquisa sensível à cultura na qual a cultura atual é inglês (Estados Unidos) considera a subcadeia de caracteres "OE" para corresponder à ligadura "œ".A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Como um hífen simples (U + 00AD) é um caractere de largura zero, a pesquisa trata o hífen suave como equivalente a Empty e localiza uma correspondência no início da cadeia de caracteres.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. Uma pesquisa ordinal, por outro lado, não encontra uma correspondência em ambos os casos.An ordinal search, on the other hand, does not find a match in either case.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2
using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2
Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

   Private Sub FindInString(s As String, substring As String, 
                            options As StringComparison)
      Dim result As Integer = s.IndexOf(substring, options)
      If result <> -1
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result)
      Else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s)
      End If                                                                          
   End Sub
End Module
' The example displays the following output:
'       'oe' found in œufs at position 0
'       'oe' not found in œufs
'       'œu' found in oeufs at position 0
'       'œu' not found in oeufs
'       
'       '­' found in co­operative at position 0
'       '­' found in co­operative at position 2

Pesquisando cadeias de caracteresSearching Strings

Os String.StartsWith métodos de pesquisa de cadeia de String.IndexOfcaracteres, como e, também podem executar comparações de cadeia de caracteres de cultura ou ordinais para determinar se um caractere ou uma subcadeia de caracteres é encontrada em uma cadeia de caracteres especificada.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

Os métodos de pesquisa na String classe que pesquisa um caractere individual, como o IndexOf método, ou um de um conjunto de caracteres, como o IndexOfAny método, todos executam uma pesquisa ordinal.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. Para executar uma pesquisa sensível à cultura para um caractere, você deve chamar um CompareInfo método CompareInfo.IndexOf(String, Char) como ou CompareInfo.LastIndexOf(String, Char).To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). Observe que os resultados da pesquisa de um caractere usando a comparação ordinal e sensível à cultura podem ser muito diferentes.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Por exemplo, uma pesquisa por um caractere Unicode precomposto, como a Ligadura "Æ" (U + 00C6), pode corresponder a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U + 041U + 0045), dependendo da cultura.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. O exemplo a seguir ilustra a diferença entre String.IndexOf(Char) os CompareInfo.IndexOf(String, Char) métodos e ao pesquisar um caractere individual.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. A Ligadura "æ" (U + 00E6) é encontrada na cadeia de caracteres "aérea" ao usar as convenções da cultura en-US, mas não ao usar as convenções da cultura da-DK ou ao executar uma comparação ordinal.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "da-DK", "en-US" }
      Dim ci As CompareInfo
      Dim str As String = "aerial"
      Dim ch As Char = "æ"c  ' U+00E6
      
      Console.Write("Ordinal comparison -- ")
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch))
      
      For Each cultureName In cultureNames
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
         Console.Write("{0} cultural comparison -- ", cultureName)
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch))
      Next
   End Sub
End Module
' The example displays the following output:
'       Ordinal comparison -- Position of 'æ' in aerial: -1
'       da-DK cultural comparison -- Position of 'æ' in aerial: -1
'       en-US cultural comparison -- Position of 'æ' in aerial: 0

Por outro lado, String os métodos de classe que pesquisam uma cadeia de caracteres em vez de um caractere executam uma pesquisa sensível à cultura se as opções de pesquisa não forem especificadas explicitamente por um parâmetro do tipo. StringComparisonOn the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. A única exceção é Contains, que executa uma pesquisa ordinal.The sole exception is Contains, which performs an ordinal search.

Testando igualdadeTesting for equality

Use o String.Compare método para determinar a relação entre duas cadeias de caracteres na ordem de classificação.Use the String.Compare method to determine the relationship of two strings in the sort order. Normalmente, essa é uma operação sensível à cultura.Typically, this is a culture-sensitive operation. Por outro lado, chame String.Equals o método para testar a igualdade.In contrast, call the String.Equals method to test for equality. Como o teste de igualdade geralmente compara a entrada do usuário com alguma cadeia de caracteres conhecida, como um nome de usuário válido, uma senha ou um caminho do sistema de arquivos, normalmente é uma operação ordinal.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

Aviso

É possível testar a igualdade chamando o String.Compare método e determinando se o valor de retorno é zero.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. No entanto, essa prática não é recomendada.However, this practice is not recommended. Para determinar se duas cadeias de caracteres são iguais, você deve chamar uma das sobrecargas String.Equals do método.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. A sobrecarga preferida a chamar é o método de Equals(String, StringComparison) instância ou o método Equals(String, String, StringComparison) estático, porque ambos os métodos incluem System.StringComparison um parâmetro que especifica explicitamente o tipo de comparação.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

O exemplo a seguir ilustra o perigo de executar uma comparação sensível à cultura para igualdade quando um ordinal deve ser usado em vez disso.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. Nesse caso, a intenção do código é proibir o acesso do sistema de arquivos de URLs que começam com "FILE://" ou "file://" executando uma comparação que não diferencia maiúsculas de minúsculas do início de uma URL com a cadeia de caracteres "FILE://".In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". No entanto, se uma comparação sensível à cultura for executada usando a cultura Turco (Turquia) em uma URL que começa com "file://", a comparação de igualdade falhará, pois o equivalente em maiúsculas turco da letra minúscula "i" é "i" em vez de "I".However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". Como resultado, o acesso ao sistema de arquivos é permitido inadvertidamente.As a result, file system access is inadvertently permitted. Por outro lado, se uma comparação ordinal for executada, a comparação para igualdade será realizada com sucesso e o acesso ao sistema de arquivos será negado.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

      String^ substring = str->Substring(0, position);  
      return substring->Equals("FILE", cmp);
}
// The example displays the following output: 
//       Culture-sensitive test for equality: 
//       Access to file://c:/notes.txt is allowed. 
//        
//       Ordinal test for equality: 
//       Access to file://c:/notes.txt is not allowed.
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")      

      Dim filePath As String = "file://c:/notes.txt"
      
      Console.WriteLine("Culture-sensitive test for equality:")
      If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
      Console.WriteLine()
      
      Console.WriteLine("Ordinal test for equality:")
      If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
   End Sub
   
   Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
      Dim position As Integer = str.IndexOf("://")
      If position < 0 Then Return False

      Dim substring As String = str.Substring(0, position)  
      Return substring.Equals("FILE", cmp)
   End Function
End Module
' The example displays the following output:
'       Culture-sensitive test for equality:
'       Access to file://c:/notes.txt is allowed.
'       
'       Ordinal test for equality:
'       Access to file://c:/notes.txt is not allowed.

NormalizaçãoNormalization

Alguns caracteres Unicode têm várias representações.Some Unicode characters have multiple representations. Por exemplo, qualquer um dos seguintes pontos de código pode representar a letra "ắ":For example, any of the following code points can represent the letter "ắ":

  • U + 1EAFU+1EAF

  • U+0103 U+0301U+0103 U+0301

  • U+0061 U+0306 U+0301U+0061 U+0306 U+0301

Várias representações para um único caractere complicam a pesquisa, classificação, correspondência e outras operações de cadeia de caracteres.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

O padrão Unicode define um processo chamado normalização que retorna uma representação binária de um caractere Unicode para qualquer uma de suas representações binárias equivalentes.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. A normalização pode usar vários algoritmos, chamados de formulários de normalização, que seguem regras diferentes.Normalization can use several algorithms, called normalization forms, that follow different rules. O .NET dá suporte a formulários de normalização Unicode C, D, KC e KD..NET supports Unicode normalization forms C, D, KC, and KD. Quando as cadeias de caracteres foram normalizadas para o mesmo formulário de normalização, elas podem ser comparadas usando a comparação ordinal.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Uma comparação ordinal é uma comparação binária do valor escalar Unicode dos objetos correspondentes Char em cada cadeia de caracteres.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. A String classe inclui vários métodos que podem executar uma comparação ordinal, incluindo o seguinte:The String class includes a number of methods that can perform an ordinal comparison, including the following:

Você pode determinar se uma cadeia de caracteres é normalizada para a forma de normalização String.IsNormalized() C chamando o método ou pode chamar String.IsNormalized(NormalizationForm) o método para determinar se uma cadeia de caracteres é normalizada para um formulário de normalização especificado.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. Você também pode chamar o String.Normalize() método para converter uma cadeia de caracteres no formulário de normalização C ou pode chamar String.Normalize(NormalizationForm) o método para converter uma cadeia de caracteres em um formulário de normalização especificado.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. Para obter informações passo a passo sobre como normalizar e comparar cadeias de caracteres Normalize() , Normalize(NormalizationForm) consulte os métodos e.For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

O exemplo simples a seguir ilustra a normalização de cadeia de caracteres.The following simple example illustrates string normalization. Ele define a letra "ố" de três maneiras diferentes em três cadeias de caracteres diferentes e usa uma comparação ordinal para igualdade para determinar que cada cadeia de caracteres difere das outras duas cadeias.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. Em seguida, ele converte cada cadeia de caracteres para os formulários de normalização com suporte e, novamente, executa uma comparação ordinal de cada cadeia de caracteres em um formulário de normalização especificado.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. Em cada caso, o segundo teste para igualdade mostra que as cadeias de caracteres são iguais.In each case, the second test for equality shows that the strings are equal.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;

public ref class Example
{
private:
   StreamWriter^ sw;

   void TestForEquality(... array<String^>^  words)
   {
      for (int ctr = 0; ctr <= words->Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words->Length - 1; ctr2++) 
            sw->WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr]->Equals(words[ctr2], StringComparison::Ordinal));
   }

   String^ ShowBytes(String^ str)
   {
      String^ result = nullptr;
      for each (Char ch in str)
         result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4")); 
      return result->Trim();            
   } 

   array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
   {
      for (int ctr = 0; ctr < words->Length; ctr++)
         if (! words[ctr]->IsNormalized(nf))
            words[ctr] = words[ctr]->Normalize(nf); 
      return words;   
   }

public: 
   void Execute()
   {
      sw = gcnew StreamWriter(".\\TestNorm1.txt");

      // Define three versions of the same word.  
      String^ s1 = L"sống";        // create word with U+1ED1 
      String^ s2 = L"s\x00F4\x0301ng";
      String^ s3 = L"so\x0302\x0301ng";

      TestForEquality(s1, s2, s3);      
      sw->WriteLine();

      // Normalize and compare strings using each normalization form. 
      for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
      {
         sw->WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
         array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
         TestForEquality(sn);           
         sw->WriteLine("\n");                                        
      }

      sw->Close(); 
   }
};

void main()
{
   Example^ ex = gcnew Example();
   ex->Execute();
}
// The example produces the following output:
// The example displays the following output: 
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False 
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//        
//       Normalization FormC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//        
//        
//       Normalization FormKC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormKD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }
      
      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
Imports System.Globalization
Imports System.IO
Imports System.Text

Module Example
   Private sw As StreamWriter
       
   Public Sub Main()
      sw = New StreamWriter(".\TestNorm1.txt")

      ' Define three versions of the same word. 
      Dim s1 As String = "sống"        ' create word with U+1ED1
      Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
      Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"

      TestForEquality(s1, s2, s3)      
      sw.WriteLine()

      ' Normalize and compare strings using each normalization form.
      For Each formName In [Enum].GetNames(GetType(NormalizationForm))
         sw.WriteLine("Normalization {0}:", formName) 
         Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),  
                                             NormalizationForm)
         Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
         TestForEquality(sn)           
         sw.WriteLine(vbCrLf)                                        
      Next
      
      sw.Close()   
   End Sub

   Private Sub TestForEquality(ParamArray words As String())
      For ctr As Integer = 0 To words.Length - 2
         For ctr2 As Integer = ctr + 1 To words.Length - 1 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words(ctr), ShowBytes(words(ctr)),
                         words(ctr2), ShowBytes(words(ctr2)),
                         words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
         Next                
      Next   
   End Sub

   Private Function ShowBytes(str As String) As String
      Dim result As String = Nothing
      For Each ch In str
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")) 
      Next
      Return result.Trim()            
   End Function  
   
   Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
      For ctr As Integer = 0 To words.Length - 1
         If Not words(ctr).IsNormalized(nf) Then
            words(ctr) = words(ctr).Normalize(nf)
         End If    
      Next
      Return words   
   End Function
End Module
' The example displays the following output:
'       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
'       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

Para obter mais informações sobre os formulários de normalização e normalização, consulte System.Text.NormalizationForm, bem como o anexo padrão Unicode #15: Os formulários de normalização Unicode e as perguntas frequentes sobre normalização no site Unicode.org.For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Operações da cadeia de caracteres por categoriaString operations by category

A String classe fornece membros para comparação de cadeias de caracteres, teste de cadeias para igualdade, localização de caractere ou subcadeias em uma cadeia de caracteres, modificação de uma cadeia de caracteres, extração de subcadeias de caracteres de uma cadeia, combinação de seqüências, valores de formatação, cópia de uma cadeia de caracteres e normalizando uma cadeia de caracteres.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

Comparando cadeias de caracteresComparing strings

Você pode comparar cadeias de caracteres para determinar sua posição relativa na ordem de classificação usando String os seguintes métodos:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • CompareRetorna um inteiro que indica a relação de uma cadeia de caracteres com uma segunda cadeia de caracteres na ordem de classificação.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinalRetorna um inteiro que indica a relação de uma cadeia de caracteres com uma segunda cadeia de caracteres com base em uma comparação de seus pontos de código.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareToRetorna um inteiro que indica a relação da instância de cadeia de caracteres atual com uma segunda cadeia de caracteres na ordem de classificação.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. O CompareTo(String) método fornece as IComparable implementações e IComparable<T> para String a classe.The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Testando igualdade das cadeias de caracteresTesting strings for equality

Você chama o Equals método para determinar se duas cadeias de caracteres são iguais.You call the Equals method to determine whether two strings are equal. A instância Equals(String, String, StringComparison) e as sobrecargas estáticas Equals(String, StringComparison) permitem especificar se a comparação é sensível à cultura ou ordinal e se o caso é considerado ou ignorado.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. A maioria dos testes de igualdade são ordinais e as comparações de igualdade que determinam o acesso a um recurso do sistema (como um objeto do sistema de arquivos) devem ser sempre ordinais.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

Localizando caracteres em uma cadeia de caracteresFinding characters in a string

A String classe inclui dois tipos de métodos de pesquisa:The String class includes two kinds of search methods:

Aviso

Se você quiser pesquisar uma cadeia de caracteres para um padrão específico em vez de uma subcadeia de caracteres específica, deverá usar expressões regulares.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Para obter mais informações, consulte expressões regulares do .net.For more information, see .NET Regular Expressions.

Modificando uma cadeia de caracteresModifying a string

A String classe inclui os seguintes métodos que parecem modificar o valor de uma cadeia de caracteres:The String class includes the following methods that appear to modify the value of a string:

  • InsertInsere uma cadeia de caracteres na String instância atual.Insert inserts a string into the current String instance.

  • PadLeftInsere uma ou mais ocorrências de um caractere especificado no início de uma cadeia de caracteres.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRightInsere uma ou mais ocorrências de um caractere especificado no final de uma cadeia de caracteres.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Removeexclui uma subcadeia da instância atual String .Remove deletes a substring from the current String instance.

  • Replacesubstitui uma subcadeia de caracteres por outra subcadeia de String caracteres na instância atual.Replace replaces a substring with another substring in the current String instance.

  • ToLowere ToLowerInvariant Converta todos os caracteres em uma cadeia de caracteres em minúsculas.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUppere ToUpperInvariant Converta todos os caracteres em uma cadeia de caracteres em letras maiúsculas.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • TrimRemove todas as ocorrências de um caractere do início e do fim de uma cadeia de caracteres.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEndRemove todas as ocorrências de um caractere do final de uma cadeia de caracteres.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStartRemove todas as ocorrências de um caractere do início de uma cadeia de caracteres.TrimStart removes all occurrences of a character from the beginning of a string.

Importante

Todos os métodos de modificação de cadeia String de caracteres retornam um novo objeto.All string modification methods return a new String object. Eles não modificam o valor da instância atual.They don't modify the value of the current instance.

Extraindo subcadeias de caracteres de uma cadeia de caracteresExtracting substrings from a string

O String.Split método separa uma única cadeia de caracteres em várias cadeias.The String.Split method separates a single string into multiple strings. Sobrecargas do método permitem que você especifique vários delimitadores, para determinar o número máximo de subcadeias de caracteres que o método extrai e para determinar se as cadeias de caracteres vazias (que ocorrem quando delimitadores são adjacentes) estão incluídas entre as cadeias de caracteres retornadas.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Combinando cadeias de caracteresCombining strings

Os métodos String a seguir podem ser usados para concatenação de cadeia de caracteres:The following String methods can be used for string concatenation:

  • Concatcombina uma ou mais subcadeias em uma única cadeia de caracteres.Concat combines one or more substrings into a single string.

  • JoinConcatena uma ou mais subcadeias de caracteres em um único elemento e adiciona um separador entre cada subcadeia de caracteres.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Formatando valoresFormatting values

O String.Format método usa o recurso de formatação composta para substituir um ou mais espaços reservados em uma cadeia de caracteres pela representação de cadeia de caracteres de algum objeto ou valor.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. O Format método é geralmente usado para fazer o seguinte:The Format method is often used to do the following:

  • Para inserir a representação de cadeia de caracteres de um valor numérico em uma cadeia de caracteres.To embed the string representation of a numeric value in a string.

  • Para inserir a representação de cadeia de caracteres de um valor de data e hora em uma cadeia de caracteres.To embed the string representation of a date and time value in a string.

  • Para inserir a representação de cadeia de caracteres de um valor de enumeração em uma cadeia de caracteres.To embed the string representation of an enumeration value in a string.

  • Para inserir a representação de cadeia de caracteres de algum objeto IFormattable que dá suporte à interface em uma cadeia de caracteres.To embed the string representation of some object that supports the IFormattable interface in a string.

  • Para justificar à direita ou justificar uma subcadeia de caracteres em um campo dentro de uma cadeia de caracteres maior.To right-justify or left-justify a substring in a field within a larger string.

Para obter informações detalhadas sobre as operações de formatação e exemplos Format , consulte o resumo de sobrecarga.For detailed information about formatting operations and examples, see the Format overload summary.

Copiando uma cadeia de caracteresCopying a string

Você pode chamar os seguintes String métodos para fazer uma cópia de uma cadeia de caracteres:You can call the following String methods to make a copy of a string:

  • CloneRetorna uma referência a um objeto String existente.Clone returns a reference to an existing String object.

  • CopyCria uma cópia de uma cadeia de caracteres existente.Copy creates a copy of an existing string.

  • CopyToCopia uma parte de uma cadeia de caracteres em uma matriz de caracteres.CopyTo copies a portion of a string to a character array.

Normalizando uma cadeia de caracteresNormalizing a string

Em Unicode, um único caractere pode ter vários pontos de código.In Unicode, a single character can have multiple code points. A normalização converte esses caracteres equivalentes na mesma representação binária.Normalization converts these equivalent characters into the same binary representation. O String.Normalize método executa a normalização e o String.IsNormalized método determina se uma cadeia de caracteres é normalizada.The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Para obter mais informações e um exemplo, consulte a seção normalização anteriormente neste tópico.For more information and an example, see the Normalization section earlier in this topic.

Construtores

String(Char*) String(Char*) String(Char*) String(Char*)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de caracteres Unicode.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de caracteres Unicode, uma posição de caractere inicial dentro dessa matriz e um tamanho.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inicializa uma nova instância da classe String para o valor indicado por um caractere Unicode repetido um número de vezes especificado.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

Inicializa uma nova instância de String classe para o valor indicado por uma matriz de caracteres Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inicializa uma nova instância da classe String para o valor indicado por uma matriz de caracteres Unicode, uma posição de caractere inicial dentro dessa matriz e um comprimento.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) String(SByte*)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro para uma matriz de inteiros de 8 bits com sinal.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de inteiros com sinal de 8 bits, uma posição inicial na matriz e um comprimento.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de inteiros com sinal de 8 bits, uma posição inicial na matriz, um comprimento e um objeto Encoding.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Campos

Empty Empty Empty Empty

Representa a cadeia de caracteres vazia.Represents the empty string. Este campo é somente leitura.This field is read-only.

Propriedades

Chars[Index] Chars[Index] Chars[Index] Chars[Index]
Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

Obtém o objeto Char em uma posição especificada no atual objeto String.Gets the Char object at a specified position in the current String object.

Chars[Range] Chars[Range] Chars[Range] Chars[Range]
Length Length Length Length

Obtém o número de caracteres no objeto String atual.Gets the number of characters in the current String object.

Métodos

Clone() Clone() Clone() Clone()

Retorna uma referência a essa instância de String.Returns a reference to this instance of String.

Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32)

Compara subcadeias de dois objetos String especificados e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean)

Compara as subcadeias de dois objetos String especificados, ignorando ou respeitando as maiúsculas e minúsculas, e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Compara subcadeias de caracteres de dois objetos String especificados, ignorando ou respeitando as maiúsculas e minúsculas e usando informações específicas da cultura para influenciar a comparação e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Compara duas subcadeias de caracteres String especificadas usando as opções de comparação especificadas e as informações específicas da cultura para influenciar a comparação e retorna um inteiro que indica o relacionamento entre as duas subcadeias de caracteres na ordem de classificação.Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison)

Compara as subcadeias de caracteres de dois especificado String objetos usando as regras especificadas e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

Compare(String, String) Compare(String, String) Compare(String, String) Compare(String, String)

Compara dois objetos String especificados e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean)

Compara dois objetos String especificados, ignorando ou respeitando as maiúsculas e minúsculas, e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo)

Compara dois objetos String especificados, ignorando ou respeitando as maiúsculas e minúsculas, bem como usando informações culturais específicas para influenciar a comparação e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions)

Compara dois objetos String especificados usando as opções de comparação especificadas e as informações específicas da cultura para influenciar a comparação e retorna um inteiro que indica o relacionamento entre as duas cadeias de caracteres na ordem de classificação.Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison)

Compara dois objetos String especificados usando as regras especificadas e retorna um inteiro que indica sua posição relativa na ordem de classificação.Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32)

Compara subcadeias de caracteres de dois objetos String especificados avaliando os valores numéricos dos objetos Char correspondentes em cada subcadeia de caracteres.Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String)

Compara dois objetos String especificados avaliando os valores numéricos dos objetos Char correspondentes em cada cadeia de caracteres.Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Compara essa instância com um Object especificado e indica se esta instância precede, segue ou aparece na mesma posição na ordem de classificação, conforme o Object especificado.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String) CompareTo(String) CompareTo(String) CompareTo(String)

Compara essa instância com um objeto String especificado e indica se esta instância precede, segue ou aparece na mesma posição na ordem de classificação, conforme a cadeia de caracteres especificada.Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

Concatena os membros de uma coleção de IEnumerable<T> construída do tipo String.Concatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

Cria a representação de cadeia de caracteres de um objeto especificado.Creates the string representation of a specified object.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

Concatena as representações de cadeia de caracteres de dois objetos especificados.Concatenates the string representations of two specified objects.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

Concatena as representações de cadeia de caracteres de três objetos especificados.Concatenates the string representations of three specified objects.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

Concatena as representações de cadeia de caracteres de quatro objetos especificados e quaisquer objetos especificados em uma lista de parâmetros opcionais de tamanho variável.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

Concatena as representações de cadeia de caracteres dos elementos em uma matriz Object especificada.Concatenates the string representations of the elements in a specified Object array.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena as representações de cadeia de caracteres de dois intervalos de caracteres somente leitura especificados.Concatenates the string representations of two specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena as representações de cadeia de caracteres de três intervalos de caracteres somente leitura especificados.Concatenates the string representations of three specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena as representações de cadeia de caracteres de quatro intervalos de caracteres somente leitura especificados.Concatenates the string representations of four specified read-only character spans.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

Concatena duas instâncias especificadas de String.Concatenates two specified instances of String.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

Concatena três instâncias especificadas de String.Concatenates three specified instances of String.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

Concatena quatro instâncias especificadas de String.Concatenates four specified instances of String.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

Concatena os elementos de uma matriz String especificada.Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

Concatena os membros de uma implementação IEnumerable<T>.Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)

Retorna um valor que indica se um caractere especificado ocorre nessa cadeia de caracteres.Returns a value indicating whether a specified character occurs within this string.

Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)

Retorna um valor que indica se um caractere especificado ocorre nessa cadeia de caracteres, usando as regras de comparação especificadas.Returns a value indicating whether a specified character occurs within this string, using the specified comparison rules.

Contains(String) Contains(String) Contains(String) Contains(String)

Retorna um valor que indica se uma subcadeia especificada ocorre nesta cadeia de caracteres.Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison)

Retorna um valor que indica se uma cadeia de caracteres especificada ocorre nessa cadeia de caracteres, usando as regras de comparação especificadas.Returns a value indicating whether a specified string occurs within this string, using the specified comparison rules.

Copy(String) Copy(String) Copy(String) Copy(String)

Cria uma nova instância de String com o mesmo valor que um String especificado.Creates a new instance of String with the same value as a specified String.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32)

Copia um número especificado de caracteres de uma posição especificada nesta instância para uma posição especificada em uma matriz de caracteres Unicode.Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>)
EndsWith(Char) EndsWith(Char) EndsWith(Char) EndsWith(Char)
EndsWith(String) EndsWith(String) EndsWith(String) EndsWith(String)

Determina se o final desta instância de cadeia de caracteres corresponde à cadeia de caracteres especificada.Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo)

Determina se o final dessa instância de cadeia de caracteres corresponde à cadeia de caracteres especificada quando comparada usando a cultura especificada.Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison)

Determina se o fim dessa instância de cadeia de caracteres corresponde à cadeia de caracteres especificada quando comparado ao uso da opção de comparação especificada.Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

EnumerateRunes() EnumerateRunes() EnumerateRunes() EnumerateRunes()

Retorna uma enumeração de Rune dessa cadeia de caracteres.Returns an enumeration of Rune from this string.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se essa instância e um objeto especificado, que também deve ser um objeto String, têm o mesmo valor.Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String) Equals(String) Equals(String) Equals(String)

Determina se essa instância e outro objeto String especificado têm o mesmo valor.Determines whether this instance and another specified String object have the same value.

Equals(String, String) Equals(String, String) Equals(String, String) Equals(String, String)

Determina se dois objetos String especificados têm o mesmo valor.Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison)

Determina se dois objetos String especificados têm o mesmo valor.Determines whether two specified String objects have the same value. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison)

Determina se essa cadeia de caracteres e um objeto String especificado têm o mesmo valor.Determines whether this string and a specified String object have the same value. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.A parameter specifies the culture, case, and sort rules used in the comparison.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

Substitui o item ou itens de formato em uma cadeia de caracteres especificada pela representação de cadeia de caracteres do objeto correspondente.Replaces the format item or items in a specified string with the string representation of the corresponding object. Um parâmetro fornece informações de formatação específicas da cultura.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

Substitui os itens de formato em uma cadeia de caracteres pela representação de cadeia de caracteres de dois objetos especificados.Replaces the format items in a string with the string representation of two specified objects. Um parâmetro fornece informações de formatação específicas da cultura.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

Substitui os itens de formato em uma cadeia de caracteres pela representação de cadeia de caracteres de três objetos especificados.Replaces the format items in a string with the string representation of three specified objects. Um parâmetro fornece informações de formatação específicas da cultura.An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

Substitui os itens de formato em uma cadeia de caracteres pelas representações cadeia de caracteres de objetos correspondentes em uma matriz especificada.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Um parâmetro fornece informações de formatação específicas da cultura.A parameter supplies culture-specific formatting information.

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

Substitui um ou mais itens de formato em uma cadeia de caracteres pela representação de cadeia de caracteres de um objeto especificado.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

Substitui os itens de formato em uma cadeia de caracteres pela representação de cadeia de caracteres de dois objetos especificados.Replaces the format items in a string with the string representation of two specified objects.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

Substitui os itens de formato em uma cadeia de caracteres pela representação de cadeia de caracteres de três objetos especificados.Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

Substitui o item de formato em uma cadeia de caracteres especificada pela representação de cadeia de caracteres de um objeto correspondente em uma matriz especificada.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Recupera um objeto que pode iterar os caracteres individuais nessa cadeia de caracteres.Retrieves an object that can iterate through the individual characters in this string.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retorna o código hash desta cadeia de caracteres.Returns the hash code for this string.

GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>)

Retorna o código hash para o intervalo de caracteres somente leitura fornecido.Returns the hash code for the provided read-only character span.

GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison)

Retorna o código hash para o intervalo de caracteres somente leitura fornecido usando as regras especificadas.Returns the hash code for the provided read-only character span using the specified rules.

GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)

Retorna o código hash para essa cadeia de caracteres usando as regras especificadas.Returns the hash code for this string using the specified rules.

GetPinnableReference() GetPinnableReference() GetPinnableReference() GetPinnableReference()

Retorna uma referência ao elemento da cadeia de caracteres no índice zero.Returns a reference to the element of the string at index zero.

GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Retorna o TypeCode para a classe String.Returns the TypeCode for class String.

IndexOf(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

Relata o índice baseado em zero da primeira ocorrência do caractere Unicode especificado na cadeia de caracteres.Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32)

Relata o índice baseado em zero da primeira ocorrência do caractere Unicode especificado na cadeia de caracteres.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. A pesquisa é iniciada em uma posição de caractere especificada.The search starts at a specified character position.

IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32)

Relata o índice baseado em zero da primeira ocorrência do caractere especificado nessa instância.Reports the zero-based index of the first occurrence of the specified character in this instance. A pesquisa é iniciada em uma posição de caractere especificada e examina um número especificado de posições de caracteres.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)

Relata o índice baseado em zero da primeira ocorrência do caractere Unicode especificado na cadeia de caracteres.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Um parâmetro especifica o tipo de pesquisa a ser usado para o caractere especificado.A parameter specifies the type of search to use for the specified character.

IndexOf(String) IndexOf(String) IndexOf(String) IndexOf(String)

Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada nessa instância.Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32)

Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada nessa instância.Reports the zero-based index of the first occurrence of the specified string in this instance. A pesquisa é iniciada em uma posição de caractere especificada.The search starts at a specified character position.

IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32)

Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada nessa instância.Reports the zero-based index of the first occurrence of the specified string in this instance. A pesquisa é iniciada em uma posição de caractere especificada e examina um número especificado de posições de caracteres.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison)

Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada no objeto String atual.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parâmetros especificam a posição inicial de pesquisa na cadeia de caracteres de atual, o número de caracteres na cadeia de caracteres atual para pesquisar e o tipo de pesquisa a ser usado para a cadeia de caracteres especificada.Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison)

Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada no objeto String atual.Reports the zero-based index of the first occurrence of the specified string in the current String object. Os parâmetros especificam a posição de pesquisa inicial na cadeia de caracteres atual e o tipo de pesquisa a ser usado para a cadeia de caracteres especificada.Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison)

Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada no objeto String atual.Reports the zero-based index of the first occurrence of the specified string in the current String object. Um parâmetro especifica o tipo de pesquisa a ser usado para a cadeia de caracteres especificada.A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[])

Relata o índice baseado em zero da primeira ocorrência nessa instância de qualquer caractere em uma matriz especificada de caracteres Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32)

Relata o índice baseado em zero da primeira ocorrência nessa instância de qualquer caractere em uma matriz especificada de caracteres Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. A pesquisa é iniciada em uma posição de caractere especificada.The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32)

Relata o índice baseado em zero da primeira ocorrência nessa instância de qualquer caractere em uma matriz especificada de caracteres Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. A pesquisa é iniciada em uma posição de caractere especificada e examina um número especificado de posições de caracteres.The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

Retorna uma nova cadeia de caracteres na qual uma cadeia de caracteres especificada é inserida em uma posição de índice especificada nesta instância.Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String) Intern(String) Intern(String) Intern(String)

Recupera a referência do sistema para o String especificado.Retrieves the system's reference to the specified String.

IsInterned(String) IsInterned(String) IsInterned(String) IsInterned(String)

Recupera uma referência a um String especificado.Retrieves a reference to a specified String.

IsNormalized() IsNormalized() IsNormalized() IsNormalized()

Indica se essa cadeia de caracteres está no formulário C de normalização Unicode.Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm)

Indica se esta cadeia de caracteres está no formulário de normalização Unicode especificado.Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String)

Indica se a cadeia de caracteres especificada é null ou uma cadeia de caracteres vazia ("").Indicates whether the specified string is null or an empty string ("").

IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String)

Indica se uma cadeia de caracteres especificada é null, vazia ou consiste apenas em caracteres de espaço em branco.Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[])
Join(Char, String[]) Join(Char, String[]) Join(Char, String[]) Join(Char, String[])
Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32)
Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>)

Concatena os membros de uma coleção de IEnumerable<T> construída do tipo String, usando o separador especificado entre cada membro.Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[]) Join(String, Object[]) Join(String, Object[]) Join(String, Object[])

Concatena os elementos de uma matriz de objetos, usando o separador especificado entre cada elemento.Concatenates the elements of an object array, using the specified separator between each element.

Join(String, String[]) Join(String, String[]) Join(String, String[]) Join(String, String[])

Concatena todos os elementos de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.Concatenates all the elements of a string array, using the specified separator between each element.

Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32)

Concatena os elementos especificados de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.Concatenates the specified elements of a string array, using the specified separator between each element.

Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>)
Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>)

Concatena os membros de uma coleção, usando o separador especificado entre cada membro.Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Relata a posição de índice com base em zero da última ocorrência de um caractere Unicode especificado nesta instância.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Relata a posição de índice com base em zero da última ocorrência de um caractere Unicode especificado nesta instância.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Relata a posição de índice que começa com zero da última ocorrência do caractere Unicode especificado em uma subcadeia de caracteres dentro dessa instância.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres especificada.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Relata o índice com base em zero da última ocorrência de uma cadeia de caracteres especificada dentro do objeto String atual.Reports the zero-based index of the last occurrence of a specified string within the current String object. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.The search starts at a specified character position and proceeds backward toward the beginning of the string. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres especificada.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Relata o índice com base em zero da última ocorrência de uma cadeia de caracteres especificada dentro do objeto String atual.Reports the zero-based index of the last occurrence of a specified string within the current String object. Um parâmetro especifica o tipo de pesquisa a ser usado para a cadeia de caracteres especificada.A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[])

Relata a posição de índice com base em zero da última ocorrência; neste caso, de um ou mais caracteres especificados em uma matriz Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32)

Relata a posição de índice com base em zero da última ocorrência; neste caso, de um ou mais caracteres especificados em uma matriz Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32)

Relata a posição de índice com base em zero da última ocorrência; neste caso, de um ou mais caracteres especificados em uma matriz Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

Retorna uma nova cadeia de caracteres cujo valor textual é o mesmo que essa cadeia de caracteres, mas cuja representação binária está no formato de normalização C Unicode.Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm)

Retorna uma nova cadeia de caracteres cujo valor textual é o mesmo que essa cadeia de caracteres, mas cuja representação binária está no formato de normalização Unicode especificado.Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) PadLeft(Int32)

Retorna uma nova cadeia de caracteres que alinha os caracteres à direita nessa instância, preenchendo-os com espaços à esquerda, para um tamanho total especificado.Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char)

Retorna uma nova cadeia de caracteres que alinha os caracteres à direita nessa instância, preenchendo-os à esquerda com um caractere Unicode especificado, para um tamanho total especificado.Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

PadRight(Int32) PadRight(Int32) PadRight(Int32) PadRight(Int32)

Retorna uma nova cadeia de caracteres que alinha os caracteres à esquerda nessa cadeia de caracteres, preenchendo-os com espaços à direita, para um tamanho total especificado.Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char)

Retorna uma nova cadeia de caracteres que alinha os caracteres à esquerda nessa cadeia de caracteres, preenchendo-os à direita com um caractere Unicode especificado, para um tamanho total especificado.Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32) Remove(Int32) Remove(Int32) Remove(Int32)

Retorna uma nova cadeia de caracteres na qual todos os caracteres na instância atual, começando na posição especificada e continuando até a última posição, foram excluídos.Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

Retorna uma nova cadeia de caracteres em que um número especificado de caracteres na instância atual que começa na posição especificada foi excluído.Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

Retorna uma nova cadeia de caracteres na qual todas as ocorrências de um caractere Unicode especificado nessa instância são substituídas por outro caractere Unicode especificado.Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Retorna uma nova cadeia de caracteres na qual todas as ocorrências de uma cadeia de caracteres especificada na instância atual são substituídas por outra cadeia de caracteres especificada.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo)
Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison)
Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Divide uma cadeia de caracteres em subcadeias de caracteres baseadas nos caracteres de uma matriz.Splits a string into substrings that are based on the characters in an array.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nos caracteres em uma matriz.Splits a string into a maximum number of substrings based on the characters in an array. Especifique também o número máximo de subcadeias de caracteres a serem retornadas.You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nos caracteres em uma matriz.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Divide uma cadeia de caracteres em subcadeias de caracteres baseadas nos caracteres de uma matriz.Splits a string into substrings based on the characters in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

Divide uma cadeia de caracteres em um número máximo de subcadeias de caracteres baseadas nas cadeias de caracteres de uma matriz.Splits a string into a maximum number of substrings based on the strings in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Divide uma cadeia de caracteres em subcadeias de caracteres com base nas cadeias de caracteres em uma matriz.Splits a string into substrings based on the strings in an array. Especifique se as subcadeias de caracteres incluem elementos de matriz vazia.You can specify whether the substrings include empty array elements.

StartsWith(Char) StartsWith(Char) StartsWith(Char) StartsWith(Char)
StartsWith(String) StartsWith(String) StartsWith(String) StartsWith(String)

Determina se o começo desta instância de cadeia de caracteres corresponde à cadeia de caracteres especificada.Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo)

Determina se o início dessa instância de cadeia de caracteres corresponde à cadeia de caracteres especificada quando comparada usando a cultura especificada.Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison)

Determina se o início dessa instância de cadeia de caracteres corresponde à cadeia de caracteres especificada quando comparado à opção de comparação especificada.Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Index) Substring(Index) Substring(Index) Substring(Index)
Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

Recupera uma subcadeia de caracteres desta instância.Retrieves a substring from this instance. A subcadeia de caracteres começa em uma posição de caractere especificado e continua até o final da cadeia de caracteres.The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

Recupera uma subcadeia de caracteres desta instância.Retrieves a substring from this instance. A subcadeia de caracteres começa em uma posição de caractere especificado e tem um comprimento especificado.The substring starts at a specified character position and has a specified length.

Substring(Range) Substring(Range) Substring(Range) Substring(Range)
ToCharArray() ToCharArray() ToCharArray() ToCharArray()

Copia os caracteres nesta instância para uma matriz de caracteres Unicode.Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32)

Copia os caracteres em uma subcadeia de caracteres especificada nesta instância para uma matriz de caracteres Unicode.Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower() ToLower() ToLower() ToLower()

Retorna uma cópia dessa cadeia de caracteres convertida em minúsculas.Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo)

Retorna uma cópia desta cadeia de caracteres convertida em minúsculas, usando as regras de maiúsculas e minúsculas da cultura especificada.Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() ToLowerInvariant()

Retorna uma cópia deste objeto String convertido em minúsculas usando as regras de maiúsculas e minúsculas da cultura invariável.Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString() ToString() ToString() ToString()

Retorna esta instância do String; nenhuma conversão em si é executada.Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Retorna esta instância do String; nenhuma conversão em si é executada.Returns this instance of String; no actual conversion is performed.

ToUpper() ToUpper() ToUpper() ToUpper()

Retorna uma cópia dessa cadeia de caracteres convertida em maiúsculas.Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo)

Retorna uma cópia desta cadeia de caracteres convertida em maiúsculas, usando as regras de maiúsculas e minúsculas da cultura especificada.Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant() ToUpperInvariant() ToUpperInvariant() ToUpperInvariant()

Retorna uma cópia deste objeto String convertido em maiúsculas usando as regras de maiúsculas e minúsculas da cultura invariável.Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim() Trim() Trim() Trim()

Remove todos os caracteres de espaço em branco à esquerda e à direita do objeto String atual.Removes all leading and trailing white-space characters from the current String object.

Trim(Char) Trim(Char) Trim(Char) Trim(Char)
Trim(Char[]) Trim(Char[]) Trim(Char[]) Trim(Char[])

Remove todas as ocorrências à esquerda e à direita de um conjunto de caracteres especificados em uma matriz do atual objeto String.Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

TrimEnd() TrimEnd() TrimEnd() TrimEnd()
TrimEnd(Char) TrimEnd(Char) TrimEnd(Char) TrimEnd(Char)
TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[])

Remove todas as ocorrências à direita de um conjunto de caracteres especificados em uma matriz do atual objeto String.Removes all trailing occurrences of a set of characters specified in an array from the current String object.

TrimStart() TrimStart() TrimStart() TrimStart()
TrimStart(Char) TrimStart(Char) TrimStart(Char) TrimStart(Char)
TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[])

Remove todas as ocorrências à esquerda de um conjunto de caracteres especificados em uma matriz do atual objeto String.Removes all leading occurrences of a set of characters specified in an array from the current String object.

Operadores

Equality(String, String) Equality(String, String) Equality(String, String) Equality(String, String)

Determina se duas cadeias de caracteres especificadas têm o mesmo valor.Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>)
Inequality(String, String) Inequality(String, String) Inequality(String, String) Inequality(String, String)

Determina se duas cadeias de caracteres especificadas têm valores diferentes.Determines whether two specified strings have different values.

Implantações explícitas de interface

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

Para obter uma descrição desse membro, consulte ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Para obter uma descrição desse membro, consulte ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Para obter uma descrição desse membro, consulte ToChar(IFormatProvider).For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Para obter uma descrição desse membro, consulte ToDateTime(IFormatProvider).For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Para obter uma descrição desse membro, consulte ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Para obter uma descrição desse membro, consulte ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Para obter uma descrição desse membro, consulte ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Para obter uma descrição desse membro, consulte ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Para obter uma descrição desse membro, consulte ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Para obter uma descrição desse membro, consulte ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Para obter uma descrição desse membro, consulte ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

Para obter uma descrição desse membro, consulte ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Para obter uma descrição desse membro, consulte ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Para obter uma descrição desse membro, consulte ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Para obter uma descrição desse membro, consulte ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Retorna um enumerador que itera pelo objeto String atual.Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator()

Retorna um enumerador que itera pelo objeto String atual.Returns an enumerator that iterates through the current String object.

Métodos de Extensão

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

Retorna um DataTable que contém cópias dos objetos DataRow, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

AsMemory(String) AsMemory(String) AsMemory(String) AsMemory(String)

Cria um ReadOnlyMemory<Char> na parte da cadeia de caracteres de destino.Creates a new ReadOnlyMemory<Char> over the portion of the target string.

AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index)

Cria um ReadOnlyMemory<Char> em uma parte da cadeia de caracteres de destino começando em um índice especificado.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified index.

AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32)

Cria um ReadOnlyMemory<Char> em uma parte da cadeia de caracteres de destino começando em uma posição de caractere especificada.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified character position.

AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32)

Cria um ReadOnlyMemory<Char> em uma parte da cadeia de caracteres de destino começando em uma posição especificada com um tamanho.Creates a new ReadOnlyMemory<Char> over a portion of the target string beginning at a specified position with a length.

AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range)

Cria um ReadOnlyMemory<Char> em um intervalo especificado da cadeia de caracteres de destino.Creates a new ReadOnlyMemory<Char> over a specified range of the target string.

AsSpan(String) AsSpan(String) AsSpan(String) AsSpan(String)

Cria um intervalo somente leitura em uma parte da cadeia de caracteres de destino com base em uma posição especificada para um número especificado de caracteres.Creates a new read-only span over a portion of the target string from a specified position for a specified number of characters.

AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32)

Cria um intervalo somente leitura em uma parte da cadeia de caracteres de destino com base em uma posição especificada até o final da cadeia de caracteres.Creates a new read-only span over a portion of the target string from a specified position to the end of the string.

AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32)

Cria um intervalo somente leitura em uma cadeia de caracteres.Creates a new read-only span over a string.

IsNormalized(String) IsNormalized(String) IsNormalized(String) IsNormalized(String)

Indica se a cadeia de caracteres especificada está no formato de normalização Unicode C.Indicates whether the specified string is in Unicode normalization form C.

IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm)

Indica se uma cadeia de caracteres está em um formato de normalização Unicode especificado.Indicates whether a string is in a specified Unicode normalization form.

Normalize(String) Normalize(String) Normalize(String) Normalize(String)

Normaliza uma cadeia de caracteres com relação a um formato de normalização Unicode C.Normalizes a string to a Unicode normalization form C.

Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm)

Normaliza uma cadeia de caracteres com relação ao formato de normalização Unicode.Normalizes a string to the specified Unicode normalization form.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós descendentes de todos os documentos e elementos na coleção de origem.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

Retorna uma coleção dos filhos elementos de cada elemento e o documento na coleção de origem.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada dos elementos filho de cada elemento e documento na coleção de origem.Returns a filtered collection of the child elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>)

Retorna uma coleção de nós que contém todos os nós na coleção de origem, classificados em ordem segundo o documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós filhos de todos os documentos e elementos na coleção de origem.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

Remove todos os nós na coleção de origem do respectivo nó pai.Removes every node in the source collection from its parent node.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também