Classe String

Você pode criar uma instância de um objeto de String das seguintes maneiras:

• Atribuindo uma cadeia de caracteres literal a uma variável de String . Este é o método mais comumente usado para criar uma cadeia de caracteres. O exemplo a seguir usa a declaração para criar várias cadeias de caracteres. Observe que em C#, porque a barra invertida (\) é um caractere de escape, barras invertidas literal em uma cadeia de caracteres deve ser escapado ou cadeia de caracteres inteira deve ser @-quoted.

  C#

  VB

  Copiar

  
  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      
  
  
  

• Chamando um construtor de classe de String . O exemplo a seguir cria uma instância cadeias de caracteres chamando vários construtores de classe. Observe que alguns dos construtores incluem ponteiros para matrizes de caracteres ou assinados a matrizes de bytes como parâmetros. Visual Basic não faz chamadas de suporte para esses construtores.

  C#

  VB

  Copiar

  
  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  
  
  
  

• Usando o operador de concatenação de cadeia de caracteres + (em C# e & ou + no Visual Basic) para criar uma única cadeia de caracteres de qualquer combinação de instâncias de String e de literais de cadeia de caracteres. O exemplo a seguir ilustra o uso do operador de concatenação de cadeia de caracteres.

  C#

  VB

  Copiar

  
  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.
  
  
  

• Recuperando uma propriedade ou chamar um método que retorna uma cadeia de caracteres. O seguinte exemplo usa os métodos da classe de String para extrair uma subcadeia de caracteres de uma cadeia de caracteres maior.

  C#

  VB

  Copiar

  
  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
  
  
  

• Chamando um método de formatação para converter um valor um objeto para sua representação de cadeia de caracteres. O exemplo a seguir usa o recurso de formatação composta para incorporar a representação de cadeia de caracteres de dois objetos em uma cadeia de caracteres.

  C#

  VB

  Copiar

  
  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.      
  
  
  

Cada caractere em uma cadeia de caracteres é definido por um valor escalar Unicode, também chamado um ponto de código Unicode ou valor numérico () ordinal de caracteres Unicode. Cada ponto de código é codificada usando a codificação UTF-16, e o valor numérico de cada elemento de codificação é representado por um objeto de Char .

Um único objeto de Char geralmente representa um único ponto de código; isto é, o valor numérico de Char é igual ao ponto de código. por exemplo, o ponto de código para o caractere “a” é U+0061. Em o entanto, um ponto de código pode exigir mais de um elemento (codificado mais de um objeto de Char ). O padrão Unicode define três tipos de caracteres que correspondem a vários objetos de Char : grafemas, suplementares pontos de código Unicode, e caracteres nos planos suplementares.

• Um grafema é representado por um caractere de base seguido por um ou mais caracteres de combinação. Por exemplo, o ä de caracteres é representado por um objeto de Char cujo ponto de código é U+0061 seguido por um objeto de Char cujo ponto de código é U+0308. Esse caractere também pode ser definido por um único objeto de Char que tem um ponto de código de U+00E4. Como mostra o exemplo a seguir, uma comparação culture-sensitive para igualdade indica que essas duas representações são iguais, embora uma comparação ordinal comum não. Em o entanto, se as duas cadeias de caracteres são normalizadas, uma comparação ordinal também indica que são iguais. (Para obter mais informações sobre normalizar cadeias de caracteres, consulte a seção de normalização .)

  C#

  VB

  Copiar

  
  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
  
  
  

• Um ponto de código Unicode (suplementar um par substituto) é representado por um objeto de Char cujo ponto de código é uma alternativa alto seguido por um objeto de Char cujo ponto de código é um baixo alternativo. Os pontos de código unicode surrogates de alto de U+D800 a U+DBFF. Os pontos de código unicode surrogates de baixo de U+DC00 a U+DFFF. Pares substitutos são usados para representar 16 caracteres nos planos suplementares Unicode. O exemplo a seguir cria um caractere substituto e passá-lo para o método de Char.IsSurrogatePair(Char, Char) para determinar se ele é um par substituto.

  C#

  VB

  Copiar

  
  using System;
  
  public class Example
  {
     public static void Main()
     {
        string surrogate = "\uD800\uDC03";
        for (int ctr = 0; ctr < surrogate.Length; ctr++) 
           Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
  
        Console.WriteLine();
        Console.WriteLine("   Is Surrogate Pair: {0}", 
                          Char.IsSurrogatePair(surrogate[0], surrogate[1]));
     }
  }
  // The example displays the following output:
  //       U+D800 U+DC03
  //          Is Surrogate Pair: True
  
  
  

Em o .NET Framework, um objeto de String pode incluir caracteres nulos inseridos, que contam como parte do comprimento da cadeia de caracteres. Em o entanto, em alguns idiomas como C e C++, um caractere nulo indica o fim de uma cadeia de caracteres; não é considerado parte da cadeia de caracteres e não é a contagem como parte do comprimento da cadeia de caracteres. Isso significa que as seguintes suposições comuns que C e programadores ou bibliotecas escritos em C ou C++ C++ podem fazer sobre cadeias de caracteres não são necessariamente válidos quando aplicado a String objetos:

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

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

Você deve garantir que o nativo C e C++ código que cria uma instância de String objetos, e o código que é passado String objetos com invocação de plataforma, não assume que um caractere nulo inserido marca ao final da cadeia de caracteres.

Caracteres nulos inseridos em uma cadeia de caracteres também são tratados de maneira diferente quando uma cadeia de caracteres é ordenada (ou) quando comparado e uma cadeia de caracteres é pesquisada. Caracteres nulos são ignorados quando executar comparações que levam entre duas cadeias de caracteres, incluindo comparações usando a cultura invariável. São considerados somente para comparações ordinais ordinais ou não diferencia maiúsculas de minúsculas. Por outro lado, caracteres nulos sempre inseridos são considerados ao procurar uma cadeia de caracteres com métodos como Contains, StartsWith, e IndexOf.

Um índice é a posição de um objeto de Char (não um caractere Unicode) em String. Um é um número índice com base zero, não-negativos parta que a primeira posição na cadeia de caracteres, que é a posição de índice zero. Um número de métodos de pesquisa, como IndexOf e LastIndexOf, retorna o índice de um caractere ou uma subcadeia de caracteres na instância de cadeia de caracteres.

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

using System;

public class Example
{
   public static 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.

Porque a classe de String implementa a interface de IEnumerable , você também pode percorrer os objetos de Char em uma cadeia de caracteres usando uma compilação de foreach , como mostra o exemplo a seguir.

using System;

public class Example
{
   public static void Main()
   {
      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.

Os valores de índice consecutivos podem não corresponder a consecutivos caracteres Unicode, como um caractere Unicode pode ser codificado como mais de um objeto de Char . Para trabalhar com caracteres Unicode em vez de objetos de Char , use as classes de System.Globalization.StringInfo e de TextElementEnumerator . O exemplo a seguir ilustra a diferença entre o código que funciona com objetos e código de Char que funciona com caracteres Unicode. Compara o número de caracteres ou de elementos de texto em cada palavra de uma sentença. A cadeia de caracteres inclui duas seqüências de um caractere base seguido por um caractere de combinação.

using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // 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++;
         }
      }

      TextElementEnumerator te = 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

Uma cadeia de caracteres que é declarada mas não receber um valor é null. Tentar chamar métodos em essa cadeia de caracteres gera NullReferenceException. Uma cadeia de caracteres nula é diferente de uma cadeia de caracteres vazia, uma cadeia de caracteres cujo valor é "" ou String.Empty. Em alguns casos, passe uma cadeia de caracteres nula ou uma cadeia de caracteres vazia como um argumento para um chamada de método gera uma exceção. Por exemplo, passe uma cadeia de caracteres nula para o método de Int32.Parse gera ArgumentNullException, e passar gera de uma cadeia de caracteres vazia FormatException. Em outros casos, um argumento do método pode ser uma cadeia de caracteres nula ou uma cadeia de caracteres vazia. Por exemplo, se você está fornecendo uma implementação de IFormattable para uma classe, você deseja igualar uma cadeia de caracteres nula e uma cadeia de caracteres vazia (com “G”) o especificador de formato geral.

A classe de String inclui os seguintes dois métodos de conveniência que permitem que você testar se uma cadeia de caracteres é null ou o vazias:

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

  C#

  VB

  Copiar

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

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

  C#

  VB

  Copiar

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

O exemplo a seguir usa o método de IsNullOrEmpty na implementação de IFormattable.ToString de uma classe personalizada de Temperature . O método suporta “G”, “C”, “F”, e de formato “K” cadeias de caracteres. Se uma cadeia de caracteres vazia de formato ou uma cadeia de caracteres de formato cujo valor é null são passadas para o método, seu valor é alterado para a cadeia de caracteres de formato “G”.

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

Um objeto de String é chamado imutável (somente leitura), porque o valor não pode ser modificado após ele ter sido criado. Métodos que aparecem para alterar realmente um retorno do objeto de String um novo objeto de String que contém a alteração.

Como cadeias de caracteres são imutáveis, rotinas de manipulação de cadeia de caracteres que executam adições ou exclusões repetidas para o que parece ser uma única cadeia de caracteres podem exigir uma significativa penalidade 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 a 0x052F. Embora o código pareça usar a concatenação de cadeia de caracteres para anexar um novo caractere para a cadeia de caracteres denominada strexistente, realmente criar um novo objeto de String para cada operação de concatenação.

using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();

      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

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

Você pode usar a classe de StringBuilder em vez da classe de String para as operações que tornam mais alterações para o valor de uma cadeia de caracteres. A o contrário das instâncias da classe de String , os objetos de StringBuilder são mutáveis; quando você concatena, acrescenta, ou excluir subcadeias de caracteres de uma cadeia de caracteres, operações são executadas em uma única cadeia de caracteres. Quando você tiver terminado alterar o valor de um objeto de StringBuilder , você pode chamar o método de StringBuilder.ToString para convertê-la em uma cadeia de caracteres. O exemplo a seguir substitui String usado no exemplo anterior para concatenar 1000 caracteres aleatórias no intervalo 0x0001 à 0x052F com um objeto de StringBuilder .

using System;
using System.IO;
using System.Text;

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

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

Os membros da classe de String executam ou ordinal ou operações linguísticas () que levam em String objeto. O atua ordinais de uma operação no valor numérico de cada Char objeto. O atua culture-sensitive de uma operação no valor do objeto de String , e levam em conta a cultura específica capitalização, ordenação, formatação, e regras de análise. operações sensíveis executam no contexto de uma cultura explicitamente declarada ou da cultura atual implícita. Os dois tipos das operações podem produzir resultados muito diferentes quando são executados na mesma cadeia de caracteres.

Observação de segurança

Se seu aplicativo faz uma decisão de segurança sobre o identificador simbólico como um nome de arquivo ou um pipe nomeado, ou sobre dados persistentes como os dados com base em texto em um arquivo XML, a operação deve usar uma comparação ordinal em vez de uma comparação culture-sensitive. Isso ocorre porque uma comparação culture-sensitive pode produzir resultados diferentes dependendo da cultura aplicado, enquanto uma comparação ordinal exclusivamente depende do valor binário de caracteres comparados.

Importante

A maioria dos métodos que executam operações de cadeia de caracteres incluem uma sobrecarga que tem um parâmetro do tipo StringComparison, que permite que você especifique se o método executa uma operação ordinal ou culture-sensitive. Em geral, você deve chamar essa sobrecarga para fazer a intenção de seu espaço livre da chamada de método. Para práticas recomendadas e orientação para usar operações ordinais e culture-sensitive em cadeias de caracteres, consulte Práticas recomendadas para o uso de cadeias de caracteres na.NET Framework.

Operações para boxing, formatação e análise, comparação e classificação, e teste para igualdade podem ser ordinais ou culture-sensitive. As seções a seguir abordam cada categoria de operação.

Boxing

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 

Formatação e análise

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

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

Comparação de cadeias de caracteres e classificação

As regras de tipo determina a ordem alfabética de caracteres Unicode e como comparam duas cadeias de caracteres entre si. Por exemplo, o método de String.Compare(String, String, StringComparison) compara duas cadeias de caracteres com base no parâmetro de StringComparison . Se o valor do parâmetro é StringComparison.CurrentCulture, o método executa uma comparação lingüística que usa as convenções da cultura atual; se o valor do parâmetro é StringComparison.Ordinal, o método executa uma comparação ordinal. Portanto, como mostra o exemplo a seguir, se a cultura atual é inglês.. dos EUA., a primeira chamada para o método de String.Compare(String, String, StringComparison) (usando a comparação culture-sensitive) consulte “a” menor que “A”, mas a segunda chamada para o mesmo método (usando a comparação ordinal) consulte “a” maior que “A”.

C#

VB

Copiar

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

O.NET Framework com, em, e regras ordinais de tipo:

• Um tipo da palavra culture-sensitive executa uma comparação de cadeias de caracteres em que determinados caracteres não alfanuméricos Unicode podem ter os pesos especiais atribuídos a elas. Por exemplo, o hífen (-) pode ter um simples muito pequeno atribuído a ele para que a capoeira” e “a “capoeira” aparecessem próximos um do outro em uma lista classificada. Para obter uma lista dos métodos de String que comparam duas cadeias de caracteres usando palavra classificar regras, consulte a seção de Operações de cadeia de caracteres por categoria .

• Um tipo de cadeia de caracteres também executa uma comparação culture-sensitive. É semelhante a um tipo da palavra, exceto que não há nenhum caso especial, e todos os símbolos não alfanuméricos vêm antes de todos os caracteres alfanuméricos Unicode. Duas cadeias de caracteres podem ser comparadas usando regras de tipo de cadeia de caracteres chamando as sobrecargas do método de CompareInfo.Compare que têm um parâmetro de options que é fornecido um valor de CompareOptions.StringSort. Observe que este é o único método que o.NET Framework fornece para comparar duas cadeias de caracteres usando regras de tipo de cadeia de caracteres.

• Um tipo ordinal compara cadeias de caracteres com base no valor numérico de cada objeto de Char na cadeia de caracteres. Uma comparação ordinal é automaticamente com diferenciação de maiúsculas e minúsculas como as versões em maiúsculas de minúsculas e um caractere têm diferentes pontos de código. Em o entanto, se o caso não são importantes, você pode especificar uma comparação ordinal que ignora casos. Isso é equivalente ao converter a cadeia de caracteres para maiúsculas usando a cultura invariável e então executar uma comparação ordinal no resultado. Para obter uma lista dos métodos de String que comparam duas cadeias de caracteres usando regras ordinais de tipos, consulte a seção de Operações de cadeia de caracteres por categoria .

Uma comparação que confidenciais são quaisquer comparação que usar explícita ou implicitamente um objeto de CultureInfo , incluindo a cultura invariável que é especificado pela propriedade de CultureInfo.InvariantCulture . A localização implícita é a cultura atual, que é especificado pelas propriedades de Thread.CurrentCulture e de CultureInfo.CurrentCulture . Uma comparação culture-sensitive geralmente é apropriado para classificar, enquanto uma comparação ordinal não é. Uma comparação ordinal geralmente é apropriado para determinar se duas cadeias de caracteres são iguais (ou seja, para determinar a identidade), enquanto uma comparação que não é sensível.

Observação
As regras que levam de classificação e de capitalização usadas na comparação de cadeia de caracteres dependem da versão do .NET Framework. Em .NET Framework 4.5 que executa no sistema operacional de Windows 8 , ordenação, a caixa, a normalização, e de caracteres Unicode informações está de acordo com o padrão Unicode 6,0. Em outros sistemas operacionais, estão de acordo com o padrão Unicode 5,0.

Para obter mais informações sobre as palavras, a cadeia de caracteres, e regras ordinais do tipo, consulte o tópico de System.Globalization.CompareOptions . Para obter recomendações sobre quando usar cada regra, consulte Práticas recomendadas para o uso de cadeias de caracteres na.NET Framework.

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 de isso, os métodos de comparação são chamados por métodos de classificação como Array.Sort ou List<T>.Sort. O exemplo é executado quatro diferentes operações de classificação (tipo do word usando a cultura atual, digite a palavra usando a cultura invariável, ordinal tipo, e tipo de cadeia de caracteres usando a cultura invariável) sem explicitamente chamar um método de comparação de cadeia de caracteres. Observe que cada tipo de tipo produz ordenação exclusivo de cadeias de caracteres na matriz.

C#

VB

Copiar

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

Cuidado
Se seu objetivo principal em comparar cadeias de caracteres é determinar se forem iguais, você deve chamar o método de String.Equals . Normalmente, você deve usar Equals para realizar uma comparação ordinal. O método de String.Compare é destinado principalmente classificar cadeias de caracteres.

Os métodos de pesquisa de cadeia de caracteres, como String.StartsWith e String.IndexOf, também podem executar comparações de cadeias de caracteres culture-sensitive ou ordinais. O exemplo a seguir ilustra as diferenças entre ordinais e comparações que levam usando o método de IndexOf . Uma pesquisa culture-sensitive em que a cultura atual é inglês (Estados Unidos) considera a subcadeia de caracteres “oe” corresponder a ligadura “œ”. Porque um hífen () U+00AD virtual é um caractere de largura zero, a pesquisa trata o hífen virtual como equivalentes a Empty e encontrar uma correspondência no início da cadeia de caracteres. Uma pesquisa ordinal, por outro lado, não encontra uma correspondência em ambos os casos.

C#

VB

Copiar

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

Teste para igualdade

Use o método de String.Compare para determinar a relação de duas cadeias de caracteres em ordem de classificação. Normalmente, isso é uma operação culture-sensitive. Por outro lado, chame o método de String.Equals para testar a igualdade. Porque o testar a igualdade geralmente compara a entrada do usuário com qualquer cadeia de caracteres, conhecida como um nome de usuário válido, uma senha, ou um caminho sistema de arquivos, é normalmente uma operação ordinal.

Cuidado

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

O exemplo a seguir ilustra o perigo de executar uma comparação culture-sensitive para igualdade quando ordinal deve ser usado em vez de isso. Em esse caso, a intenção de código é proibir acesso do sistema de arquivos de URL que começam com “FILE://” ou “file://” executando uma comparação que não diferencia maiúsculas de minúsculas de início de um URL com a cadeia de caracteres “FILE://”. Em o entanto, se uma comparação culture-sensitive é executada usando a cultura turca de Turquia () em uma URL que inicia com “file://”, a comparação para igualdade falhar, porque o equivalente maiúscula turco minúsculas “i” é “i” em vez de “i”. Como resultado, o acesso de sistema de arquivos é permitido inadvertidamente. Por outro lado, se uma comparação ordinal é executada, a comparação para igualdade tiver êxito, e acesso de sistema de arquivos é negado.

C#

VB

Copiar

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.

Alguns caracteres Unicode têm representações múltiplas. Por exemplo, qualquer um dos seguintes pontos de código podem representar a letra “ắ”:

• U+1EAF

• U+0103 U+0301

• U+0061 U+0306 U+0301

As representações múltiplas para um único caractere complicam a pesquisa, classificar, corresponder, e outras operações de cadeia de caracteres.

O padrão Unicode define um processo chamado a normalização que retorna uma representação binária de um caractere Unicode para algumas de suas representações binárias equivalentes. A normalização pode usar vários formulários, chamados algoritmos de normalização, que seguem as regras diferentes. O.NET Framework oferece suporte aos formulários C, D, KC, e KD de normalização Unicode. Quando as cadeias de caracteres foram normalizadas ao mesmo formulário de normalização, podem ser comparadas usando a comparação ordinal. Para obter mais informações sobre a normalização e formulários de normalização, consulte System.Text.NormalizationForm.

Você pode determinar se uma cadeia de caracteres é normalizada para o formulário C de normalização chamando o método de String.IsNormalized() , ou você pode chamar o método de String.IsNormalized(NormalizationForm) para determinar se uma cadeia de caracteres é padrão para um formulário especificado de normalização. Você também pode chamar o método de String.Normalize() para converter uma cadeia de caracteres ao formulário C de normalização, ou você pode chamar o método de String.Normalize(NormalizationForm) para converter uma cadeia de caracteres em um formulário especificado de normalização.

O exemplo a seguir ilustra a normalização de cadeia de caracteres. Define a letra “ố” em três maneiras diferentes em três diferentes cadeias de caracteres, e usa uma comparação ordinal de igualdade determinar que cada cadeia de caracteres diferem das outras duas cadeias de caracteres. Converte em cada cadeia de caracteres em formulários suporte de normalização, e novamente executa uma comparação ordinal de cada cadeia de caracteres em um formulário especificado de normalização. Em cada caso, o segundo testar a igualdade que mostra as cadeias de caracteres são iguais.

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

public class Example
{
   private static StreamWriter sw;

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

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

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

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

      sw.Close();   
   }

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

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 

   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

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

Comparando cadeias de caracteres

Cadeias de caracteres de teste para igualdade

localizando caracteres em uma cadeia de caracteres

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

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

• Métodos que indica a posição inicial de uma subcadeia de caracteres em uma instância de cadeia de caracteres. Esses incluem IndexOf, IndexOfAny, LastIndexOf, os métodos e de LastIndexOfAny .

Cuidado
Se você deseja procurar uma cadeia de caracteres por um padrão específico em vez de uma subcadeia de caracteres específica, você deve usar expressões regulares. Para obter mais informações, consulte Expressões Regulares do .NET Framework.

Modificando uma cadeia de caracteres

A classe de String inclui os seguintes métodos que aparecem para alterar o valor de uma cadeia de caracteres:

• Insert insere uma cadeia de caracteres na instância atual de 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 início de uma cadeia de caracteres.

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

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

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

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

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

• TrimEnd remove todas as ocorrências de um caractere de fim 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 alteração de cadeia de caracteres retornam um novo objeto de String . Não alteram o valor da instância atual.

extraindo subcadeias de caracteres de uma cadeia de caracteres

combinando cadeias de caracteres

Valores de formatação

copiando uma cadeia de caracteres

normalizando uma cadeia de caracteres