Cadeias de caracteres (Guia de Programação em C#)
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 nulos incorporados ('\0'). O Length 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 Unicode. Para acessar os pontos de código Unicode individuais em uma seqüência de caracteres, use o StringInfo objeto.
seqüência de caracteres vs.System. String
No C#, o 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, manipulação e comparação de 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 string (Referência de C#). 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 use o nova operador para criar um objeto de seqüência de caracteres, exceto quando Inicializando a seqüência de caracteres com uma matriz de caracteres.
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 que ocorrem. Use estática IsNullOrEmpty(String) método para verificar o valor de uma seqüência de caracteres antes de você tenta acessá-la.
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 para modificar uma seqüência de caracteres e métodos, na verdade, 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 combinado. 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 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 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 "modificar", em seguida, a seqüência de caracteres original, continuará a referência apontar para o objeto original em vez de um novo objeto que foi criado quando a seqüência de caracteres 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 seqüência de caracteres original, consulte Como modificar o conteúdo de uma cadeia de caracteres (Guia de Programação em C#).
Literais de seqüência regular e Verbatim
Use literais de seqüência de caracteres normal 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 cadeia 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 de caracteres verbatim. 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
Seqüência de escape |
Nome do caractere |
Codificação Unicode |
|---|---|---|
\' |
Aspa simples |
0x0027 |
\" |
Aspas duplas |
0x0022 |
\\ |
Barra invertida |
0x005C |
\0 |
Null |
0x0000 |
\a |
Alertar |
0x0007 |
\b |
BACKSPACE |
0x0008 |
\f |
Avanço de página |
0x000C |
\n |
Nova linha |
0x000A |
\r |
Retorno de carro |
0x000D |
\t |
Guia horizontal |
0x0009 |
\U |
Seqüência de escape do Unicode para pares substitutos. |
\Unnnnnnnn |
\u |
Seqüência de escape do Unicode |
\u0041 = "A" |
\v |
Tabulação vertical |
0x000B |
\x |
Seqüência de escape Unicode semelhante a "\u", exceto com comprimento variável. |
\x0041 = "A" |
Dica
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 de variáveis 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 a incorporação de espaços reservados chaves 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 gerar o resultado de cada iteração de um loop:
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 da WriteLine método usa 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 na Visual Studio saída janela, você precisa chamar explicitamente o Format método porque WriteLine só aceita uma seqüência de caracteres, não é uma seqüência de formato. Para obter mais informações sobre seqüências de caracteres de formato, consulte Formatando tipos no .NET Framework.
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. Como o Substring método, Replace , na verdade, retorna uma nova seqüência de caracteres e não modifica a seqüência de caracteres original. Para obter mais informações, consulte Como pesquisar cadeias de caracteres usando métodos de cadeia de caracteres (Guia de Programação em C#) e Como modificar o conteúdo de uma cadeia de caracteres (Guia de Programação em 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 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 o objeto para modificar os 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 String o objeto que contém zero caracteres. Cadeias 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 String objetos. Cadeias de caracteres vazias são inicializadas da seguinte maneira:
string s = String.Empty;
Por outro lado, uma seqüência nula não se refere a uma instância de um 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 em concatenação e as operações de comparação com outras seqüências de caracteres. Os exemplos a seguir ilustram alguns casos em que uma referência a uma seqüência nula faz e não faz com que uma exceção seja lançada:
static void Main()
{
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 o StringBuilder para rápida criação de seqüência de caracteres
Operações em cadeia de caracteres.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 várias 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 de caracteres que oferece melhor desempenho se seu programa executar várias manipulações de seqüência de caracteres. O StringBuilder seqüência de caracteres também permite que você reatribuir caracteres individuais, algo a seqüência de caracteres interna não oferece suporte a tipo de dados. 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 digite implementa IEnumerable, você pode usar os métodos de extensão definidos na Enumerable classe em cadeias 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 em cadeias de caracteres de consulta. Para obter mais informações, consulte LINQ e cadeias de caracteres.
Tópicos relacionados
Tópico |
Descrição |
|---|---|
Como modificar o conteúdo de uma cadeia de caracteres (Guia de Programação em C#) |
Fornece um exemplo de código que ilustra como modificar o conteúdo de seqüências de caracteres. |
Como concatenar várias cadeias de caracteres (Guia de Programação em C#) |
Ilustra como usar o + operador e o Stringbuilder classe para ingressar em seqüências de caracteres juntos em tempo de compilação e tempo de execução. |
Como comparar cadeias de caracteres (Guia de Programação em C#) |
Mostra como executar o ordinais comparações de seqüências de caracteres. |
Como dividir cadeias de caracteres (Guia de Programação em C#) |
Contém um exemplo de código ilustra como usar o String.Split método para analisar cadeias de caracteres. |
Explica como usar métodos específicos para pesquisar seqüências de caracteres. |
|
Como pesquisar cadeias de caracteres usando expressões regulares (Guia de Programação em C#) |
Explica como usar expressões regulares para pesquisar seqüências de caracteres. |
Como determinar se uma cadeia de caracteres representa um valor numérico (Guia de Programação em C#) |
Mostra como analisar com segurança uma seqüência de caracteres para ver se ele tem um valor numérico válido. |
Como converter uma cadeia de caracteres em um DateTime (Guia de Programação em C#) |
Mostra como converter uma seqüência de caracteres como "24/01/2008" para um DateTime objeto. |
Operações básicas de cadeias de caracteres no .NET Framework |
Fornece links para tópicos que usam String e StringBuilder métodos para executar operações básicas de seqüência de caracteres. |
Descreve como inserir caracteres ou espaços vazios em uma sequência de caracteres. |
|
Inclui informações sobre como comparar seqüências de caracteres e fornece exemplos em C# e Visual Basic. |
|
Descreve como criar e modificar objetos string dinâmico usando o StringBuilder classe. |
|
Fornece informações sobre como executar várias operações de cadeia de caracteres usando consultas LINQ. |
|
Fornece links para tópicos que explicam as construções de programação em C#. |
Capítulo do livro em destaque
Mais informações sobre variáveis de na início 2010 do Visual C#