Cordas C#

Uma string é uma sequência de caracteres. Em C#, string é a palavra-chave da linguagem para o System.String tipo. Cada literal de string que escreves produz uma System.String instância.

string vs. String

A string palavra-chave e o nome do String tipo referem-se ao mesmo tipo. Compilam para uma linguagem intermédia idêntica (IL).

// The 'string' keyword is an alias for System.String. The two are identical.
string a = "hello";
String b = "hello";

Console.WriteLine(a == b);                // True
Console.WriteLine(typeof(string) == typeof(String)); // True

Prefira a string palavra-chave no seu próprio código. É consistente com as outras palavras-chave de tipo incorporadas (int, bool, double), e funciona sem uma using System; diretiva.

As cordas são imutáveis

Imutável significa que o valor não pode ser alterado depois de ser criado. Depois de criares um string, não podes mudar as suas personagens. Métodos como ToUpperInvariant, Replace, Substring, e Trim retornam uma nova cadeia que contenha o valor modificado. A instância original mantém-se igual.

string greeting = "hello";

// ToUpper returns a *new* string. The original is unchanged.
string shouted = greeting.ToUpperInvariant();

Console.WriteLine(greeting);  // hello
Console.WriteLine(shouted);   // HELLO

Como as strings são imutáveis, pode partilhá-las em segurança entre métodos e threads. Esta imutabilidade explica porque é que o string tipo se comporta como um tipo de valor no uso quotidiano, mesmo sendo um tipo de referência.

Quando constróis uma cadeia de caracteres a partir de muitos pequenos fragmentos num ciclo, usa StringBuilder para acrescentar diretamente e obter uma única cadeia de caracteres no final:

// For many sequential edits, StringBuilder avoids allocating a new string each time.
var builder = new StringBuilder();
for (int i = 1; i <= 3; i++)
{
    builder.Append("item ").Append(i).Append(';');
}
string result = builder.ToString();
Console.WriteLine(result);    // item 1;item 2;item 3;

Cadeias literais

C# oferece quatro formas literais. Cada formulário adequa-se a conteúdos diferentes. Como guia rápido:

• Use literais normais para texto curto e simples, com no máximo algumas sequências de escape.
• Utilize literais verbatim quando as barras invertidas predominarem no conteúdo, como caminhos do Windows ou padrões de regex.
• Utilize literais de cadeia em bruto para texto multilinha ou com formatação estrutural, como JSON inline, SQL, XML ou blocos de mensagens formatados.
• Adiciona um $ prefixo a qualquer um dos literais mencionados para obter uma cadeia interpolada quando precisares de incorporar valores.
• Adicione o sufixo u8 a um literal para produzir uma sequência de bytes UTF-8 (um(a) ReadOnlySpan<T> de byte) para APIs orientadas para bytes. Consulte os literais de cadeia UTF-8 na referência da linguagem para obter mais informações.

Literais regulares e sequências de escape

Um literal de cadeia de caracteres normal é delimitado por aspas duplas. A barra invertida indica o início de uma sequência de fuga:

// Common escape sequences inside a regular string literal.
string tabbed   = "name:\tAda";          // \t  tab
string twoLines = "line 1\nline 2";      // \n  newline
string quoted   = "She said \"hi\".";    // \"  literal quote
string path     = "C:\\src\\app";        // \\  literal backslash

Console.WriteLine(tabbed);
Console.WriteLine(twoLines);
Console.WriteLine(quoted);
Console.WriteLine(path);

As sequências de escape comuns incluem \n (nova linha), \t (tabulação), \" (aspas literais), \\ (barra inversa literal), \0 (carácter nulo) e sequências de escape Unicode (\uXXXX, \UXXXXXXXX).

A partir do C# 13, \e representa o carácter de controlo ESC (U+001B). É o byte inicial das sequências de escape do terminal ANSI:

// Beginning in C# 13, \e represents the ESC control character (U+001B).
// It's used to start ANSI terminal escape sequences.
string esc = "\e[31mError\e[0m: file missing";

Console.WriteLine(esc);                  // ESC[31mError ESC[0m: file missing
Console.WriteLine((int)'\e');          // 27

Use um literal normal quando o texto for curto e contiver apenas algumas sequências de escape. Quando os caracteres de escape começarem a ser mais numerosos do que os caracteres visíveis, passe para um literal verbatim ou raw.

Literais textuais

Um literal verbatim é precedido de @. As barras invertidas são tratadas literalmente, o que é útil para caminhos do Windows e padrões de expressões regulares:

// A verbatim string literal (@) treats backslashes literally.
// Useful for Windows paths and regular expressions.
string winPath = @"C:\src\app\readme.md";
string pattern = @"\d{3}-\d{4}";

Console.WriteLine(winPath);
Console.WriteLine(pattern);

Para incorporar uma citação literal dentro de uma sequência literal, dobre-a: @"She said ""hi"".". As cadeias verbatim também podem estender-se por várias linhas físicas.

Os literais verbatim são a escolha certa quando as barras invertidas fazem parte do conteúdo, mas não há muitas aspas incorporadas. Para texto de várias linhas ou conteúdo com aspas, os literais de cadeia em bruto são geralmente mais claros.

Literais de cadeia de caracteres brutos

Para qualquer literal que contenha aspas, barras invertidas ou várias linhas, prefira literais de cadeia em bruto. Eliminam completamente o ruído de escape, o que os torna a melhor opção para JSON inline, SQL, XML, padrões regex e blocos de texto formatados, onde a fonte deve assemelhar-se à saída:

// Raw string literals use three or more quotes and need no escaping.
// The source looks like the output, which is ideal for inline JSON, SQL, XML, and the like.
string json = """
    {
        "name": "Ada",
        "roles": ["admin", "editor"]
    }
    """;

string sql = """
    SELECT Id, Name
    FROM   Users
    WHERE  Name = 'O''Brien'
    """;

Console.WriteLine(json);
Console.WriteLine(sql);

Os literais de string brutos praticamente eliminam sequências de escape e acomodam qualquer formatação e citação que precises. Consulte cadeias de caracteres literais em bruto para as regras completas.

Cordas interpoladas

Um prefixo $ transforma um literal numa sequência interpolada. As expressões nos espaços reservados {} são avaliadas, e os respetivos resultados são inseridos, e é possível aplicar especificadores de formato padrão e alinhamento nesses espaços reservados. A interpolação também pode ser combinada com as outras formas de literais — use $@"..." para interpolar um literal verbatim, ou $"""...""" para interpolar um literal de cadeia de caracteres em bruto, para obter uma saída com formatação avançada:

// The $ prefix evaluates expressions inside { } and inserts their values.
string name = "Ada";
int score = 92;

string greeting = $"Hello, {name}! Your score is {score}.";
// Format specifiers and alignment work inside the holes.
string formatted = $"pi = {Math.PI:F3}, padded = |{name,10}|";

// Combine $ and """ for richly formatted multiline output.
string report = $"""
    Report for {name}
    -----------------
    Score : {score}
    Grade : {(score >= 90 ? "A" : "B")}
    """;

Console.WriteLine(greeting);
Console.WriteLine(formatted);
Console.WriteLine(report);

A interpolação é a forma recomendada de compor cadeias a partir de valores em código quotidiano.

Indexação e char

A string é uma sequência de unidades de código UTF-16. O indexador devolve um System.Char, que representa uma única unidade de código UTF-16, não necessariamente um ponto de código Unicode completo. Length devolve a contagem das unidades de código.

// A string is a sequence of UTF-16 code units. s[i] returns one char.
string word = "café";

Console.WriteLine(word.Length);          // 4
Console.WriteLine(word[0]);              // c

foreach (char c in word)
{
    Console.Write($"{c} ");              // c a f é
}
Console.WriteLine();

Para texto que possa conter emoji ou caracteres fora do Plano Multilíngue Básico, itere por runa usando Rune ou por cluster de grafemas usando StringInfo. A iteração simples char funciona para a maioria dos textos ocidentais e conteúdos dominantes em ASCII.

Igualdade de cadeia de caracteres

A igualdade em string compara sequências de caracteres, não referências:

// String equality compares character sequences, not references.
string left  = "hello";
string right = string.Concat("hel", "lo");

Console.WriteLine(left == right);                                      // True
Console.WriteLine(left.Equals(right, StringComparison.Ordinal));       // True

Para comparações que precisam de ser conscientes da localização ou do caso, passe um valor explícito StringComparison . StringComparison.Ordinal Use para valores de protocolo, identificadores e outros textos não linguísticos.

Operações comuns com cadeias de caracteres

Use a tabela seguinte como guia rápido para as operações diárias de cordas em C#:

A superfície completa da API — cada sobrecarga, cada método — está documentada na String referência.

Consulte também

• Literais de cadeia de caracteres brutos
• nameof operador
• String
• StringBuilder
• Char
• ReadOnlySpan<T>