Partilhar via

Cordas e cordas literais

  • Artigo

Uma corda é um objeto do tipo String cujo valor é texto. Internamente, o texto é armazenado como uma coleção sequencial apenas de leitura de Char objetos. Não há nenhum personagem nulo no final de uma corda C#; portanto, uma corda C# pode conter qualquer número de caracteres nulos incorporados ('\0'). A Length propriedade de uma corda representa o número de Char objetos que contém, não o número de caracteres Unicode. Para aceder aos pontos de código unicode individuais numa cadeia, utilize o StringInfo objeto.

string vs. System.String

Em C#, a string palavra-chave é um pseudónimo para String. Portanto, String e string são equivalentes, independentemente de ser recomendado usar o pseudónimo string fornecido como funciona mesmo sem using System;. A String classe fornece muitos métodos para criar, manipular e comparar cordas com segurança. Além disso, o idioma C# sobrecarrega alguns operadores para simplificar as operações comuns de cordas. Para obter mais informações sobre a palavra-chave, consulte a corda. Para obter mais informações sobre o tipo e os seus métodos, consulte String.

Declarando e inicializando cordas

Pode declarar e inicializar as cordas de várias formas, como mostra o seguinte exemplo:

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

Não se utiliza o novo operador para criar um objeto de corda, exceto quando se inicia a cadeia com uma matriz de chars.

Inicialize uma corda com o Empty valor constante para criar um novo String objeto cuja corda é de comprimento zero. A representação literal de uma corda de comprimento zero é "". Ao inicializar cordas com o Empty valor em vez de nula, pode reduzir as chances de ocorrência de uma NullReferenceException . Utilize o método estático IsNullOrEmpty(String) para verificar o valor de uma cadeia antes de tentar aceder-lhe.

Imutabilidade das cordas

Os objetos de corda são imutáveis: não podem ser mudados depois de terem sido criados. Todos os String métodos e operadores C# que parecem modificar uma corda realmente devolvem os resultados num novo objeto de corda. No exemplo seguinte, quando o conteúdo de s1 e s2 são concatenados para formar uma única corda, as duas cordas originais são modificadas. O += operador cria uma nova cadeia que contém o conteúdo combinado. Este novo objeto é atribuído à variável s1, e o objeto original a s1 que foi atribuído é lançado para recolha de lixo porque nenhuma outra variável tem uma referência a ele.

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.

Como uma "modificação" de cordas é na verdade uma nova criação de cordas, deve ter cuidado quando criar referências a cordas. Se criar uma referência a uma cadeia e, em seguida, "modificar" a cadeia original, a referência continuará a apontar para o objeto original em vez do novo objeto que foi criado quando a cadeia foi modificada. O seguinte código ilustra este comportamento:

string str1 = "Hello ";
string str2 = str1;
str1 += "World";

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

Para obter mais informações sobre como criar novas cordas baseadas em modificações como pesquisar e substituir operações na cadeia original, consulte Como modificar o conteúdo das cordas.

Literal de cordas citada

As cordas literais citadas são o início e o fim com um único carácter de citação dupla (") na mesma linha. As cordas literais citadas são mais adequadas para cordas que se encaixam numa única linha e não incluem sequências de fuga. Um literal de cordas citado deve incorporar caracteres de fuga, como mostra o seguinte exemplo:

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

Literales de cordas verbatim

Verbatim string literals são mais convenientes para cordas multi-linha, cordas que contêm caracteres de backslash, ou citações duplas incorporadas. As cordas verbatim preservam os caracteres da nova linha como parte do texto de cordas. Use aspas duplas para incorporar uma marca de aspa dentro de uma corda verbatim. O exemplo a seguir mostra algumas utilizações comuns para cordas 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."

Literales de cordas cruas

Começando com C# 11, pode utilizar literais de cordas cruas para criar mais facilmente cordas que sejam multi-line, ou usar quaisquer caracteres que necessitem de sequências de fuga. As cordas cruas eliminam a necessidade de utilizar sequências de fuga. Pode escrever a corda, incluindo a formatação whitespace, como pretende que apareça na saída. Uma corda crua literal:

  • Começa e termina com uma sequência de pelo menos três caracteres de citação dupla ("""). É-lhe permitido que mais de três caracteres consecutivos iniciem e terminem a sequência de forma a suportar letras de cordas que contenham três (ou mais) caracteres de citação repetidas.
  • As letras de corda crua de linha única requerem os caracteres de citação de abertura e fecho na mesma linha.
  • As letras de cordas cruas multi-linha requerem caracteres de citação de abertura e fecho na sua própria linha.
  • Em várias linhas de cordas cruas literais, qualquer espaço branco à esquerda das cotações finais é removido.

Os seguintes exemplos demonstram estas regras:

string singleLine = """Friends say "hello" as they pass by.""";
string multiLine = """
    "Hello World!" is typically the first program someone writes.
    """;
string embeddedXML = """
       <element attr = "content">
           <body style="normal">
               Here is the main text
           </body>
           <footer>
               Excerpts from "An amazing story"
           </footer>
       </element >
       """;
// The line "<element attr = "content">" starts in the first column.
// All whitespace left of that column is removed from the string.

string rawStringLiteralDelimiter = """"
    Raw string literals are delimited 
    by a string of at least three double quotes,
    like this: """
    """";

Os seguintes exemplos demonstram os erros do compilador relatados com base nestas regras:

// CS8997: Unterminated raw string literal.
var multiLineStart = """This
    is the beginning of a string 
    """;

// CS9000: Raw string literal delimiter must be on its own line.
var multiLineEnd = """
    This is the beginning of a string """;

// CS8999: Line does not start with the same whitespace as the closing line
// of the raw string literal
var noOutdenting = """
    A line of text.
Trying to outdent the second line.
    """;

Os dois primeiros exemplos são inválidos porque as cordas cruas multiline requerem a sequência de citação de abertura e fecho na sua própria linha. O terceiro exemplo é inválido porque o texto é excluído da sequência de cotação de encerramento.

Deve considerar as cordas cruas literais quando estiver a gerar texto que inclua caracteres que requerem sequências de fuga ao usar literal de cordas citadas ou literais de cordas verbatim. As cordas cruas literais serão mais fáceis de ler para si e para os outros, porque se assemelhará mais ao texto de saída. Por exemplo, considere o seguinte código que inclui uma cadeia de JSON formatado:

string jsonString = """
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "TemperatureRanges": {
    "Cold": {
      "High": 20,
      "Low": -10
    },
    "Hot": {
      "High": 60,
      "Low": 20
    }
            },
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}
""";

Compare este texto com o texto equivalente na nossa amostra sobre a serialização JSON, que não faz uso desta nova funcionalidade.

Sequências de fuga de cordas

Sequência de fuga Nome do personagem Codificação Unicode
\' Cotação única 0x0027
\" Cotação dupla 0x0022
\\ Backslash 0x005C
\0 Nulo 0x0000
\a Alerta 0x0007
\b Backspace 0x0008
\f Formulário feed 0x000C
\n Nova linha 0x000A
\r Retorno do transporte 0x000D
\t Separador horizontal 0x0009
\v Separador vertical 0x000B
\u Sequência de fuga unicódigo (UTF-16) \uHHHH (gama: 0000 - FFFF; exemplo: \u00E7 = "ç")
\U Sequência de fuga unicódigo (UTF-32) \U00HHHHHH (intervalo: 000000 - 10FF; exemplo: \U0001F47D = "👽")
\x Sequência de fuga unicode semelhante a "\u" exceto com comprimento variável \xH[H][H][H] (intervalo: 0 - FFFF; exemplo: \x00E7 ou \x0E7\xE7 = "ç")

Aviso

Quando utilizar a \x sequência de fuga e especificar menos de 4 dígitos de hexáxinhos, se os caracteres que seguem imediatamente a sequência de fuga forem dígitos de hexáxide válidos (ou seja, 0-9, A-F e a-f), serão interpretados como fazendo parte da sequência de fuga. Por exemplo, \xA1 produz "¡", que é o ponto de código U+00A1. No entanto, se o próximo personagem for "A" ou "a", então a sequência de fuga será interpretada como sendo \xA1A e produzirá "ਚ", que é o ponto de código U+0A1A. Nesses casos, especificar todos os 4 dígitos de hexáxia (por exemplo \x00A1 ) evitará qualquer possível má interpretação.

Nota

No tempo de compilação, as cordas verbatim são convertidas em cordas comuns com todas as mesmas sequências de fuga. Portanto, se vir uma cadeia verbatim na janela do relógio depurador, verá os caracteres de fuga que foram adicionados pelo compilador, e não a versão verbatim do seu código fonte. Por exemplo, a corda @"C:\files.txt" verbatim aparecerá na janela do relógio como "C:\\files.txt".

Cordas de formato

Uma cadeia de formato é uma cadeia cujo conteúdo é determinado dinamicamente no tempo de execução. As cordas de formato são criadas incorporando expressões interpoladas ou espaços reservados dentro de uma corda. Tudo dentro dos aparelhos ({...}) será resolvido a um valor e saída como uma corda formatada no tempo de execução. Existem dois métodos para criar cordas de formato: interpolação de cordas e formatação compósita.

Interpolação de cordas

Disponíveis em C# 6.0 e posteriormente, as $cordas interpoladas são identificadas pelo carácter especial e incluem expressões interpoladas em aparelhos. Se você é novo para a interpolação de cordas, consulte a interpolação string - C# tutorial interativo para uma visão geral rápida.

Utilize a interpolação de cadeias para melhorar a legibilidade e manutenção do seu código. A interpolação de cordas obtém os mesmos resultados que o String.Format método, mas melhora a facilidade de utilização e a clareza inline.

var jh = (firstName: "Jupiter", lastName: "Hammon", born: 1711, published: 1761);
Console.WriteLine($"{jh.firstName} {jh.lastName} was an African American poet born in {jh.born}.");
Console.WriteLine($"He was first published in {jh.published} at the age of {jh.published - jh.born}.");
Console.WriteLine($"He'd be over {Math.Round((2018d - jh.born) / 100d) * 100d} years old today.");

// Output:
// Jupiter Hammon was an African American poet born in 1711.
// He was first published in 1761 at the age of 50.
// He'd be over 300 years old today.

Começando com C# 10, pode utilizar a interpolação de cordas para inicializar uma cadeia constante quando todas as expressões utilizadas para os espaços reservados também são cordas constantes.

Começando com C# 11, você pode combinar literal de cordas cruas com interpolações de cordas. Começa-se e termina a cadeia de formato com três ou mais citações duplas sucessivas. Se a sua cadeia de saída deve conter o { ou } o carácter, pode utilizar caracteres extras $ para especificar quantos { caracteres começam } e terminam uma interpolação. Qualquer sequência de menos { ou } caracteres está incluída na saída. O exemplo a seguir mostra como pode utilizar essa função para mostrar a distância de um ponto a partir da origem e colocar o ponto dentro dos aparelhos:

int X = 2;
int Y = 3;

var pointMessage = $$"""The point {{{X}}, {{Y}}} is {{Math.Sqrt(X * X + Y * Y)}} from the origin.""";

Console.WriteLine(pointMessage);
// Output:
// The point {2, 3} is 3.605551275463989 from the origin.

Formatação compósita

O String.Format espaço reservado utiliza espaços reservados em aparelhos para criar uma cadeia de formato. Este exemplo resulta numa saída semelhante ao método de interpolação de cordas utilizado acima.

var pw = (firstName: "Phillis", lastName: "Wheatley", born: 1753, published: 1773);
Console.WriteLine("{0} {1} was an African American poet born in {2}.", pw.firstName, pw.lastName, pw.born);
Console.WriteLine("She was first published in {0} at the age of {1}.", pw.published, pw.published - pw.born);
Console.WriteLine("She'd be over {0} years old today.", Math.Round((2018d - pw.born) / 100d) * 100d);

// Output:
// Phillis Wheatley was an African American poet born in 1753.
// She was first published in 1773 at the age of 20.
// She'd be over 300 years old today.

Para obter mais informações sobre os tipos formatting .NET, consulte Tipos de Formatação em .NET.

Sublagem

Um sub-cordão é qualquer sequência de caracteres que está contido numa corda. Use o Substring método para criar uma nova corda a partir de uma parte da cadeia original. Pode pesquisar uma ou mais ocorrências de um subluto utilizando o IndexOf método. Utilize o Replace método para substituir todas as ocorrências de um sublamamento especificado por uma nova corda. Como o Substring método, na verdade devolve Replace uma nova corda e não modifica a corda original. Para obter mais informações, consulte Como pesquisar cordas e como modificar o conteúdo das cordas.

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

Aceder a caracteres individuais

Pode utilizar a notação de matriz com um valor de índice para adquirir acesso apenas de leitura a caracteres individuais, como no exemplo seguinte:

string s5 = "Printing backwards";

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

Se os String métodos não fornecerem a funcionalidade que você deve ter para modificar caracteres individuais em uma cadeia, você pode usar um StringBuilder objeto para modificar os chars individuais "in-place", e, em seguida, criar uma nova corda para armazenar os resultados usando os StringBuilder métodos. No exemplo seguinte, assuma que deve modificar a cadeia original de uma determinada forma e, em seguida, armazenar os resultados para utilização futura:

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?

Cordas nulas e cordas vazias

Uma corda vazia é um exemplo de um System.String objeto que contém zero caracteres. As cordas vazias são usadas frequentemente em vários cenários de programação para representar um campo de texto em branco. Podes chamar métodos em cordas vazias porque são objetos válidos System.String . As cordas vazias são inicializadas da seguinte forma:

string s = String.Empty;

Em contraste, uma corda nula não se refere a uma instância de um System.String objeto e qualquer tentativa de chamar um método numa corda nula causa um NullReferenceException. No entanto, pode utilizar cordas nulas em operações de concatenação e comparação com outras cordas. Os exemplos que se seguem ilustram alguns casos em que uma referência a uma corda nula faz e não faz uma exceção:

string str = "hello";
string nullStr = null;
string emptyStr = String.Empty;

string tempStr = str + nullStr;
// Output of the following line: hello
Console.WriteLine(tempStr);

bool b = (emptyStr == nullStr);
// Output of the following line: 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";
// Output of the following line: * abc*
Console.WriteLine("*" + s1 + "*");
// Output of the following line: *abc *
Console.WriteLine("*" + s2 + "*");
// Output of the following line: 4
Console.WriteLine(s2.Length);

Usando stringBuilder para criação de cordas rápidas

As operações de cordas em .NET são altamente otimizadas e na maioria dos casos não têm um impacto significativo no desempenho. No entanto, em alguns cenários, como loops apertados que estão executando muitas centenas ou milhares de vezes, as operações de cordas podem afetar o desempenho. A StringBuilder classe cria um tampão de cordas que oferece um melhor desempenho se o seu programa executar muitas manipulações de cordas. A StringBuilder cadeia também permite reatribuir caracteres individuais, algo que o tipo de dados de cadeia incorporado não suporta. Este código, por exemplo, altera o conteúdo de uma cadeia sem criar uma nova cadeia:

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

Neste exemplo, um StringBuilder objeto é usado para criar uma cadeia a partir de um conjunto de tipos numéricos:

var sb = new StringBuilder();

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

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

Console.WriteLine(sb);  // displays 9123456789

Cordas, métodos de extensão e LINQ

Como o String tipo implementa, pode utilizar os métodos IEnumerable<T>de extensão definidos na Enumerable classe em cordas. Para evitar a desordem visual, estes métodos são excluídos do IntelliSense para o String tipo, mas estão disponíveis no entanto. Também pode usar expressões de consulta LINQ em cordas. Para mais informações, consulte LINQ e Strings.