Strings (C# Programming Guide)

Uma seqüência de caracteres é um objeto do tipo String cujo valor é texto. Internamente, o texto é armazenado como uma coleção seqüencial de somente leitura de Char objetos. Não há nenhum caractere nulo de terminação no final de uma seqüência de C#; Portanto, uma seqüência de caracteres C# pode conter qualquer número de caracteres de nulo incorporados ('\0'). O Length a propriedade de uma seqüência de caracteres representa o número de Char objetos que ele contém, não o número de caracteres do Unicode. Para acessar os pontos de código Unicode individuais em uma seqüência de caracteres, use o StringInfo objeto.

seqüência vs.System. String

Em C# a string palavra-chave é um alias para String. Portanto, String e string são equivalentes e você pode usar qualquer convenção de nomenclatura que você preferir. O String classe fornece vários métodos para criação com segurança, a manipulação e comparando seqüências de caracteres. Além disso, a linguagem C# sobrecarrega alguns operadores para simplificar as operações mais comuns com strings. Para obter mais informações sobre a palavra-chave, consulte a seqüência de caracteres (C# referência). Para obter mais informações sobre o tipo e seus métodos, consulte String.

Declarar e inicializar as seqüências de caracteres

Você pode declarar e inicializar as seqüências de caracteres de várias formas, conforme o exemplo seguinte:

// Declare without initializing.
string message1;

// Initialize to null.
string message2 = null;

// Initialize as an empty string.
// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

//Initialize with a regular string literal.
string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.
string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.
System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)
// you can use implicit typing.
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from
// being used to store another string value.
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating
// a string from a char*, char[], or sbyte*. See
// System.String documentation for details.
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

Observe que você não usar o nova operador para criar um objeto de seqüência de caracteres, exceto quando a seqüência de caracteres com uma matriz de caracteres de inicialização.

Inicializar uma seqüência de caracteres com o Empty para criar um novo valor da constante String objeto cuja seqüência de comprimento zero. A representação literal de uma string de comprimento zero é "". Inicializando cadeias de caracteres com o Empty valor em vez de Nulo, você pode reduzir as chances de um NullReferenceException ocorrendo. Use estática IsNullOrEmpty(String) método para verificar o valor de uma seqüência de caracteres antes de tentar acessar o proprietário.

Imutabilidade de objetos String

Objetos String são imutáveis: não pode ser alterados depois que eles foram criados. Todas as String C# operadores que aparecem modificar uma seqüência de caracteres e os métodos realmente retornam os resultados em um novo objeto de seqüência de caracteres. No exemplo a seguir, quando o conteúdo de s1 e s2 são concatenados para formar uma única cadeia de caracteres, as duas seqüências de caracteres originais são modificadas. O += operador cria uma nova seqüência de caracteres que contém o conteúdo combinadas. Esse novo objeto é atribuído à variável s1e o objeto original que foi atribuído a s1 é liberada para coleta de lixo, porque nenhuma outra variável contém uma referência ao proprietário.

string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.

Porque uma seqüência de caracteres "modificação" é realmente uma nova criação de seqüência de caracteres, você deve usar o cuidado ao criar referências para seqüências de caracteres. Se você cria uma referência a uma seqüência de caracteres e, em seguida, "modificar" a seqüência de caracteres original, a referência continuará apontar para o objeto original em vez de um novo objeto que foi criado quando a seqüência foi modificada. O código a seguir ilustra esse comportamento:

string s1 = "Hello ";
string s2 = s1;
s1 += "World";

System.Console.WriteLine(s2);
//Output: Hello

Para obter mais informações sobre como criar novas seqüências de caracteres que sejam baseiam em modificações como pesquisar e substituir operações em uma seqüência de caracteres original, consulte How to: Modificar Conteúdo de seqüência (guia de programação de C#).

Literais de seqüência regular e Verbatim

Use literais de seqüência regular, quando você deve incorporar os caracteres de escape fornecidos pela C#, conforme mostrado no exemplo a seguir:

string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1        Column 2        Column 3

string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
  Row 1
  Row 2
  Row 3
*/

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Use seqüências de caracteres verbatim para conveniência e melhor legibilidade, quando o texto de seqüência de caracteres contém caracteres de barra invertida, por exemplo, em caminhos de arquivo. Como seqüências de caracteres verbatim preservar os caracteres de nova linha como parte do texto de seqüência de caracteres, pode ser usados para inicializar as seqüências de caracteres de várias linhas. Use aspas duplas para incorporar uma marca de aspas dentro de uma seqüência textual. O exemplo a seguir mostra alguns usos comuns para cadeias de caracteres verbatim:

string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\

string text = @"My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
   Thus on mine arm, most soothing sweet it is
   To sit beside our Cot,... 
*/

string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Seqüências de Escape de string

Observação

Em tempo de compilação, seqüências de caracteres verbatim são convertidos em cadeias de caracteres comuns com as mesmas seqüências de escape. Portanto, se você exibir uma seqüência de caracteres verbatim na janela de inspeção do depurador, você verá os caracteres de escape que foram adicionados pelo compilador, não a versão verbatim do seu código fonte. Por exemplo, a seqüência de caracteres verbatim @ "C:\files.txt" será exibido na janela watch como "C:\\files.txt".

Seqüências de caracteres de formato

Uma seqüência de formato é uma seqüência de caracteres cujo conteúdo pode ser determinado dinamicamente no tempo de execução. Você cria uma seqüência de caracteres de formato usando estática Format método e espaços reservados de incorporação chaves que serão substituídos por outros valores em tempo de execução. O exemplo a seguir usa uma seqüência de caracteres de formato para o resultado de cada iteração de um loop de saída:

class FormatString
{
    static void Main()
    {
        // Get user input.
        System.Console.WriteLine("Enter a number");
        string input = System.Console.ReadLine();

        // Convert the input string to an int.
        int j;
        System.Int32.TryParse(input, out j);

        // Write a different string each iteration.
        string s;
        for (int i = 0; i < 10; i++)
        {
            // A simple format string with no alignment formatting.
            s = System.String.Format("{0} times {1} = {2}", i, j, (i * j));
            System.Console.WriteLine(s);
        }

        //Keep the console window open in debug mode.
        System.Console.ReadKey();
    }
}

Uma sobrecarga de WriteLine método leva uma seqüência de caracteres de formato como um parâmetro. Portanto, você pode incorporar apenas uma seqüência de caracteres de formato literal sem uma chamada explícita para o método. No entanto, se você usar o WriteLine método para exibir a saída de depuração em que o Visual Studio saída janela, você precisa chamar explicitamente o Format método porque WriteLine só aceita uma seqüência de caracteres, não um formato de seqüência de caracteres. Para obter mais informações sobre seqüências de caracteres de formato, consulte Tipos de Formatação.

Substrings

Uma subseqüência de caracteres é qualquer seqüência de caracteres que está contida em uma seqüência de caracteres. Use o Substring método para criar uma nova seqüência de caracteres de uma parte da seqüência de caracteres original. Você pode procurar por uma ou mais ocorrências de uma substring usando o IndexOf método. Use o Replace método para substituir todas as ocorrências de uma subseqüência especificada com uma nova seqüência de caracteres. Como o Substring método, Replace , na verdade, retorna uma nova seqüência de caracteres e não modifica a seqüência original. Para obter mais informações, consulte How to: Procurar Seqüências de caracteres usando os métodos de String (guia de programação de C#) e How to: Modificar Conteúdo de seqüência (guia de programação de C#).

string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based
int index = s3.IndexOf("C");
// index = 7

Acessando os caracteres individuais

Você pode usar a notação de matriz com um valor de índice para adquirir acesso somente leitura a caracteres individuais, como no exemplo a seguir:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"

Se a String métodos não fornecem a funcionalidade que você deve ter para modificar os caracteres individuais em uma seqüência de caracteres, você pode usar um StringBuilder de objeto para modificar as caracteres individuais "in-loco" e crie uma nova seqüência de caracteres para armazenar os resultados usando o StringBuilder métodos. No exemplo a seguir, suponha que você deve modificar a seqüência de caracteres original de uma determinada maneira e armazenar os resultados para uso futuro:

string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)
{
    if (System.Char.IsLower(sb[j]) == true)
        sb[j] = System.Char.ToUpper(sb[j]);
    else if (System.Char.IsUpper(sb[j]) == true)
        sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?            

Seqüências de caracteres nulas e seqüências de caracteres vazias

Uma seqüência vazia é uma instância de um System.String objeto que contém zero caracteres. Seqüências de caracteres vazias são usadas com freqüência em vários cenários de programação para representar um campo de texto em branco. Você pode chamar métodos em cadeias de caracteres vazias, porque elas são válidas System.String objetos. Seqüências de caracteres vazias são inicializadas como segue:

string s = String.Empty;

Por outro lado, uma seqüência nula não se refere a uma instância de um System.String objeto e qualquer tentativa de chamar um método em uma seqüência nula faz com que uma NullReferenceException. No entanto, você pode usar seqüências de caracteres nulas na concatenação e operações de comparação com outras cadeias de caracteres. Os exemplos a seguir ilustram alguns casos em que uma referência a uma seqüência nula faz e não causa uma exceção seja lançada:

static void Main()
{
    string str = "hello";
    string nullStr = null;
    string emptyStr = String.Empty;

    string tempStr = str + nullStr;
    // The following line displays "hello."
    Console.WriteLine(tempStr);

    bool b = (emptyStr == nullStr);
    // The following line displays False.
    Console.WriteLine(b);

    // The following line creates a new empty string.
    string newStr = emptyStr + nullStr;

    // Null strings and empty strings behave differently. The following
    // two lines display 0.
    Console.WriteLine(emptyStr.Length);
    Console.WriteLine(newStr.Length);
    // The following line raises a NullReferenceException.
    //Console.WriteLine(nullStr.Length);

    // The null character can be displayed and counted, like other chars.
    string s1 = "\x0" + "abc";
    string s2 = "abc" + "\x0";
    // The following line displays "* abc*".
    Console.WriteLine("*" + s1 + "*");
    // The following line displays "abc *".
    Console.WriteLine("*" + s2 + "*");
    // The following line displays 4.
    Console.WriteLine(s2.Length);
}

Usando o StringBuilder para criação rápida de seqüência de caracteres

Seqüência de operações.NET são altamente otimizados e na maioria dos casos não afeta o desempenho significativamente. No entanto, em alguns cenários, como loops rígidos que estiverem executando centenas ou milhares de vezes, as operações de cadeia de caracteres podem afetar o desempenho. O StringBuilder classe cria um buffer de seqüência que oferece melhor desempenho se seu programa executa várias manipulações de seqüência de caracteres. O StringBuilder seqüência de caracteres também permite que você reatribuir caracteres individuais, algo que os dados de seqüência de caracteres interna tipo não oferece suporte. Esse código, por exemplo, altera o conteúdo de uma seqüência de caracteres sem criar uma nova seqüência de caracteres:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
System.Console.ReadLine();

//Outputs Cat: the ideal pet

Neste exemplo, um StringBuilder objeto é usado para criar uma seqüência de caracteres a partir de um conjunto de tipos numéricos:

class TestStringBuilder
{
    static void Main()
    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();

        // Create a string composed of numbers 0 - 9
        for (int i = 0; i < 10; i++)
        {
            sb.Append(i.ToString());
        }
        System.Console.WriteLine(sb);  // displays 0123456789

        // Copy one character of the string (not possible with a System.String)
        sb[0] = sb[9];

        System.Console.WriteLine(sb);  // displays 9123456789
    }
}

Seqüências de caracteres, os métodos de extensão e LINQ

Porque o String tipo implementa IEnumerable<T>, você pode usar os métodos de extensão definidos a Enumerable classe em seqüências de caracteres. Para evitar confusão visual, esses métodos são excluídos do IntelliSense para o String tipo, mas eles estão disponíveis de Todavia. Você também pode usar LINQ expressões de consulta em seqüências de caracteres. Para obter mais informações, consulte LINQ e seqüências de caracteres.

Tópicos relacionados

Histórico de alterações