String em C#: Length, comparação, caracteres de escape, strings verbatim e multilinha

Uma string em C# é uma sequência de caracteres UTF-16 (valores char). Ela é um tipo de referência, mas se comporta como um valor nos pontos que importam: ela é imutável, e == compara o texto em vez da identidade do objeto. string é a palavra-chave de C# para o tipo .NET System.String; os dois são intercambiáveis.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

Saída:

Porto
5
0
*****
hi
Porto has 5 letters

Strings são imutáveis

Nenhum método muda uma string no lugar. ToUpper, Replace, Trim e todos os outros métodos retornam uma string nova e deixam a original intacta. Esquecer de usar o valor de retorno é um bug muito comum com strings:

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

Saída:

[  maya  ]
[MAYA]
tea
tea and cake

A imutabilidade torna as strings seguras para compartilhar entre threads e para usar como chaves de dicionário. O custo é que montar uma string pedaço por pedaço em um laço cria uma string nova a cada passo; para isso, use StringBuilder.

Length e índices

Length é uma propriedade (sem parênteses). O indexador s[i] retorna o char na posição i, contando a partir de 0, e é somente leitura:

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

Saída:

7
A
1
IndexOutOfRangeException
XB-2931

O C# 8 em diante também aceita um índice a partir do fim: code[^1] é o último caractere, o mesmo que code[code.Length - 1]. Para pegar vários caracteres de uma vez, veja substring.

Length conta unidades de código UTF-16, não o que um leitor vê como caracteres. A maioria das letras na maioria dos idiomas ocupa uma unidade, mas emojis e alguns sistemas de escrita raros usam duas (um par substituto), então "👍".Length é 2.

Comparando strings

== e != comparam os caracteres, diferenciando maiúsculas de minúsculas. Para qualquer outra coisa, passe um valor StringComparison que diz como comparar:

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

Saída:

False
False
True
True
apple first
True
False
False
True

Qual comparação usar:

• Ordinal compara os códigos numéricos dos caracteres. É rápida, previsível e igual em qualquer máquina. Use-a para identificadores, nomes de arquivo, chaves, valores de protocolo e tudo o que não é mostrado a uma pessoa.
• OrdinalIgnoreCase é a mesma coisa, ignorando maiúsculas e minúsculas. A escolha certa para verificações sem diferenciar maiúsculas e minúsculas, como extensões de arquivo ou cabeçalhos HTTP.
• CurrentCulture (e CurrentCultureIgnoreCase) segue as regras do idioma do usuário, então ordena as palavras como um dicionário nesse idioma faria. Use-a para ordenar listas mostradas aos usuários.
• InvariantCulture usa regras que respeitam a cultura, mas não dependem das configurações de idioma do usuário. Ela ainda depende da biblioteca de globalização: o .NET moderno usa ICU, o .NET Framework usa o NLS do Windows, e os dois podem ordenar algumas strings de forma diferente.

string.Compare(a, b) e a.CompareTo(b) sem um StringComparison usam a cultura atual, o que faz os resultados variarem entre máquinas. Evite comparar com a.ToLower() == b.ToLower(): isso aloca duas strings novas e dá respostas erradas em algumas culturas (o i com e sem ponto do turco é o caso clássico).

Chamar a.Equals(b) quando a é null lança uma NullReferenceException, enquanto a == b e o método static string.Equals(a, b) tratam null com segurança.

Caracteres de escape

Dentro de um literal de string comum, uma barra invertida começa uma sequência de escape:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

Saída:

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

Uma sequência não reconhecida como "\d" é um erro de compilação (CS1009, unrecognized escape sequence), que é o que acontece quando um caminho do Windows ou uma expressão regular é escrito como string comum.

Strings verbatim e strings multilinha

Prefixar um literal com @ o torna verbatim: as barras invertidas são caracteres literais, e a string pode ocupar várias linhas. O único escape que sobra é "", que produz uma aspa dupla.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

Saída:

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

Uma string verbatim multilinha inclui tudo o que está entre as aspas, inclusive a indentação das linhas de continuação, e é por isso que elas normalmente são escritas coladas à margem, como acima. As quebras de linha que ela contém são as do arquivo-fonte, então um arquivo salvo com finais de linha do Windows produz \r\n.

O C# 11 adicionou os raw string literals, que resolvem os dois problemas. Eles começam e terminam com três ou mais aspas duplas, não precisam de escape nenhum e removem a indentação em que as aspas de fechamento estão:

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

Se o próprio conteúdo contém """, comece e termine com quatro aspas. Raw literals também se combinam com interpolação ($"""..."""); veja interpolação de strings.

Null, vazia e espaços em branco

Uma variável string pode ser null (nenhuma string), vazia ("", tamanho 0) ou conter só espaços em branco. Dois auxiliares static verificam esses casos sem risco de NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

Saída:

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

Para validar entradas do usuário, string.IsNullOrWhiteSpace é quase sempre o que você quer. string.Empty e "" são o mesmo valor; qual escrever é questão de estilo.

Percorrendo os caracteres

Uma string é enumerável, então o foreach visita cada char. O tipo char tem métodos static para classificar caracteres:

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

Saída:

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

Juntando strings

+ concatena, e funciona com qualquer tipo do outro lado (ele chama ToString()). Para combinar muitos valores, prefira a interpolação ou string.Join:

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

Saída:

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

As duas últimas linhas mostram uma armadilha de precedência: + é avaliado da esquerda para a direita, então quando o lado esquerdo já é uma string, todo + seguinte é concatenação. Coloque parênteses na aritmética dentro de uma concatenação.