String Classe

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Representa o texto como uma sequência de unidades de código UTF-16.

public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>

Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)

Herança

Object

String

Implementações

IEnumerable<Char> IEnumerable IComparable IComparable<String> IConvertible IEquatable<String> ICloneable

Comentários

Uma cadeia de caracteres é uma coleção sequencial de caracteres que é usada para representar texto. Um String objeto é uma coleção sequencial de System.Char objetos que representam uma cadeia de caracteres; um System.Char objeto corresponde a uma unidade de código UTF-16. 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). Para obter mais informações sobre a imutabilidade das cadeias de caracteres, consulte a seção Imutabilidade e a classe StringBuilder . O tamanho máximo de um String objeto na memória é de 2 GB ou cerca de 1 bilhão de caracteres.

Para obter mais informações sobre Unicode, UTF-16, unidades de código, pontos de código e tipos Char e Rune , consulte Introdução à codificação de caracteres no .NET.

Nesta seção:

Criar uma instância de um objeto String
Objetos Char e caracteres Unicode
Cadeias de caracteres e o Padrão Unicode
Cadeias de caracteres e caracteres nulos inseridos
Cadeias de caracteres e índices
Cadeias de caracteres nulas e cadeias de caracteres vazias
Imutabilidade e a classe StringBuilder
Ordinal x operações sensíveis à cultura
Normalização
Operações da cadeia de caracteres por categoria

Criar uma instância de um objeto String

Você pode instanciar um String objeto das seguintes maneiras:

• Atribuindo um literal de cadeia de caracteres a uma String variável. Esse é o método mais usado para criar uma cadeia de caracteres. O exemplo a seguir usa atribuição para criar várias cadeias de caracteres. Observe que em C# e F#, como a barra invertida (\) é um caractere de escape, as barras invertidas literais em uma cadeia de caracteres devem ser escapadas ou toda a cadeia de caracteres deve ser @-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
  

  let string1 = "This is a string created by assignment."
  printfn "%s" string1
  let string2a = "The path is C:\\PublicDocuments\\Report1.doc"
  printfn "%s" string2a
  let string2b = @"The path is C:\PublicDocuments\Report1.doc"
  printfn "%s" 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 String construtor de classe. O exemplo a seguir cria uma instância das cadeias de caracteres chamando vários construtores de classe. Observe que alguns dos construtores incluem ponteiros para matrizes de caracteres ou matrizes de bytes assinadas como parâmetros. O Visual Basic não dá suporte a chamadas para esses construtores. Para obter informações detalhadas sobre String construtores, consulte o resumo do String construtor.

  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
  

  let chars = [| 'w'; 'o'; 'r'; 'd' |]
  let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |]
  
  // Create a string from a character array.
  let string1 = String chars
  printfn "%s" string1
  
  // Create a string that consists of a character repeated 20 times.
  let string2 = String('c', 20)
  printfn "%s" string2
  
  let stringFromBytes =
      // Create a string from a pointer to a signed byte array.
      use pbytes = fixed bytes
      String pbytes
  let stringFromChars = 
      // Create a string from a pointer to a character array.
      use pchars = fixed chars
      String pchars
  
  printfn $"{stringFromBytes}"
  printfn $"{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 (+ em C# e F#, e & ou + no Visual Basic) para criar uma única cadeia de caracteres de qualquer combinação de String instâncias e literais de cadeia de caracteres. O exemplo a seguir ilustra o uso do operador de concatenação de cadeia de caracteres.

  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.
  

  let string1 = "Today is " + DateTime.Now.ToString("D") + "."
  printfn $"{string1}"
  
  let string2 = "This is one sentence. " + "This is a second. "
  let string2 = string2 + "This is a third sentence."
  printfn $"{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. O exemplo a seguir usa os métodos da String classe para extrair uma subcadeia de caracteres de uma cadeia de caracteres maior.

  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
  

  let sentence = "This sentence has five words."
  // Extract the second word.
  let startPosition = sentence.IndexOf " " + 1
  let word2 = 
      sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition)
  printfn $"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. 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.

  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.
  

  let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0)
  let temperature = 68.3
  String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature)
  |> printfn "%s"
  // 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 Unicode

Cada caractere em uma cadeia de caracteres é definido por um valor escalar Unicode, também chamado de ponto de código Unicode ou o valor ordinal (numérico) do caractere Unicode. 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 .

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. Por exemplo, é possível criar uma cadeia de caracteres que tenha um substituto baixo sem um substituto alto correspondente. Embora alguns métodos, como os métodos de codificação e decodificação de objetos no System.Text namespace, possam executar verificações para garantir que as cadeias de caracteres estejam bem formadas, String os membros da classe não garantem que uma cadeia de caracteres esteja bem formada.

Um único Char objeto geralmente representa um único ponto de código; ou seja, o valor numérico do Char é igual ao ponto de código. Por exemplo, o ponto de código para o caractere "a" é U+0061. No entanto, um ponto de código pode exigir mais de um elemento codificado (mais de um Char objeto). O padrão Unicode define dois tipos de caracteres que correspondem a vários Char objetos: grafemas e pontos de código suplementar Unicode que correspondem a caracteres nos planos suplementares Unicode.

• Um grafema é representado por um caractere base seguido por um ou mais caracteres de combinação. Por exemplo, o caractere ä é representado por um Char objeto cujo ponto de código é U+0061 seguido por um Char objeto cujo ponto de código é U+0308. Esse caractere também pode ser definido por um único Char objeto que tem um ponto de código de U+00E4. Como mostra o exemplo a seguir, uma comparação sensível à cultura quanto à igualdade indica que essas duas representações são iguais, embora uma comparação ordinal comum não seja. No entanto, se as duas cadeias de caracteres forem normalizadas, uma comparação ordinal também indicará que elas são iguais. (Para obter mais informações sobre como normalizar cadeias de caracteres, consulte a seção Normalização .)

  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
  

  open System
  open System.IO
  
  do
      use sw = new StreamWriter(@".\graphemes.txt")
      let grapheme = "\u0061\u0308"
      sw.WriteLine grapheme
  
      let 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))
  // 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 alternativo) é representado por um Char objeto cujo ponto de código é um substituto alto seguido por um Char objeto cujo ponto de código é um substituto baixo. As unidades de código de substitutos altos variam de U+D800 a U+DBFF. As unidades de código de substitutos baixos variam de U+DC00 a U+DFFF. Pares alternativos são usados para representar caracteres nos 16 planos suplementares Unicode. O exemplo a seguir cria um caractere alternativo e o passa para o Char.IsSurrogatePair(Char, Char) método para determinar se ele é um par substituto.

  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+{(ushort)surrogate[ctr]:X2} ");
  
  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
  

  open System
  
  let surrogate = "\uD800\uDC03"
  for i = 0 to surrogate.Length - 1 do
      printf $"U+{uint16 surrogate[i]:X2} "
  
  printfn $"\n   Is Surrogate Pair: {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 Unicode

Os caracteres em uma cadeia de caracteres são representados por unidades de código codificadas em UTF-16, que correspondem aos Char valores.

Cada caractere em uma cadeia de caracteres tem uma categoria de caractere Unicode associada, que é representada no .NET pela UnicodeCategory enumeração . A categoria de um caractere ou um par substituto pode ser determinada chamando o CharUnicodeInfo.GetUnicodeCategory método .

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. Em todas as versões do .NET e em todas as plataformas do sistema operacional, as informações de categoria de caracteres são fornecidas pelo Banco de Dados de Caracteres Unicode.

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.

Versão do .NET	Versão do Padrão Unicode
.NET Framework 1.1	O Padrão Unicode, versão 4.0.0
.NET Framework 2.0	O Padrão Unicode, versão 5.0.0
.NET Framework 3.5	O Padrão Unicode, versão 5.0.0
.NET Framework 4	O Padrão Unicode, versão 5.0.0
.NET Framework 4.5	O Padrão Unicode, versão 6.3.0
.NET Framework 4.5.1	O Padrão Unicode, versão 6.3.0
.NET Framework 4.5.2	O Padrão Unicode, versão 6.3.0
.NET Framework 4.6	O Padrão Unicode, versão 6.3.0
.NET Framework 4.6.1	O Padrão Unicode, versão 6.3.0
.NET Framework 4.6.2 e versões posteriores	O Padrão Unicode, versão 8.0.0
.NET Core 2.1	O Padrão Unicode, versão 8.0.0
.NET Core 3.1	O Padrão Unicode, versão 11.0.0
.NET 5	O Padrão Unicode, versão 13.0.0

Além disso, o .NET dá suporte à comparação de cadeias de caracteres e à classificação com base no padrão Unicode. .NET Framework 4 e versões anteriores mantêm sua própria tabela de dados de cadeia de caracteres. Isso também acontece com versões do .NET Framework começando com o .NET Framework 4.5 em execução no Windows 7. A partir do .NET Framework 4.5 em execução no Windows 8 e versões posteriores do sistema operacional Windows, o runtime delega operações de comparação e classificação de cadeia de caracteres para o sistema operacional. No .NET Core e no .NET 5+, as informações de comparação e classificação de cadeias de caracteres são fornecidas por Componentes Internacionais para bibliotecas Unicode (exceto em versões do Windows anteriores à Atualização de maio de 2019 do Windows 10). A tabela a seguir lista as versões do .NET e as versões do Padrão Unicode nas quais a comparação e a classificação de caracteres se baseiam.

Versão do .NET	Versão do Padrão Unicode
.NET Framework 1.1	O Padrão Unicode, versão 4.0.0
.NET Framework 2.0	O Padrão Unicode, versão 5.0.0
.NET Framework 3.5	O Padrão Unicode, versão 5.0.0
.NET Framework 4	O Padrão Unicode, versão 5.0.0
.NET Framework 4.5 e posterior no Windows 7	O Padrão Unicode, versão 5.0.0
.NET Framework 4.5 e posterior nos sistemas operacionais Windows 8 e posteriores	O Padrão Unicode, versão 6.3.0
.NET Core e .NET 5+	Depende da versão do padrão Unicode compatível com o sistema operacional subjacente.

Cadeias de caracteres e caracteres nulos inseridos

No .NET, um String objeto pode incluir caracteres nulos inseridos, que contam como parte do comprimento da cadeia de caracteres. No entanto, em algumas linguagens, como C e C++, um caractere nulo indica o fim de uma cadeia de caracteres; ele não é considerado uma parte da cadeia de caracteres e não é contado como parte do comprimento da cadeia de caracteres. Isso significa que as seguintes suposições comuns que programadores ou bibliotecas C e C++ escritas em C ou C++ podem fazer sobre cadeias de caracteres não são necessariamente válidas quando aplicadas a String objetos:

• O valor retornado pelas strlen funções ou wcslen não é necessariamente igual String.Lengtha .

• A cadeia de caracteres criada pelas strcpy_s funções ou wcscpy_s não é necessariamente idêntica à cadeia de caracteres criada pelo String.Copy método .

Você deve garantir que o código C e C++ nativo que instancia String objetos e o código que é passado String objetos por meio da invocação de plataforma, não suponha que um caractere nulo inserido marque o final da cadeia de caracteres.

Caracteres nulos 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 é pesquisada. Caracteres nulos são ignorados ao executar comparações sensíveis à cultura entre duas cadeias de caracteres, incluindo comparações usando a cultura invariável. Elas são consideradas apenas para comparações ordinais ordinais ou ordinais que não diferenciam maiúsculas de minúsculas. Por outro lado, caracteres nulos inseridos são sempre considerados ao pesquisar uma cadeia de caracteres com métodos como Contains, StartsWithe IndexOf.

Cadeias de caracteres e índices

Um índice é a posição de um Char objeto (não um caractere Unicode) em um String. Um índice é um número não negativo baseado em zero que começa da primeira posição na cadeia de caracteres, que é a posição de índice zero. Vários métodos de pesquisa, como IndexOf e LastIndexOf, retornam o índice de um caractere ou subcadeia de caracteres na instância de cadeia de caracteres.

A Chars[] propriedade permite acessar objetos individuais Char por sua posição de índice na cadeia de caracteres. Como a Chars[] propriedade é a propriedade padrão (no Visual Basic) ou o indexador (em C# e F#), você pode acessar os objetos individuais Char em uma cadeia de caracteres usando código como o seguinte. Esse código procura caracteres de espaço em branco ou pontuação em uma cadeia de caracteres para determinar quantas palavras a cadeia de caracteres contém.

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.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for i = 0 to s1.Length - 1 do
    if Char.IsPunctuation s1[i] || Char.IsWhiteSpace s1[i] then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// 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 por meio dos Char objetos em uma cadeia de caracteres usando um foreach constructo, como mostra o exemplo a seguir.

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.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for ch in s1 do
    if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// 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.

Valores de índice consecutivos podem não corresponder a caracteres Unicode consecutivos, pois um caractere Unicode pode ser codificado como mais de um Char objeto. 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 de combinação ou por pares alternativos. Para trabalhar com caracteres Unicode em vez de Char objetos, use as System.Globalization.StringInfo classes e TextElementEnumerator ou o String.EnumerateRunes método e o Rune struct. O exemplo a seguir ilustra a diferença entre o código que funciona com Char objetos e código que funciona com caracteres Unicode. Ele compara o número de caracteres ou elementos de texto em cada palavra de uma frase. A cadeia de caracteres inclui duas sequências de um caractere base seguido por um caractere de combinação.

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

open System
open System.Globalization

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

for ch in opening do
    // Skip the ' character.
    if ch <> '\u0027' then
        if Char.IsWhiteSpace ch || Char.IsPunctuation ch then
            chars.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

let te = StringInfo.GetTextElementEnumerator opening
while te.MoveNext() do
    let s = te.GetTextElement()
    // Skip the ' character.
    if s <> "\u0027" then
        if String.IsNullOrEmpty(s.Trim()) || (s.Length = 1 && Char.IsPunctuation(Convert.ToChar s)) then
            elements.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

// Display character counts.
printfn "%6s %20s %20s" "Word #" "Char Objects " "Characters"
for i = 0 to chars.Count - 1 do
    printfn "%6d %20d %20d" i chars[i] elements[i]
// 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. Você também pode recuperar uma matriz que contém o índice inicial de cada elemento de texto chamando o StringInfo.ParseCombiningCharacters método .

Para obter mais informações sobre como trabalhar com unidades de texto em vez de valores individuais Char , consulte Introdução à codificação de caracteres no .NET.

Cadeias de caracteres nulas e cadeias de caracteres vazias

Uma cadeia de caracteres que foi declarada, mas não recebeu um valor, é null. Tentar chamar métodos nessa cadeia de caracteres lança um NullReferenceException. Uma cadeia de caracteres nula é diferente de uma cadeia de caracteres vazia, que é uma cadeia de caracteres cujo valor é "" ou String.Empty. Em alguns casos, passar uma cadeia de caracteres nula ou uma cadeia de caracteres vazia como um argumento em uma chamada de método gera uma exceção. Por exemplo, passar uma cadeia de caracteres nula para o Int32.Parse método lança um ArgumentNullExceptione passar uma cadeia de caracteres vazia lança um FormatException. Em outros casos, um argumento de método pode ser uma cadeia de caracteres nula ou uma cadeia de caracteres vazia. Por exemplo, se você estiver fornecendo uma IFormattable implementação para uma classe, deseja equiparar uma cadeia de caracteres nula e uma cadeia de caracteres vazia com o especificador de formato geral ("G").

A String classe inclui os dois métodos de conveniência a seguir que permitem testar se uma cadeia de caracteres está null ou vazia:

• IsNullOrEmpty, que indica se uma cadeia de caracteres é null ou é igual a String.Empty. Esse método elimina a necessidade de usar código como o seguinte:

  if (str == nullptr || str->Equals(String::Empty))
  

  if (str == null || str.Equals(String.Empty))
  

  if str = null || str.Equals String.Empty then
  

  If str Is Nothing OrElse str.Equals(String.Empty) Then
  

• IsNullOrWhiteSpace, que indica se uma cadeia de caracteres String.Emptyé null, é igual a ou consiste exclusivamente em caracteres de espaço em branco. Esse método elimina a necessidade de usar código como o seguinte:

  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 = null || str.Equals String.Empty || str.Trim().Equals String.Empty then
  

  If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
  

O exemplo a seguir usa o IsNullOrEmpty método na IFormattable.ToString implementação de uma classe personalizada Temperature . O método dá suporte às cadeias de caracteres de formato "G", "C", "F" e "K". Se uma cadeia de caracteres de formato vazia ou uma cadeia de caracteres de formato cujo valor é null passado para o método, seu valor será alterado para a cadeia de caracteres de formato "G".

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));
   }                                   
}

member _.ToString(format: string, provider: IFormatProvider) =
    let format = 
        if String.IsNullOrEmpty format then "G" else format
    
    let provider: IFormatProvider = 
        if provider = null then CultureInfo.CurrentCulture else provider

    match format.ToUpperInvariant() with
    // Return degrees in Celsius.
    | "G"
    | "C" ->
        temp.ToString("F2", provider) + "°C"
    // Return degrees in Fahrenheit.
    | "F" ->
        (temp * 9. / 5. + 32.).ToString("F2", provider) + "°F"
    // Return degrees in Kelvin.
    | "K" ->
        (temp + 273.15).ToString()
    | _ ->
        raise (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 StringBuilder

Um String objeto é chamado de imutável (somente leitura), pois seu valor não pode ser modificado depois de ser criado. Métodos que parecem modificar um String objeto realmente retornam um novo String objeto que contém a modificação.

Como as cadeias de caracteres são imutáveis, as rotinas de manipulação de cadeia de caracteres que executam adições ou exclusões repetidas ao que parece ser uma única cadeia de caracteres podem exigir uma penalidade significativa de desempenho. Por exemplo, o código a seguir usa um gerador de número aleatório para criar uma cadeia de caracteres com 1000 caracteres no intervalo 0x0001 para 0x052F. Embora o código pareça usar concatenação de cadeia de caracteres para acrescentar um novo caractere à cadeia de caracteres existente chamada str, ele realmente cria um novo String objeto para cada operação de concatenação.

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 += (char)rnd.Next(1, 0x0530);
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}

open System
open System.IO
open System.Text

do
    let rnd = Random()

    let mutable str = String.Empty
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
    for _ = 0 to 1000 do
        str <- str + (rnd.Next(1, 0x0530) |> char |> string)
        if str.Length % 60 = 0 then
            str <- str + Environment.NewLine
    sw.Write str

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 da String classe para operações que fazem várias alterações no valor de uma cadeia de caracteres. Ao contrário das instâncias da classe , StringBuilder os String objetos são mutáveis; quando você concatena, acrescenta ou exclui subcadeias de caracteres de uma cadeia de caracteres, as operações são executadas em uma única cadeia de caracteres. Quando terminar de modificar o valor de um StringBuilder objeto, você poderá chamar seu StringBuilder.ToString método para convertê-lo em uma cadeia de caracteres. O exemplo a seguir substitui o String usado no exemplo anterior para concatenar 1.000 caracteres aleatórios no intervalo para 0x0001 a 0x052F por um StringBuilder objeto .

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((char)rnd.Next(1, 0x0530));
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}

open System
open System.IO
open System.Text

do
    let rnd = Random()
    let sb = StringBuilder()
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)

    for _ = 0 to 1000 do
        sb.Append(rnd.Next(1, 0x0530) |> char) |> ignore
        if sb.Length % 60 = 0 then
            sb.AppendLine() |> ignore
    sw.Write(string sb)

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 à cultura

Os membros da String classe executam operações ordinais ou sensíveis à cultura (linguística) em um String objeto . Uma operação ordinal atua no valor numérico de cada Char objeto. Uma operação sensível à cultura atua no valor do String objeto e leva em conta as regras de maiúsculas e minúsculas específicas da cultura, classificação, formatação e análise. Operações sensíveis à cultura são executadas no contexto de uma cultura declarada explicitamente ou da cultura atual implícita. Os dois tipos de operações podem produzir resultados muito diferentes quando são executados na mesma cadeia de caracteres.

O .NET também dá suporte a operações de cadeia de caracteres linguísticas que não diferenciam cultura usando a cultura invariável (CultureInfo.InvariantCulture), que é vagamente baseada nas configurações de cultura do idioma inglês independente da região. Ao contrário de outras System.Globalization.CultureInfo configurações, as configurações da cultura invariável têm a garantia de permanecer consistentes em um único computador, do sistema ao sistema e entre versões do .NET. A cultura invariável pode ser vista como uma espécie de caixa preta que garante a estabilidade das comparações de cadeia de caracteres e da ordenação em todas as culturas.

Importante

Se o 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. Isso ocorre porque uma comparação sensível à cultura pode produzir resultados diferentes dependendo da cultura em vigor, enquanto uma comparação ordinal depende apenas do valor binário dos caracteres comparados.

Importante

A maioria dos métodos que executam operações de cadeia de caracteres inclui uma sobrecarga que tem um parâmetro do tipo StringComparison, que permite especificar se o método executa uma operação ordinal ou sensível à cultura. Em geral, você deve chamar essa sobrecarga para tornar clara a intenção de sua chamada de método. Para obter melhores práticas e diretrizes para usar operações ordinais e sensíveis à cultura em cadeias de caracteres, consulte Práticas recomendadas para usar cadeias de caracteres.

As operações para uso de maiúsculas e minúsculas, análise e formatação, comparação e classificação e testes de igualdade podem ser ordinais ou sensíveis à cultura. As seções a seguir discutem cada categoria de operação.

Dica

Você sempre deve chamar uma sobrecarga de método que torna clara a intenção de sua chamada de método. Por exemplo, em vez de chamar o Compare(String, String) método para executar uma comparação sensível à cultura de duas cadeias de caracteres usando as convenções da cultura atual, você deve chamar o Compare(String, String, StringComparison) método com um valor de StringComparison.CurrentCulture para o comparisonType argumento . Para obter mais informações, consulte Práticas recomendadas para o uso de cadeias de caracteres.

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 caractere usados em operações de classificação e comparação, nos seguintes links:

• Windows (.NET Framework e .NET Core): classificando tabelas de peso
• Atualização de maio de 2019 do Windows 10 ou posterior (.NET 5+) e Linux e macOS (.NET Core e .NET 5+): Tabela de elementos de ordenação Unicode padrão

Maiúsculas

As 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. Geralmente, uma operação de maiúsculas e minúsculas é executada antes de uma comparação de cadeia de caracteres. Por exemplo, uma cadeia de caracteres pode ser convertida em maiúsculas para que possa ser comparada com outra cadeia de caracteres maiúscula. Você pode converter os caracteres em uma cadeia de caracteres em letras minúsculas chamando o ToLower método ou ToLowerInvariant e pode convertê-los em maiúsculas chamando o ToUpper método ou ToUpperInvariant . Além disso, você pode usar o TextInfo.ToTitleCase método para converter uma cadeia de caracteres em caso de título.

Observação

.NET Core em execução somente em sistemas Linux e macOS: O comportamento de ordenação para as culturas C e Posix sempre diferencia maiúsculas de minúsculas porque essas culturas não usam a ordem de ordenação Unicode esperada. 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.

As operações de maiúsculas e minúsculas podem ser baseadas nas regras da cultura atual, em uma cultura especificada ou na cultura invariável. Como os mapeamentos de caso podem variar dependendo da cultura usada, o resultado das operações de maiúsculas e minúsculas pode variar de acordo com a cultura. As diferenças reais no uso de maiúsculas e minúsculas são de três tipos:

• Diferenças no mapeamento de caso da LETRA MAIÚSCULA LATINA I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) e LATIN SMALL LETTER DOTLESS I (U+0131). Nas culturas tr-TR (Turquia)) e az-Latn-AZ (Azerbaijão, Latino) e nas culturas neutras tr, az e az-Latn, o equivalente minúsculo de LATIN CAPITAL LETTER I é LATIN SMALL LETTER DOTLESS I e o equivalente maiúsculo de LETRA LATINA PEQUENA I é LATIN CAPITAL LETTER I WITH DOT ABOVE. Em todas as outras culturas, incluindo a cultura invariável, LATIN SMALL LETTER I e LATIN CAPITAL LETTER I são equivalentes minúsculos e maiúsculos.

  O exemplo a seguir demonstra como uma comparação de cadeia de caracteres projetada para impedir o acesso ao sistema de arquivos pode falhar se depender de uma comparação de maiúsculas e minúsculas que diferencia a cultura. (As convenções de maiúsculas e minúsculas da cultura invariável deveriam ter sido usadas.)

  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
  

  open System
  open System.Globalization
  open System.Threading
  
  let disallowed = "file"
  
  let isAccessAllowed (resource: string) =
      let cultures = 
          [| CultureInfo.CreateSpecificCulture "en-US"
             CultureInfo.CreateSpecificCulture "tr-TR" |]
      let index = resource.IndexOfAny [| '\\'; '/' |]
      let scheme =
          if index > 0 then
              resource.Substring(0, index - 1)
          else 
              null
  
      // Change the current culture and perform the comparison.
      for culture in cultures do
          Thread.CurrentThread.CurrentCulture <- culture
          printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
          printfn $"{resource}"
          printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
          printfn ""
          
  isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
  // 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 nos mapeamentos de caso entre a cultura invariável e todas as outras culturas. Nesses casos, usar as regras de maiúsculas e minúsculas da cultura invariável para alterar um caractere para maiúsculo ou minúsculo retorna o mesmo caractere. Para todas as outras culturas, ele retorna um caractere diferente. Alguns dos caracteres afetados são listados na tabela a seguir.

  Caractere	Se alterado para	Retornos
  MICRON SIGN (U+00B5)	Maiúsculas	LETRA MAIÚSCULA GREGA MU (U+-39C)
  LETRA MAIÚSCULA LATINA I COM PONTO ACIMA (U+0130)	Minúsculas	LETRA LATINA PEQUENA I (U+0069)
  LETRA MINÚSCULA LATINA DOTLESS I (U+0131)	Maiúsculas	LETRA MAIÚSCULA LATINA I (U+0049)
  LETRA PEQUENA LATINA LONGA S (U+017F)	Maiúsculas	LETRAS MAIÚSCULAS LATINAS (U+0053)
  LETRA MAIÚSCULA LATINA D COM LETRA PEQUENA Z COM CARON (U+01C5)	Minúsculas	LETRA LATINA PEQUENA DZ COM CARON (U+01C6)
  COMBINANDO YPOGEGRAMMENI GREGO (U+0345)	Maiúsculas	LETRA MAIÚSCULA GREGA IOTA (U+0399)

• Diferenças nos mapeamentos de casos de pares de maiúsculas e minúsculas de duas letras no intervalo de caracteres ASCII. Na maioria das culturas, um par de maiúsculas e minúsculas de duas letras é igual ao par maiúsculo ou minúsculo de duas letras equivalente. Isso não é verdadeiro para os seguintes pares de duas letras nas seguintes culturas, pois, em cada caso, eles são comparados a um dígrafo:

  • "lJ" e "nJ" na cultura hr-HR (croata (Croácia)).

  • "cH" nas culturas cs-CZ (República Tcheca)) e sk-SK (Eslovaco (Eslováquia)).

  • "aA" na cultura da-DK (dinamarquesa (Dinamarca)).

  • "cS", "dZ", "dZS", "nY", "sZ", "tY" e "zS" na cultura hu-HU (Hungria)).

  • "cH" e "lL" na cultura es-ES_tradnl (Espanhol (Espanha, Classificação Tradicional)).

  • "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" e "tR" na cultura vi-VN (Vietnamita (Vietnã)).

  No entanto, é incomum encontrar uma situação em que uma comparação sensível à cultura desses pares cria problemas, pois esses pares são incomuns em cadeias de caracteres ou identificadores fixos.

O exemplo a seguir ilustra algumas das diferenças nas regras de maiúsculas e minúsculas entre culturas ao converter cadeias de caracteres em maiúsculas.

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

open System
open System.Globalization
open System.IO

let showHexValue (s: string) =
    let mutable retval = ""
    for ch in s do
        let bytes = BitConverter.GetBytes ch
        retval <- retval + String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0])
    retval

do
    use sw = new StreamWriter(@".\case.txt")
    let words = [| "file"; "sıfır"; "Dženana" |]
    let cultures = 
        [| CultureInfo.InvariantCulture 
           CultureInfo "en-US"
           CultureInfo "tr-TR" |]

    for word in words do
        sw.WriteLine("{0}:", word)
        for culture in cultures do
            let name =
                 if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name
            let upperWord = word.ToUpper culture
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, upperWord, showHexValue upperWord)
        sw.WriteLine()
    sw.Close()

// 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ção

A formatação e a análise são operações inversas. 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. As regras de formatação e análise dependem de convenções culturais. O exemplo a seguir ilustra a ambiguidade que pode surgir ao interpretar uma cadeia de caracteres de data específica da cultura. 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, 1/3/2011 e 03/01/2011 representam 3 de janeiro de 2011 ou 1º de março de 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

open System
open System.Globalization

let date = DateTime(2011, 3, 1)
let cultures = 
      [| CultureInfo.InvariantCulture
         CultureInfo "en-US"
         CultureInfo "fr-FR" |]

for culture in cultures do
    printfn $"""{(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),-12} {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.

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

open System
open System.Globalization

let dateString = "07/10/2011"
let cultures = 
    [| CultureInfo.InvariantCulture
       CultureInfo.CreateSpecificCulture "en-GB"
       CultureInfo.CreateSpecificCulture "en-US" |]
printfn $"""{"Date String",-12} {"Culture",10} {"Month",8} {"Day",8}\n"""
for culture in cultures do
    let date = DateTime.Parse(dateString, culture)
    printfn $"""{dateString,-12} {(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),10} {date.Month,8} {date.Day,8}"""
// 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ção

As convenções para comparar e classificar cadeias de caracteres variam de cultura para cultura. Por exemplo, a ordem de classificação pode ser baseada em fonética ou na representação visual de caracteres. Em idiomas do Leste Asiático, os caracteres são classificados pelo traço e radical dos ideógrafos. A classificação também depende das linguagens de ordem e das culturas usadas para o alfabeto. Por exemplo, o idioma dinamarquês tem um caractere "Æ" que classifica após "Z" no alfabeto. Além disso, as comparações podem diferenciar maiúsculas de minúsculas ou diferenciar maiúsculas de minúsculas, e as regras de maiúsculas e minúsculas podem ser diferentes por cultura. 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 cadeias de caracteres.

As regras de classificação determinam a ordem alfabética dos caracteres Unicode e como duas cadeias de caracteres se comparam entre si. Por exemplo, o String.Compare(String, String, StringComparison) método compara duas cadeias de caracteres com base no StringComparison parâmetro . Se o valor do parâmetro for StringComparison.CurrentCulture, o método executará uma comparação linguística que usa as convenções da cultura atual; se o valor do parâmetro for StringComparison.Ordinal, o método executará uma comparação ordinal. Consequentemente, como mostra o exemplo a seguir, se a cultura atual for inglês americano, a primeira chamada para o String.Compare(String, String, StringComparison) método (usando comparação sensível à cultura) considerará "a" menor que "A", mas a segunda chamada para o mesmo método (usando comparação ordinal) considerará "a" maior que "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

open System
open System.Globalization
open System.Threading

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
printfn $"""{String.Compare("A", "a", StringComparison.CurrentCulture)}"""
printfn $"""{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 dá suporte a regras de classificação de palavra, cadeia de caracteres e ordinal:

• 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. Por exemplo, o hífen (-) pode ter um peso muito pequeno atribuído a ele para que "coop" e "cooperação" apareçam um ao lado do outro em uma lista classificada. 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 .

• Uma classificação de cadeia de caracteres também executa uma comparação sensível à cultura. É semelhante a uma classificação de palavra, exceto que não há casos especiais e todos os símbolos não alfanuméricos vêm antes de todos os caracteres Unicode alfanuméricos. Duas cadeias de caracteres podem ser comparadas usando regras de classificação de cadeia de caracteres chamando as CompareInfo.Compare sobrecargas de método que têm um options parâmetro que é fornecido um valor de 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 cadeia de caracteres.

• Uma classificação ordinal compara as cadeias de caracteres com base no valor numérico de cada objeto Char na cadeia de caracteres. Uma comparação ordinal diferencia automaticamente maiúsculas de minúsculas porque as versões minúsculas e maiúsculas de um caractere têm pontos de código diferentes. No entanto, se case não for importante, você poderá especificar uma comparação ordinal que ignore maiúsculas e minúsculas. Isso é equivalente a converter a cadeia de caracteres em maiúsculas usando a cultura invariável e, em seguida, executar uma comparação ordinal no resultado. Para obter uma lista dos String métodos que comparam duas cadeias de caracteres usando regras de classificação ordinal, consulte a seção Operações de cadeia de caracteres por categoria .

Uma comparação sensível à cultura é qualquer comparação que usa explicita ou implicitamente um CultureInfo objeto , incluindo a cultura invariável especificada pela CultureInfo.InvariantCulture propriedade . A cultura implícita é a cultura atual, que é especificada pelas Thread.CurrentCulture propriedades e CultureInfo.CurrentCulture . Há uma variação considerável na ordem de classificação de caracteres alfabéticos (ou seja, caracteres para os quais a Char.IsLetter propriedade retorna true) entre culturas. 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). Você pode especificar uma comparação sensível à cultura que usa as convenções da cultura atual fornecendo StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCaseou qualquer membro da CompareOptions enumeração diferente CompareOptions.Ordinal de ou CompareOptions.OrdinalIgnoreCase para uma sobrecarga apropriada do Compare método. Uma comparação sensível à cultura geralmente é apropriada para classificação, enquanto uma comparação ordinal não é. 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 é.

O exemplo a seguir ilustra a diferença entre a comparação ordinal e sensível à cultura. 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 que o Compare método é chamado). 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". No entanto, "Æble" não é considerado equivalente a "AEble", portanto, "Æble" também é maior que "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". A comparação ordinal, por outro lado, considera "Apple" menor que "Æble" e "Æble" como maior que "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

open System
open System.Globalization
open System.Threading

let str1 = "Apple"
let str2 = "Æble"
let str3 = "AEble"

// Set the current culture to Danish in Denmark.
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Set the current culture to English in the U.S.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Perform an ordinal comparison.
printfn "Ordinal comparison"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2, StringComparison.Ordinal)}"
printfn $"Comparison of {str2} with {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 classificação ou comparação de cadeia de caracteres apropriado:

• 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. Se a cultura do usuário for alterada, a ordem das cadeias de caracteres classificadas também será alterada adequadamente. Por exemplo, um aplicativo de dicionário de sinônimos sempre deve classificar palavras com base na cultura do usuário.

• Se você quiser que as cadeias de caracteres sejam ordenadas com base nas convenções de uma cultura específica, você deve ordená-las fornecendo um CultureInfo objeto que representa essa cultura para um método de comparação. Por exemplo, em um aplicativo projetado para ensinar aos alunos uma linguagem específica, você deseja que as cadeias de caracteres sejam ordenadas com base nas convenções de uma das culturas que falam esse idioma.

• Se quiser que a ordem das cadeias de caracteres permaneça inalterada entre as culturas, você deverá ordená-las com base nas convenções da cultura invariável ou usar uma comparação ordinal. Por exemplo, você usaria uma classificação ordinal para organizar os nomes de arquivos, processos, mutexes ou pipes nomeados.

• Para uma comparação que envolva 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 .

Observação

As regras de classificação e maiúsculas e minúsculas sensíveis à cultura usadas na comparação de cadeias de caracteres dependem da versão do .NET. No .NET Core, a comparação de cadeias de caracteres depende da versão do Padrão Unicode compatível com o sistema operacional subjacente. No .NET Framework 4.5 e versões posteriores em execução no Windows 8 ou posterior, classificação, uso de maiúsculas e minúsculas, normalização e informações de caractere Unicode estão em conformidade com o padrão Unicode 6.0. Em outros sistemas operacionais Windows, eles estão em conformidade com o padrão Unicode 5.0.

Para obter mais informações sobre regras de classificação de palavra, cadeia de caracteres e ordinal, consulte o System.Globalization.CompareOptions tópico . Para obter recomendações adicionais sobre quando usar cada regra, consulte Práticas recomendadas para usar cadeias de caracteres.

Normalmente, você não chama métodos de comparação de cadeia de caracteres, como Compare diretamente, para determinar a ordem de classificação de cadeias de caracteres. Em vez disso, os métodos de comparação são chamados classificando métodos como Array.Sort ou 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. Observe que cada tipo de classificação produz uma ordenação exclusiva de cadeias de caracteres em sua matriz.

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

open System
open System.Collections.Generic
open System.Globalization

// IComparer<String> implementation to perform string sort using an F# object expression.
let scompare = 
    { new IComparer<String> with
        member _.Compare(x, y) =
            CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort) }

let strings = [| "coop"; "co-op"; "cooperative"; "co\u00ADoperative"; "cœur"; "coeur" |]

// Perform a word sort using the current (en-US) culture.
let current = Array.copy strings
Array.Sort(current, StringComparer.CurrentCulture)

// Perform a word sort using the invariant culture.
let invariant = Array.copy strings
Array.Sort(invariant, StringComparer.InvariantCulture)

// Perform an ordinal sort.
let ordinal = Array.copy strings
Array.Sort(ordinal, StringComparer.Ordinal)

// Perform a string sort using the current culture.
let stringSort = Array.copy strings
Array.Sort(stringSort, scompare)

// Display array values
printfn "%13s %13s %15s %13s %13s\n" "Original" "Word Sort" "Invariant Word" "Ordinal Sort" "String Sort"
for i = 0 to strings.Length - 1 do
    printfn "%13s %13s %15s %13s %13s\n" strings[i] current[i] invariant[i] ordinal[i] stringSort[i]

// 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 cadeias de caracteres culturalmente confidenciais. Cada caractere em uma cadeia de caracteres recebe várias categorias de pesos de classificação, incluindo alfabético, maiúsculas e minúsculas e diacríticos. Uma chave de classificação, representada pela SortKey classe , fornece um repositório desses pesos para uma cadeia de caracteres específica. 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. 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. Para obter mais informações, consulte a classe SortKey.

Se você não especificar uma convenção de comparação de cadeia de caracteres, classifique métodos como Array.Sort(Array) executar uma classificação que diferencia maiúsculas de minúsculas e diferencia maiúsculas de minúsculas em cadeias de caracteres. O exemplo a seguir ilustra como a alteração da cultura atual afeta a ordem das cadeias de caracteres classificadas em uma matriz. Ele cria uma matriz de três cadeias de caracteres. Primeiro, ele define a System.Threading.Thread.CurrentThread.CurrentCulture propriedade como en-US e chama o Array.Sort(Array) método . A ordem de classificação resultante baseia-se em convenções de classificação para a cultura em inglês (Estados Unidos). Em seguida, o exemplo define a System.Threading.Thread.CurrentThread.CurrentCulture propriedade como da-DK e chama o Array.Sort método novamente. Observe como a ordem de classificação resultante difere dos resultados en-US porque usa as convenções de classificação para dinamarquês (Dinamarca).

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

open System
open System.Globalization
open System.Threading

let printIndexAndValues (myArray: string[]) =
    for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
        printfn $"[{i}]: {myArray[i]}" 
    printfn ""

// Create and initialize a new array to store the strings.
let stringArray = [| "Apple"; "Æble"; "Zebra" |]

// Display the values of the array.
printfn "The original string array:"
printIndexAndValues stringArray

// Set the CurrentCulture to "en-US".
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
// Sort the values of the array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"en-US\":"
printIndexAndValues stringArray

// Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
// Sort the values of the Array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"da-DK\":"
printIndexAndValues stringArray
// 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 finalidade principal na comparação de cadeias de caracteres for determinar se elas são iguais, você deve chamar o String.Equals método . Normalmente, você deve usar Equals para executar uma comparação ordinal. O String.Compare método destina-se principalmente a classificar cadeias de caracteres.

Métodos de pesquisa de cadeia de caracteres, como String.StartsWith e String.IndexOf, também podem executar comparações de cadeia de caracteres ordinais ou sensíveis à cultura. O exemplo a seguir ilustra as diferenças entre comparações ordinais e sensíveis à cultura usando o IndexOf método . Uma pesquisa sensível à cultura na qual a cultura atual é inglês (Estados Unidos) considera a subcadeia de caracteres "oe" para corresponder à ligatura "œ". Como um hífen macio (U+00AD) é um caractere de largura zero, a pesquisa trata o hífen macio como equivalente a Empty e encontra uma correspondência no início da cadeia de caracteres. Uma pesquisa ordinal, por outro lado, não encontra uma correspondência em nenhum dos casos.

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

open System

let findInString (s: string) (substring: string) (options: StringComparison) =
    let result = s.IndexOf(substring, options)
    if result <> -1 then
        printfn $"'{substring}' found in {s} at position {result}"
    else
        printfn $"'{substring}' not found in {s}"

// Search for "oe" and "œu" in "œufs" and "oeufs".
let s1 = "œufs"
let s2 = "oeufs"
findInString s1 "oe" StringComparison.CurrentCulture
findInString s1 "oe" StringComparison.Ordinal
findInString s2 "œu" StringComparison.CurrentCulture
findInString s2 "œu" StringComparison.Ordinal
printfn ""

let s3 = "co\u00ADoperative"
findInString s3 "\u00AD" StringComparison.CurrentCulture
findInString s3 "\u00AD" StringComparison.Ordinal

// 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

Pesquisar em cadeias de caracteres

Métodos de pesquisa de cadeia de caracteres, como String.StartsWith e String.IndexOf, também podem executar comparações de cadeia de caracteres ordinal ou sensíveis à cultura para determinar se um caractere ou subcadeia de caracteres é encontrado em uma cadeia de caracteres especificada.

Os métodos de pesquisa na String classe que pesquisam 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. Para executar uma pesquisa sensível à cultura de um caractere, você deve chamar um CompareInfo método como CompareInfo.IndexOf(String, Char) ou 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. Por exemplo, uma pesquisa por um caractere Unicode pré-compilado, como a ligatura "Æ" (U+00C6), pode corresponder a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U+041U+0045), dependendo da cultura. O exemplo a seguir ilustra a diferença entre os String.IndexOf(Char) métodos e CompareInfo.IndexOf(String, Char) ao pesquisar um caractere individual. A ligatura "æ" (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.

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

open System.Globalization

let cultureNames = [| "da-DK"; "en-US" |]
let str = "aerial"
let ch = 'æ'  // U+00E6

printf "Ordinal comparison -- "
printfn $"Position of '{ch}' in {str}: {str.IndexOf ch}"
                  
for cultureName in cultureNames do
    let ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
    printf $"{cultureName} cultural comparison -- "
    printfn $"Position of '{ch}' in {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 StringComparison. A única exceção é Contains, que executa uma pesquisa ordinal.

Testando igualdade

Use o String.Compare método para determinar a relação de duas cadeias de caracteres na ordem de classificação. Normalmente, essa é uma operação sensível à cultura. Por outro lado, chame o String.Equals método para testar a igualdade. 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.

Aviso

É possível testar a igualdade chamando o String.Compare método e determinando se o valor retornado é zero. No entanto, essa prática não é recomendada. Para determinar se duas cadeias de caracteres são iguais, você deve chamar uma das sobrecargas do String.Equals método. A sobrecarga preferencial a ser chamada é o método de instância Equals(String, StringComparison) ou o método estático Equals(String, String, StringComparison) , pois ambos os métodos incluem um System.StringComparison parâmetro que especifica explicitamente o tipo de comparação.

O exemplo a seguir ilustra o perigo de executar uma comparação sensível à cultura quanto à igualdade quando um ordinal deve ser usado. 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://". No entanto, se uma comparação sensível à cultura for realizada usando a cultura turca (Turquia) em uma URL que começa com "file://", a comparação de igualdade falhará, porque o equivalente em maiúsculas turcas do "i" minúsculo é "İ" em vez de "I". Como resultado, o acesso ao sistema de arquivos é inadvertidamente permitido. Por outro lado, se uma comparação ordinal for executada, a comparação de igualdade terá êxito e o acesso ao sistema de arquivos será negado.

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.

open System
open System.Globalization
open System.Threading

let testForEquality (str: string) (cmp: StringComparison) =
    let position = str.IndexOf "://"
    if position < 0 then false
    else
        let substring = str.Substring(0, position)
        substring.Equals("FILE", cmp)

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "tr-TR"

let filePath = "file://c:/notes.txt"

printfn "Culture-sensitive test for equality:"
if not (testForEquality filePath StringComparison.CurrentCultureIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

printfn "\nOrdinal test for equality:"
if not (testForEquality filePath StringComparison.OrdinalIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

// 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ção

Alguns caracteres Unicode têm várias representações. Por exemplo, qualquer um dos seguintes pontos de código pode representar a letra "ắ":

• U+1EAF

• U+0103 U+0301

• U+0061 U+0306 U+0301

Várias representações para um único caractere complicam a pesquisa, a classificação, a correspondência e outras operações de cadeia de caracteres.

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. A normalização pode usar vários algoritmos, chamados formulários de normalização, que seguem regras diferentes. O .NET dá suporte aos formulários de normalização Unicode C, D, KC e KD. Quando as cadeias de caracteres foram normalizadas com o mesmo formulário de normalização, elas podem ser comparadas usando a comparação ordinal.

Uma comparação ordinal é uma comparação binária do valor escalar Unicode de objetos correspondentes Char em cada cadeia de caracteres. A String classe inclui vários métodos que podem executar uma comparação ordinal, incluindo o seguinte:

• Qualquer sobrecarga dos Comparemétodos , Equals, StartsWith, EndsWith, IndexOfe LastIndexOf que incluem um StringComparison parâmetro. O método executará uma comparação ordinal se você fornecer um valor de StringComparison.Ordinal ou OrdinalIgnoreCase para esse parâmetro.

• As sobrecargas do CompareOrdinal método .

• Métodos que usam a comparação ordinal por padrão, como Contains, Replacee Split.

• Métodos que pesquisam um Char valor ou os elementos em uma Char matriz em uma instância de cadeia de caracteres. Esses métodos incluem IndexOf(Char) e Split(Char[]).

Você pode determinar se uma cadeia de caracteres é normalizada para normalização do formulário C chamando o String.IsNormalized() método ou pode chamar o String.IsNormalized(NormalizationForm) método para determinar se uma cadeia de caracteres é normalizada para um formulário de normalização especificado. 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 o String.Normalize(NormalizationForm) método para converter uma cadeia de caracteres em um formulário de normalização especificado. Para obter informações passo a passo sobre como normalizar e comparar cadeias de caracteres, consulte os Normalize() métodos e Normalize(NormalizationForm) .

O exemplo simples a seguir ilustra a normalização da cadeia de caracteres. 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 de caracteres. Em seguida, ele converte cada cadeia de caracteres nos formulários de normalização com suporte e executa novamente uma comparação ordinal de cada cadeia de caracteres em um formulário de normalização especificado. Em cada caso, o segundo teste de igualdade mostra que as cadeias de caracteres são iguais.

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 += $"{(ushort)ch: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

open System
open System.IO
open System.Text

do
    use sw = new StreamWriter(@".\TestNorm1.txt")

    let showBytes (str: string) =
        let mutable result = ""
        for ch in str do
            result <- result + $"{uint16 ch:X4} "
        result.Trim()
    
    let testForEquality (words: string[]) =
        for ctr = 0 to words.Length - 2 do
            for ctr2 = ctr + 1 to words.Length - 1 do
                sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                            words[ctr], showBytes(words[ctr]),
                            words[ctr2], showBytes(words[ctr2]),
                            words[ctr].Equals(words[ctr2], StringComparison.Ordinal))

    let normalizeStrings nf (words: string[]) =
        for i = 0 to words.Length - 1 do
            if not (words[i].IsNormalized nf) then
                words[i] <- words[i].Normalize nf
        words

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

    testForEquality [| s1; s2; s3 |]
    sw.WriteLine()

    // Normalize and compare strings using each normalization form.
    for formName in Enum.GetNames typeof<NormalizationForm> do
        sw.WriteLine("Normalization {0}:\n", formName)
        let nf = Enum.Parse(typeof<NormalizationForm>, formName) :?> NormalizationForm
        let sn = normalizeStrings nf [| s1; s2; s3|]
        testForEquality sn
        sw.WriteLine "\n"

// 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 formulários de normalização e normalização, consulte System.Text.NormalizationForm, bem como Anexo Padrão Unicode nº 15: Formulários de Normalização Unicode e as Perguntas frequentes sobre normalização no site do unicode.org.

Operações da cadeia de caracteres por categoria

A String classe fornece membros para comparar cadeias de caracteres, testar cadeias de caracteres para igualdade, localizar caracteres ou subcadeias de caracteres em uma cadeia de caracteres, modificar uma cadeia de caracteres, extrair subcadeias de caracteres de uma cadeia de caracteres, combinar cadeias de caracteres, formatar valores, copiar uma cadeia de caracteres e normalizar uma cadeia de caracteres.

Comparar cadeias de caracteres

Você pode comparar cadeias de caracteres para determinar sua posição relativa na ordem de classificação usando os seguintes String métodos:

• Compare retorna um inteiro que indica a relação de uma cadeia de caracteres com uma segunda cadeia de caracteres na ordem de classificação.

• CompareOrdinal retorna 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.

• CompareTo retorna 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. O CompareTo(String) método fornece as IComparable implementações e IComparable<T> para a String classe .

Testar a igualdade das cadeias de caracteres

Você chama o Equals método para determinar se duas cadeias de caracteres são iguais. A instância Equals(String, String, StringComparison) e as sobrecargas estáticas Equals(String, StringComparison) permitem que você especifique se a comparação é sensível à cultura ou ordinal e se o caso é considerado ou ignorado. 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.

Localizar caracteres em uma cadeia de caracteres

A String classe inclui dois tipos de métodos de pesquisa:

• Métodos que retornam um Boolean valor para indicar se uma subcadeia de caracteres específica está presente em uma instância de cadeia de caracteres. Eles incluem os Containsmétodos , EndsWithe StartsWith .

• Métodos que indicam a posição inicial de uma subcadeia de caracteres em uma instância de cadeia de caracteres. Eles incluem os IndexOfmétodos , IndexOfAny, LastIndexOfe LastIndexOfAny .

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. Para obter mais informações, consulte Expressões regulares do .NET.

Modificar uma cadeia de caracteres

A String classe inclui os seguintes métodos que parecem modificar o valor de uma cadeia de caracteres:

• Insert insere uma cadeia de caracteres na instância atual String .

• PadLeft insere uma ou mais ocorrências de um caractere especificado no início de uma cadeia de caracteres.

• PadRight insere uma ou mais ocorrências de um caractere especificado no final de uma cadeia de caracteres.

• Remove exclui uma subcadeia de caracteres da instância atual String .

• Replace substitui uma subcadeia de caracteres por outra subcadeia de caracteres na instância atual String .

• ToLower e ToLowerInvariant converte todos os caracteres em uma cadeia de caracteres em minúsculas.

• ToUpper e ToUpperInvariant converte todos os caracteres em uma cadeia de caracteres em maiúsculas.

• Trim remove todas as ocorrências de um caractere do início e do fim de uma cadeia de caracteres.

• TrimEnd remove todas as ocorrências de um caractere do final de uma cadeia de caracteres.

• TrimStart remove todas as ocorrências de um caractere do início de uma cadeia de caracteres.

Importante

Todos os métodos de modificação de cadeia de caracteres retornam um novo String objeto. Eles não modificam o valor da instância atual.

Extrair substrings de uma cadeia de caracteres

O String.Split método separa uma única cadeia de caracteres em várias cadeias de caracteres. As sobrecargas do método permitem que você especifique vários delimitadores, limite o número de subcadeias de caracteres que o método extrai, corte o espaço em branco das subcadeias de caracteres e especifique se cadeias de caracteres vazias (que ocorrem quando delimitadores são adjacentes) estão incluídas entre as cadeias de caracteres retornadas.

Combinar cadeias de caracteres

Os seguintes String métodos podem ser usados para concatenação de cadeia de caracteres:

• Concat combina uma ou mais subcadeias de caracteres em uma única cadeia de caracteres.

• Join concatena uma ou mais subcadeias de caracteres em um único elemento e adiciona um separador entre cada subcadeia de caracteres.

Formatar valores

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. O Format método geralmente é usado para fazer o seguinte:

• Para inserir a representação de cadeia de caracteres de um valor numérico em uma cadeia de caracteres.

• Para inserir a representação de cadeia de caracteres de um valor de data e hora em uma cadeia de caracteres.

• Para inserir a representação de cadeia de caracteres de um valor de enumeração em uma cadeia de caracteres.

• Para inserir a representação de cadeia de caracteres de algum objeto que dá suporte à IFormattable interface em uma cadeia de caracteres.

• Para justificar à direita ou à esquerda, justifique uma subcadeia de caracteres em um campo dentro de uma cadeia de caracteres maior.

Para obter informações detalhadas sobre operações de formatação e exemplos, consulte o resumo da Format sobrecarga.

Copiar uma cadeia de caracteres

Você pode chamar os seguintes String métodos para fazer uma cópia de uma cadeia de caracteres:

• Clone retorna uma referência a um objeto existente String .

• Copy cria uma cópia de uma cadeia de caracteres existente.

• CopyTo copia uma parte de uma cadeia de caracteres para uma matriz de caracteres.

Normalizar uma cadeia de caracteres

Em Unicode, um único caractere pode ter vários pontos de código. A normalização converte esses caracteres equivalentes na mesma representação binária. O String.Normalize método executa a normalização e o String.IsNormalized método determina se uma cadeia de caracteres é normalizada.

Para obter mais informações e um exemplo, consulte a seção Normalização anteriormente neste tópico.

Construtores

String(Char*)	Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de caracteres Unicode.
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.
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.
String(Char[])	Inicializa uma nova instância da classe String para os caracteres Unicode indicados na matriz de caracteres especificada.
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.
String(ReadOnlySpan<Char>)	Inicializa uma nova instância da classe String para os caracteres Unicode indicados no intervalo somente leitura especificado.
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.
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.
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.

Campos

Empty

Representa a cadeia de caracteres vazia. Este campo é somente leitura.

Propriedades

Chars[Int32]	Obtém o objeto Char em uma posição especificada no atual objeto String.
Length	Obtém o número de caracteres no objeto String atual.

Métodos

Clone()	Retorna uma referência a essa instância de String.
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.
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.
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.
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.
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.
Compare(String, String)	Compara dois objetos String especificados e retorna um inteiro que indica sua posição relativa na ordem de classificação.
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.
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.
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.
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.
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.
CompareOrdinal(String, String)	Compara dois objetos String especificados avaliando os valores numéricos dos objetos Char correspondentes em cada cadeia de caracteres.
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.
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.
Concat(IEnumerable<String>)	Concatena os membros de uma coleção de IEnumerable<T> construída do tipo String.
Concat(Object)	Cria a representação de cadeia de caracteres de um objeto especificado.
Concat(Object, Object)	Concatena as representações de cadeia de caracteres de dois objetos especificados.
Concat(Object, Object, Object)	Concatena as representações de cadeia de caracteres de três objetos especificados.
Concat(Object[])	Concatena as representações de cadeia de caracteres dos elementos em uma matriz Object especificada.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena as representações de cadeia de caracteres de dois intervalos de caracteres somente leitura especificados.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena as representações de cadeia de caracteres de três intervalos de caracteres somente leitura especificados.
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.
Concat(String, String)	Concatena duas instâncias especificadas de String.
Concat(String, String, String)	Concatena três instâncias especificadas de String.
Concat(String, String, String, String)	Concatena quatro instâncias especificadas de String.
Concat(String[])	Concatena os elementos de uma matriz String especificada.
Concat<T>(IEnumerable<T>)	Concatena os membros de uma implementação IEnumerable<T>.
Contains(Char)	Retorna um valor que indica se um caractere especificado ocorre nessa cadeia de caracteres.
Contains(Char, StringComparison)	Retorna um valor que indica se um caractere especificado ocorre nessa cadeia de caracteres, usando as regras de comparação especificadas.
Contains(String)	Retorna um valor que indica se uma subcadeia especificada ocorre nesta cadeia de caracteres.
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.
Copy(String)	Obsoleto. Cria uma nova instância de String com o mesmo valor que um String especificado.
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.
CopyTo(Span<Char>)	Copia o conteúdo dessa cadeia de caracteres para o intervalo de destino.
Create(IFormatProvider, DefaultInterpolatedStringHandler)	Cria uma nova cadeia de caracteres usando o provedor especificado para controlar a formatação da cadeia de caracteres interpolada especificada.
Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)	Cria uma nova cadeia de caracteres usando o provedor especificado para controlar a formatação da cadeia de caracteres interpolada especificada.
Create<TState>(Int32, TState, SpanAction<Char,TState>)	Cria uma nova cadeia de caracteres com um comprimento específico e o inicializa após a criação usando o retorno de chamada especificado.
EndsWith(Char)	Determina se o final desta instância de cadeia de caracteres corresponde ao caractere especificado.
EndsWith(String)	Determina se o final desta instância de cadeia de caracteres corresponde à cadeia de caracteres especificada.
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.
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.
EnumerateRunes()	Retorna uma enumeração de Rune dessa cadeia de caracteres.
Equals(Object)	Determina se essa instância e um objeto especificado, que também deve ser um objeto String, têm o mesmo valor.
Equals(String)	Determina se essa instância e outro objeto String especificado têm o mesmo valor.
Equals(String, String)	Determina se dois objetos String especificados têm o mesmo valor.
Equals(String, String, StringComparison)	Determina se dois objetos String especificados têm o mesmo valor. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.
Equals(String, StringComparison)	Determina se essa cadeia de caracteres e um objeto String especificado têm o mesmo valor. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.
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. Um parâmetro fornece informações de formatação específicas da cultura.
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. Um parâmetro fornece informações de formatação específicas da cultura.
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. Um parâmetro fornece informações de formatação específicas da cultura.
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. Um parâmetro fornece informações de formatação específicas da cultura.
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.
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.
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.
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.
GetEnumerator()	Recupera um objeto que pode iterar os caracteres individuais nessa cadeia de caracteres.
GetHashCode()	Retorna o código hash desta cadeia de caracteres.
GetHashCode(ReadOnlySpan<Char>)	Retorna o código hash para o intervalo de caracteres somente leitura fornecido.
GetHashCode(ReadOnlySpan<Char>, StringComparison)	Retorna o código hash para o intervalo de caracteres somente leitura fornecido usando as regras especificadas.
GetHashCode(StringComparison)	Retorna o código hash para essa cadeia de caracteres usando as regras especificadas.
GetPinnableReference()	Retorna uma referência ao elemento da cadeia de caracteres no índice zero. Esse método destina-se a dar suporte a compiladores .NET e não se destina a ser chamado pelo código do usuário.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetTypeCode()	Retorna o TypeCode para a classe String.
IndexOf(Char)	Relata o índice baseado em zero da primeira ocorrência do caractere Unicode especificado na cadeia de caracteres.
IndexOf(Char, Int32)	Relata o índice baseado em zero da primeira ocorrência do caractere Unicode especificado na cadeia de caracteres. A pesquisa é iniciada em uma posição de caractere especificada.
IndexOf(Char, Int32, Int32)	Relata o índice baseado em zero da primeira ocorrência do caractere especificado nessa instância. A pesquisa é iniciada em uma posição de caractere especificada e examina um número especificado de posições de caracteres.
IndexOf(Char, StringComparison)	Relata o índice baseado em zero da primeira ocorrência do caractere Unicode especificado na cadeia de caracteres. Um parâmetro especifica o tipo de pesquisa a ser usado para o caractere especificado.
IndexOf(String)	Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada nessa instância.
IndexOf(String, Int32)	Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada nessa instância. A pesquisa é iniciada em uma posição de caractere especificada.
IndexOf(String, Int32, Int32)	Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada nessa instância. A pesquisa é iniciada em uma posição de caractere especificada e examina um número especificado de posições de caracteres.
IndexOf(String, Int32, Int32, StringComparison)	Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada no objeto String atual. 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.
IndexOf(String, Int32, StringComparison)	Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada no objeto String atual. 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.
IndexOf(String, StringComparison)	Relata o índice baseado em zero da primeira ocorrência da cadeia de caracteres especificada no objeto String atual. Um parâmetro especifica o tipo de pesquisa a ser usado para a cadeia de caracteres especificada.
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.
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. A pesquisa é iniciada em uma posição de caractere especificada.
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. A pesquisa é iniciada em uma posição de caractere especificada e examina um número especificado de posições de caracteres.
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.
Intern(String)	Recupera a referência do sistema para o String especificado.
IsInterned(String)	Recupera uma referência a um String especificado.
IsNormalized()	Indica se essa cadeia de caracteres está no formulário C de normalização Unicode.
IsNormalized(NormalizationForm)	Indica se esta cadeia de caracteres está no formulário de normalização Unicode especificado.
IsNullOrEmpty(String)	Indica se a cadeia de caracteres especificada é null ou uma cadeia de caracteres vazia ("").
IsNullOrWhiteSpace(String)	Indica se uma cadeia de caracteres especificada é null, vazia ou consiste apenas em caracteres de espaço em branco.
Join(Char, Object[])	Concatena as representações de cadeia de caracteres de uma matriz de objetos, usando o separador especificado entre cada membro.
Join(Char, String[])	Concatena as matrizes de cadeias de caracteres, usando o separador especificado entre cada membro.
Join(Char, String[], Int32, Int32)	Concatena uma matriz de cadeias de caracteres, usando o separador especificado entre cada membro, começando com o elemento em value localizado na posição startIndex e concatenando até os elementos count.
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.
Join(String, Object[])	Concatena os elementos de uma matriz de objetos, usando o separador especificado entre cada elemento.
Join(String, String[])	Concatena todos os elementos de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.
Join(String, String[], Int32, Int32)	Concatena os elementos especificados de uma matriz de cadeia de caracteres usando o separador especificado entre cada elemento.
Join<T>(Char, IEnumerable<T>)	Concatena os membros de uma coleção, usando o separador especificado entre cada membro.
Join<T>(String, IEnumerable<T>)	Concatena os membros de uma coleção, usando o separador especificado entre cada membro.
LastIndexOf(Char)	Relata a posição de índice com base em zero da última ocorrência de um caractere Unicode especificado nesta instância.
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. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.
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. 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.
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.
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. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.
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. 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.
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. 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. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres especificada.
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. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres especificada.
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. Um parâmetro especifica o tipo de pesquisa a ser usado para a cadeia de caracteres especificada.
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.
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. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.
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. 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.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Replace(String, String, Boolean, CultureInfo)	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, usando a cultura fornecida e a diferenciação de maiúsculas e minúsculas.
Replace(String, String, StringComparison)	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, usando o tipo de comparação fornecida.
ReplaceLineEndings()	Substitui todas as sequências de nova linha na cadeia de caracteres atual por NewLine.
ReplaceLineEndings(String)	Substitui todas as sequências de nova linha na cadeia de caracteres atual por replacementText.
Split(Char, Int32, StringSplitOptions)	Divide uma cadeia de caracteres em um número máximo de substrings baseadas em um caractere delimitador especificado e, opcionalmente, em opções. Divide uma cadeia de caracteres em um número máximo de substrings baseadas no separador de caracteres fornecido, omitindo opcionalmente substrings vazias do resultado.
Split(Char, StringSplitOptions)	Divide uma cadeia de caracteres em substrings baseadas em um caractere delimitador especificado e, opcionalmente, em opções.
Split(Char[])	Divide uma cadeia de caracteres em substrings baseadas nos caracteres delimitadores especificados.
Split(Char[], Int32)	Divide uma cadeia de caracteres em um número máximo de substrings baseadas nos caracteres delimitadores especificados.
Split(Char[], Int32, StringSplitOptions)	Divide uma cadeia de caracteres em um número máximo de substrings baseadas em caracteres delimitadores especificados e, opcionalmente, em opções.
Split(Char[], StringSplitOptions)	Divide uma cadeia de caracteres em substrings baseadas em caracteres delimitadores e opções.
Split(String, Int32, StringSplitOptions)	Divide uma cadeia de caracteres em um número máximo de substrings baseadas em uma cadeia de caracteres delimitadora especificada e, opcionalmente, em opções.
Split(String, StringSplitOptions)	Divide uma cadeia de caracteres em substrings com base no separador de cadeias de caracteres fornecido.
Split(String[], Int32, StringSplitOptions)	Divide uma cadeia de caracteres em um número máximo de substrings baseadas em cadeias de caracteres delimitadoras especificadas e, opcionalmente, em opções.
Split(String[], StringSplitOptions)	Divide uma cadeia de caracteres em substrings baseadas em uma cadeia de caracteres delimitadora especificada e, opcionalmente, em opções.
StartsWith(Char)	Determina se esta instância de cadeia de caracteres inicia no caractere especificado.
StartsWith(String)	Determina se o começo desta instância de cadeia de caracteres corresponde à cadeia de caracteres especificada.
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.
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.
Substring(Int32)	Recupera uma subcadeia de caracteres desta instância. A subcadeia de caracteres começa em uma posição de caractere especificado e continua até o final da cadeia de caracteres.
Substring(Int32, Int32)	Recupera uma subcadeia de caracteres desta instância. A subcadeia de caracteres começa em uma posição de caractere especificado e tem um comprimento especificado.
ToCharArray()	Copia os caracteres nesta instância para uma matriz de caracteres Unicode.
ToCharArray(Int32, Int32)	Copia os caracteres em uma subcadeia de caracteres especificada nesta instância para uma matriz de caracteres Unicode.
ToLower()	Retorna uma cópia dessa cadeia de caracteres convertida em minúsculas.
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.
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.
ToString()	Retorna esta instância do String; nenhuma conversão em si é executada.
ToString(IFormatProvider)	Retorna esta instância do String; nenhuma conversão em si é executada.
ToUpper()	Retorna uma cópia dessa cadeia de caracteres convertida em maiúsculas.
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.
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.
Trim()	Remove todos os caracteres de espaço em branco à esquerda e à direita da cadeia de caracteres atual.
Trim(Char)	Remove todas as instâncias à esquerda e à direita da cadeia de caracteres atual.
Trim(Char[])	Remove todas as ocorrências à esquerda e à direita de um conjunto de caracteres especificados em uma matriz da cadeia de caracteres atual.
TrimEnd()	Remove todos os caracteres de espaço em branco da cadeia de caracteres atual.
TrimEnd(Char)	Remove todas as ocorrências à direita da cadeia de caracteres atual.
TrimEnd(Char[])	Remove todas as ocorrências à direita de um conjunto de caracteres especificados em uma matriz da cadeia de caracteres atual.
TrimStart()	Remove todos os caracteres de espaço em branco à esquerda da cadeia de caracteres atual.
TrimStart(Char)	Remove todas as ocorrências à esquerda de um caractere especificado da cadeia de caracteres atual.
TrimStart(Char[])	Remove todas as ocorrências à esquerda de um conjunto de caracteres especificados em uma matriz da cadeia de caracteres atual.
TryCopyTo(Span<Char>)	Copia o conteúdo dessa cadeia de caracteres no intervalo de destino.

Operadores

Equality(String, String)	Determina se duas cadeias de caracteres especificadas têm o mesmo valor.
Implicit(String to ReadOnlySpan<Char>)	Define uma conversão implícita de uma determinada cadeia de caracteres em um intervalo somente leitura de caracteres.
Inequality(String, String)	Determina se duas cadeias de caracteres especificadas têm valores diferentes.

Implantações explícitas de interface

IConvertible.ToBoolean(IFormatProvider)	Para obter uma descrição desse membro, confira ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Para obter uma descrição desse membro, confira ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Para obter uma descrição desse membro, confira ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Para obter uma descrição desse membro, confira ToDateTime(IFormatProvider).
IConvertible.ToDecimal(IFormatProvider)	Para obter uma descrição desse membro, confira ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Para obter uma descrição desse membro, confira ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Para obter uma descrição desse membro, confira ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Para obter uma descrição desse membro, confira ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Para obter uma descrição desse membro, confira ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Para obter uma descrição desse membro, confira ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Para obter uma descrição desse membro, confira ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Para obter uma descrição desse membro, confira ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Para obter uma descrição desse membro, confira ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Para obter uma descrição desse membro, confira ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Para obter uma descrição desse membro, confira ToUInt64(IFormatProvider).
IEnumerable.GetEnumerator()	Retorna um enumerador que itera pelo objeto String atual.

Métodos de Extensão

ToImmutableArray<TSource>(IEnumerable<TSource>)	Cria uma matriz imutável com base na coleção especificada.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Constrói um dicionário imutável de uma coleção existente de elementos, aplicando uma função de transformação nas chaves de origem.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Constrói um dicionário imutável com base em alguma transformação de uma sequência.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Enumera e transforma uma sequência e produz um dicionário imutável com base em seu conteúdo.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Enumera e transforma uma sequência e produz um dicionário imutável com base em seu conteúdo usando o comparador de chave especificado.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Enumera e transforma uma sequência e produz um dicionário imutável com base em seu conteúdo usando os comparadores de chave e valor especificados.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Enumera uma sequência e produz um conjunto de hash imutável de seu conteúdo.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Enumera uma sequência, produz um conjunto de hash imutável de seu conteúdo e usa o comparador de igualdade especificado para o tipo de conjunto.
ToImmutableList<TSource>(IEnumerable<TSource>)	Enumera uma sequência e produz uma lista imutável de seu conteúdo.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Enumera e transforma uma sequência e produz um dicionário classificado imutável com base em seu conteúdo.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Enumera e transforma uma sequência e produz um dicionário classificado imutável com base em seu conteúdo usando o comparador de chave especificado.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Enumera e transforma uma sequência e produz um dicionário classificado imutável com base em seu conteúdo usando os comparadores de chave e valor especificados.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Enumera uma sequência e produz um conjunto classificado imutável de seu conteúdo.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Enumera uma sequência, produz um conjunto classificado imutável de seu conteúdo e usa o comparador especificado.
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.
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.
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.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Aplica uma função de acumulador a uma sequência.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Aplica uma função de acumulador a uma sequência. O valor de semente especificado é usado como o valor inicial do acumulador.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Aplica uma função de acumulador a uma sequência. O valor de semente especificado é usado como o valor inicial do acumulador e a função especificada é usada para selecionar o valor do resultado.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Determina se todos os elementos de uma sequência atendem a uma condição.
Any<TSource>(IEnumerable<TSource>)	Determina se uma sequência contém elementos.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Determina se algum elemento de uma sequência atende a uma condição.
Append<TSource>(IEnumerable<TSource>, TSource)	Acrescenta um valor ao final da sequência.
AsEnumerable<TSource>(IEnumerable<TSource>)	Retorna a entrada digitada como IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Calcula a média de uma sequência de valores Decimal obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Calcula a média de uma sequência de valores Double obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Calcula a média de uma sequência de valores Int32 obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Calcula a média de uma sequência de valores Int64 obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Calcula a média de uma sequência de valores Decimal que permitem valor nulo obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Calcula a média de uma sequência de valores Double que permitem valor nulo obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Calcula a média de uma sequência de valores Int32 que permitem valor nulo obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Calcula a média de uma sequência de valores Int64 que permitem valor nulo obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Calcula a média de uma sequência de valores Single que permitem valor nulo obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Calcula a média de uma sequência de valores Single obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Cast<TResult>(IEnumerable)	Converte os elementos de um IEnumerable para o tipo especificado.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Divide os elementos de uma sequência em partes de tamanho no máximo size.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Concatena duas sequências.
Contains<TSource>(IEnumerable<TSource>, TSource)	Determina se uma sequência contém um elemento especificado usando o comparador de igualdade padrão.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Determina se uma sequência contém um elemento especificado usando um IEqualityComparer<T> especificado.
Count<TSource>(IEnumerable<TSource>)	Retorna o número de elementos em uma sequência.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna um número que representa quantos elementos na sequência especificada atendem a uma condição.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Retornará os elementos da sequência especificada ou o valor padrão do parâmetro de tipo em uma coleção de singletons se a sequência estiver vazia.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Retorna os elementos da sequência especificada ou o valor especificado em uma coleção de singletons se a sequência está vazia.
Distinct<TSource>(IEnumerable<TSource>)	Retorna os elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar valores.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Retorna os elementos distintos de uma sequência usando um IEqualityComparer<T> especificado para comparar valores.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Retorna elementos distintos de uma sequência de acordo com uma função de seletor de chave especificada.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Retorna elementos distintos de uma sequência de acordo com uma função de seletor de chave especificada e usando um comparador especificado para comparar chaves.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Retorna o elemento de um índice especificado em uma sequência.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Retorna o elemento de um índice especificado em uma sequência.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do intervalo.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do intervalo.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produz a diferença de conjunto de duas sequências usando o comparador de igualdade padrão para comparar os valores.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produz a diferença de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar os valores.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Produz a diferença de conjunto de duas sequências de acordo com uma função de seletor de chave especificada.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Produz a diferença de conjunto de duas sequências de acordo com uma função de seletor de chave especificada.
First<TSource>(IEnumerable<TSource>)	Retorna o primeiro elemento de uma sequência.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna o primeiro elemento em uma sequência que satisfaz uma condição especificada.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Retorna o primeiro elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Retorna o primeiro elemento de uma sequência ou um valor padrão especificado se a sequência não contiver elementos.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão, caso esse elemento não seja encontrado.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retorna o primeiro elemento da sequência que atende a uma condição ou um valor padrão especificado se nenhum elemento desse tipo for encontrado.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave especificada.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e compara as chaves usando um comparador especificado.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Agrupa os elementos de uma sequência de acordo com a função de seletor de chave especificada e projeta os elementos de cada grupo usando uma função especificada.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Agrupa os elementos de uma sequência de acordo com uma função de seletor de chave. As chaves são comparadas usando um comparador e os elementos de cada grupo são projetados usando uma função especificada.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e cria um valor de resultado de cada grupo e sua chave.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e cria um valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e cria um valor de resultado de cada grupo e sua chave. Os elementos de cada grupo são projetados usando uma função especificada.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Agrupa os elementos de uma sequência de acordo com uma função do seletor de chave especificada e cria um valor de resultado de cada grupo e sua chave. Os valores da chave são comparados usando um comparador especificado e os elementos de cada grupo são projetados usando uma função especificada.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Correlaciona os elementos de duas sequências com base na igualdade de chaves e agrupa os resultados. O comparador de igualdade padrão é usado para comparar chaves.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Correlaciona os elementos de duas sequências com base na igualdade de chaves e agrupa os resultados. Um IEqualityComparer<T> especificado é usado para comparar chaves.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produz a interseção de conjunto de duas sequências usando o comparador de igualdade padrão para comparar os valores.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produz a interseção de conjunto de duas sequências usando o IEqualityComparer<T> especificado para comparar os valores.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Produz a interseção definida de duas sequências de acordo com uma função de seletor de chave especificada.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Produz a interseção definida de duas sequências de acordo com uma função de seletor de chave especificada.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Correlaciona os elementos de duas sequências com base em chaves de correspondência. O comparador de igualdade padrão é usado para comparar chaves.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Correlaciona os elementos de duas sequências com base em chaves de correspondência. Um IEqualityComparer<T> especificado é usado para comparar chaves.
Last<TSource>(IEnumerable<TSource>)	Retorna o último elemento de uma sequência.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna o último elemento de uma sequência que satisfaz uma condição especificada.
LastOrDefault<TSource>(IEnumerable<TSource>)	Retorna o último elemento de uma sequência ou um valor padrão se a sequência não contém elementos.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Retorna o último elemento de uma sequência ou um valor padrão especificado se a sequência não contiver elementos.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna o último elemento de uma sequência que satisfaz uma condição ou um valor padrão, caso esse elemento não seja encontrado.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retorna o último elemento de uma sequência que atende a uma condição ou um valor padrão especificado se nenhum elemento desse tipo for encontrado.
LongCount<TSource>(IEnumerable<TSource>)	Retorna um Int64 que representa o número total de elementos em uma sequência.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna um Int64 que representa quantos elementos na sequência atendem a uma condição.
Max<TSource>(IEnumerable<TSource>)	Retorna o valor máximo em uma sequência genérica.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Retorna o valor máximo em uma sequência genérica.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal máximo que permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double máximo que permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 máximo que permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 máximo que permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single máximo que permite valor nulo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single máximo.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Invoca uma função de transformação em cada elemento de uma sequência genérica e retorna o maior valor resultante.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Retorna o valor máximo em uma sequência genérica de acordo com uma função de seletor de chave especificada.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Retorna o valor máximo em uma sequência genérica de acordo com uma função de seletor de chave e um comparador de chave especificados.
Min<TSource>(IEnumerable<TSource>)	Retorna o valor mínimo em uma sequência genérica.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Retorna o valor mínimo em uma sequência genérica.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Decimal mínimo que permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Double mínimo que permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int32 mínimo que permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Int64 mínimo que permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single mínimo que permite valor nulo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Invoca uma função de transformação em cada elemento de uma sequência e retorna o valor Single mínimo.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Invoca uma função de transformação em cada elemento de uma sequência genérica e retorna o menor valor resultante.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Retorna o valor mínimo em uma sequência genérica de acordo com uma função de seletor de chave especificada.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Retorna o valor mínimo em uma sequência genérica de acordo com uma função de seletor de chave especificada e um comparador de chave.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base em um tipo especificado.
Order<T>(IEnumerable<T>)	Classifica os elementos de uma sequência em ordem crescente.
Order<T>(IEnumerable<T>, IComparer<T>)	Classifica os elementos de uma sequência em ordem crescente.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Classifica os elementos de uma sequência em ordem crescente de acordo com uma chave.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Classifica os elementos de uma sequência em ordem crescente usando um comparador especificado.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Classifica os elementos de uma sequência em ordem decrescente de acordo com uma chave.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Classifica os elementos de uma sequência em ordem decrescente usando um comparador especificado.
OrderDescending<T>(IEnumerable<T>)	Classifica os elementos de uma sequência em ordem decrescente.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Classifica os elementos de uma sequência em ordem decrescente.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Adiciona um valor ao início da sequência.
Reverse<TSource>(IEnumerable<TSource>)	Inverte a ordem dos elementos em uma sequência.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projeta cada elemento de uma sequência em um novo formulário.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projeta cada elemento de uma sequência em um novo formulário, incorporando o índice do elemento.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma sequência.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma sequência. O índice de cada elemento de origem é usado no formulário projetado desse elemento.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projeta cada elemento de uma sequência em um IEnumerable<T>, mescla as sequências resultantes em uma sequência e chama uma função de seletor de resultado em cada elemento contido nele.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projeta cada elemento de uma sequência em um IEnumerable<T>, mescla as sequências resultantes em uma sequência e chama uma função de seletor de resultado em cada elemento contido nele. O índice de cada elemento de origem é usado no formulário projetado intermediário do elemento.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Determina se duas sequências são iguais comparando os elementos usando o comparador de igualdade padrão para o tipo.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Determina se duas sequências são iguais, comparando seus elementos usando um IEqualityComparer<T> especificado.
Single<TSource>(IEnumerable<TSource>)	Retornará o único elemento de uma sequência e lançará uma exceção se não houver exatamente um elemento na sequência.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna o único elemento de uma sequência que satisfaz uma condição especificada e gera uma exceção se houver mais de um tal elemento.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Retorna o único elemento de uma sequência ou um valor padrão se a sequência é vazia; esse método gera uma exceção se há mais de um elemento na sequência.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Retorna o único elemento de uma sequência ou um valor padrão especificado se a sequência estiver vazia; esse método gerará uma exceção se houver mais de um elemento na sequência.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna o único elemento de uma sequência que satisfaz uma condição especificada ou um valor padrão se esse elemento não existir. Esse método lança uma exceção se mais de um elemento satisfizer a condição.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retorna o único elemento de uma sequência que atende a uma condição especificada ou um valor padrão especificado se esse elemento não existir; esse método gerará uma exceção se mais de um elemento atender à condição.
Skip<TSource>(IEnumerable<TSource>, Int32)	Ignora um número especificado de elementos em uma sequência e retorna os elementos restantes.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Retorna uma nova coleção enumerável que contém os elementos de source com os últimos elementos de count da coleção de origem omitidos.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Ignora elementos em uma sequência, contanto que uma condição especificada seja verdadeira e retorne os elementos restantes.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Ignora elementos em uma sequência, contanto que uma condição especificada seja verdadeira e retorne os elementos restantes. O índice do elemento é usado na lógica da função de predicado.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Calcula a soma da sequência de valores Decimal obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Calcula a soma da sequência de valores Double obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Calcula a soma da sequência de valores Int32 obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Calcula a soma da sequência de valores Int64 obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Calcula a soma da sequência de valores Decimal anuláveis obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Calcula a soma da sequência de valores Double anuláveis obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Calcula a soma da sequência de valores Int32 anuláveis obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Calcula a soma da sequência de valores Int64 anuláveis obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Calcula a soma da sequência de valores Single anuláveis obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Calcula a soma da sequência de valores Single obtidos pela invocação de uma função de transformação em cada elemento da sequência de entrada.
Take<TSource>(IEnumerable<TSource>, Int32)	Retorna um número especificado de elementos contíguos do início de uma sequência.
Take<TSource>(IEnumerable<TSource>, Range)	Retorna um intervalo especificado de elementos contíguos de uma sequência.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Retorna uma nova coleção enumerável que contém os últimos elementos de count de source.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retorna os elementos de uma sequência contanto que uma condição especificada seja verdadeira.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Retorna os elementos de uma sequência contanto que uma condição especificada seja verdadeira. O índice do elemento é usado na lógica da função de predicado.
ToArray<TSource>(IEnumerable<TSource>)	Cria uma matriz de um IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de acordo com uma função de seletor de chave especificada.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de acordo com uma função de seletor de chave especificada e um comparador de chaves.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Cria um Dictionary<TKey,TValue> de um IEnumerable<T>, de acordo com as funções especificadas de seletor de chave e seletor de elemento.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Cria um Dictionary<TKey,TValue> de um IEnumerable<T> de acordo com uma função de seletor de chave, um comparador e uma função de seletor de elemento especificados.
ToHashSet<TSource>(IEnumerable<TSource>)	Cria um HashSet<T> de um IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Cria um HashSet<T> de um IEnumerable<T> usando o comparer para comparar chaves.
ToList<TSource>(IEnumerable<TSource>)	Cria um List<T> de um IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de acordo com uma função de seletor de chave especificada.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de acordo com uma função de seletor de chave especificada e um comparador de chaves.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Cria um Lookup<TKey,TElement> de um IEnumerable<T>, de acordo com as funções especificadas de seletor de chave e seletor de elemento.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Cria um Lookup<TKey,TElement> de um IEnumerable<T> de acordo com uma função de seletor de chave, um comparador e uma função de seletor de elemento especificados.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Tenta determinar o número de elementos em uma sequência sem forçar uma enumeração.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produz a união de conjunto de duas sequências usando o comparador de igualdade padrão.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produz a união de conjunto de duas sequências usando o IEqualityComparer<T> especificado.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Produz a união definida de duas sequências de acordo com uma função de seletor de chave especificada.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Produz a união definida de duas sequências de acordo com uma função de seletor de chave especificada.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtra uma sequência de valores com base em um predicado.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtra uma sequência de valores com base em um predicado. O índice de cada elemento é usado na lógica da função de predicado.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Produz uma sequência de tuplas com elementos das duas sequências especificadas.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Produz uma sequência de tuplas com elementos das três sequências especificadas.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Aplica uma função especificada para os elementos correspondentes de duas sequências, produzindo uma sequência dos resultados.
AsParallel(IEnumerable)	Habilita a paralelização de uma consulta.
AsParallel<TSource>(IEnumerable<TSource>)	Habilita a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable em um IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Converte um IEnumerable<T> genérico em um IQueryable<T> genérico.
AsMemory(String)	Cria um ReadOnlyMemory<Char> na parte da cadeia de caracteres de destino.
AsMemory(String, Index)	Cria um ReadOnlyMemory<Char> em uma parte da cadeia de caracteres de destino começando em um índice especificado.
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.
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.
AsMemory(String, Range)	Cria um ReadOnlyMemory<Char> em um intervalo especificado da cadeia de caracteres de destino.
AsSpan(String)	Cria um intervalo somente leitura em uma cadeia de caracteres.
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.
AsSpan(String, Int32, Int32)	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.
IsNormalized(String)	Indica se a cadeia de caracteres especificada está no formato de normalização Unicode C.
IsNormalized(String, NormalizationForm)	Indica se uma cadeia de caracteres está em um formato de normalização Unicode especificado.
Normalize(String)	Normaliza uma cadeia de caracteres com relação a um formato de normalização Unicode C.
Normalize(String, NormalizationForm)	Normaliza uma cadeia de caracteres com relação ao formato de normalização Unicode.
Ancestors<T>(IEnumerable<T>)	Retorna uma coleção de elementos que contém os ancestrais de cada nó na coleção de origem.
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. Somente os elementos que têm um XName correspondente são incluídos na coleção.
DescendantNodes<T>(IEnumerable<T>)	Retorna uma coleção dos nós descendentes de todos os documentos e elementos na coleção de origem.
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.
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. Somente os elementos que têm um XName correspondente são incluídos na coleção.
Elements<T>(IEnumerable<T>)	Retorna uma coleção dos filhos elementos de cada elemento e o documento na coleção de origem.
Elements<T>(IEnumerable<T>, XName)	Retorna uma coleção filtrada dos elementos filho de cada elemento e documento na coleção de origem. Somente os elementos que têm um XName correspondente são incluídos na coleção.
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.
Nodes<T>(IEnumerable<T>)	Retorna uma coleção dos nós filhos de todos os documentos e elementos na coleção de origem.
Remove<T>(IEnumerable<T>)	Remove todos os nós na coleção de origem do respectivo nó pai.

Acesso thread-safe

Este tipo é thread-safe.

Confira também

• IComparable
• ICloneable
• IConvertible
• IEnumerable
• StringBuilder
• CultureInfo
• Classificando tabelas de peso para Windows (somente .NET Framework e .NET Core)
• Tabelas de elementos de ordenação Unicode padrão
• Tipos de formatação no .NET
• Práticas recomendadas para o uso de cadeias de caracteres no .NET