Noções básicas de seqüência de caracteres (guia de programação translation from VPE for Csharp)

Artigo
08/25/2010

Uma seqüência de caracteres é um objeto do tipo String cujo valor é texto. Internamente, o texto é armazenado sistema autônomo uma coleção somente leitura de Char objetos, cada um deles representa um caractere Unicode codificado em UTF-16. Não há nenhum caractere de terminação nula no participante de uma seqüência de caracteres translation from VPE for Csharp (ao contrário da C e C++); portanto uma seqüência de caracteres translation from VPE for Csharp pode conter qualquer número de caracteres nulo incorporados ('\0').O tamanho de uma seqüência de caracteres representa o número de caracteres independentemente de se os caracteres são formados de pares substitutos de Unicode ou não.Para acessar os pontos de código Unicode individuais em uma seqüência de caracteres, use o StringInfo objeto.

seqüência de caracteres vs.sistema.String

Em translation from VPE for Csharp, o string palavra-chave é um alias para String. Portanto, String e string são equivalente e você pode usam qualquer convenção de nomeação você preferir. The String classe fornece vários métodos para criação com segurança, manipulação e comparação de cadeias de caracteres. Além disso, o linguagem translation from VPE for Csharp sobrecargas alguns operadores para simplificar as operações de seqüência de caracteres comuns.Para obter mais informações sobre a palavra-chave, consulte seqüência de caracteres (translation from VPE for Csharp Reference). Para obter mais informações sobre o tipo e seus métodos, consulte String.

Declarar e inicializar strings

Você pode declarar e inicializar seqüências de caracteres em várias formas, sistema autônomo mostrado no exemplo a seguir:

// 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 usa o novo operador para criar um objeto de seqüência de caracteres, exceto quando inicializar 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 caracteres de comprimento zero. A representação literal de seqüência de caracteres de uma seqüência de caracteres de comprimento zero é "".Inicializando cadeias de caracteres com o Empty valor em vez de nulo, você pode reduzir as chances de um NullReferenceException ocorrendo. Usar o estáticoIsNullOrEmpty(String) método para verificar o valor de uma seqüência de caracteres antes de você tentar acessá-lo.

Imutabilidade dos objetos de string

Objetos String são imutável: eles não podem ser alterados após ter sido criados.Todos os String métodos e os operadores translation from VPE for Csharp que aparecem para modificar uma seqüência de caracteres, na verdade, retornam os resultados em um novo objeto de seqüência de caracteres. No exemplo a seguir, quando o Sumário de s1 e s2 concatenados para formulário uma única cadeia de caracteres, as duas seqüências originais são sem modificações. The += operador cria uma cadeia de caracteres de nova que contém o Sumário combinado. Esse novo objeto é atribuído a variável s1e o objeto original que foi atribuído a s1 é liberado para a coleta de lixo porque nenhuma Outros 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 criação de seqüência de caracteres de novo, você deve usar cuidado ao criar referências para seqüências de caracteres.Se você criar uma referência a uma seqüência de caracteres e "modificar", em seguida, a seqüência de caracteres original, a referência continuarão a apontar para o objeto original em vez do novo objeto que era criar d 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 sistema autônomo criar novas seqüências de caracteres que sejam baseiam em modificações, sistema autônomo Pesquisar e substituir operações em cadeia de caracteres original, consulte Como: Modificar o Sumário de string (guia de programação translation from VPE for Csharp).

Regular e Verbatim literais de string

Use literais de seqüências de caracteres normal quando você deve incorporar caracteres de escape fornecidos pelo translation from VPE for Csharp, 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 strings idênticas para conveniência e melhor legibilidade quando o texto da seqüência de caracteres contém caracteres de barra invertida, por exemplo, em caminhos de arquivo.Porque seqüências textual preservar novos caracteres de linha sistema autônomo parte da seqüência de caracteres de texto, eles podem ser usados para inicializar seqüências de caracteres de várias linhas.Use aspas duplas para incorporar uma aspa dentro de uma seqüência textual.O exemplo a seguir mostra alguns usos comuns para seqüências textual:

         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 seqüência de caracteres

sequência de escape	Nome do caractere	Codificação Unicode
\'	Aspas simples	0x0027
\"	Aspas duplas	0x0022
\\	Barra invertida	0x005C
\0	Null	0x0000
\a	Alerta	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	sequência de escape unicode para pares substitutos.	\Unnnnnnnn
\u	sequência de escape unicode	\u0041 = "A"
\v	Tabulação vertical	0x000B
\x	sequência de escape do Unicode semelhante a "\u", exceto com comprimento variável.	\x0041 = "A"

Observação:
No momento da compilar, literalmente seqüências serão convertidas em cadeias de caracteres comuns com as mesmas seqüências de escape.Portanto, se você exibir uma seqüência textual na janela de observação do depurador, você verá os caracteres de escape que foram adicionados pelo compilador, não a versão textual do seu código-fonte.Por exemplo, a seqüência de caracteres textual @ ” C:\files.txt ” aparecerá na janela Inspeção sistema autônomo “ C:\\files.txt ”.

No momento da compilar, literalmente seqüências serão convertidas em cadeias de caracteres comuns com as mesmas seqüências de escape.Portanto, se você exibir uma seqüência textual na janela de observação do depurador, você verá os caracteres de escape que foram adicionados pelo compilador, não a versão textual do seu código-fonte.Por exemplo, a seqüência de caracteres textual @ ” C:\files.txt ” aparecerá na janela Inspeção sistema autônomo “ C:\\files.txt ”.

Seqüências de formato

Uma seqüência de caracteres de formato é uma seqüência de caracteres cujo Sumário pode ser determinado dinamicamente no tempo de execução.Você criar uma seqüência de caracteres de formato usando o estáticoFormat método e incorporação de espaços reservados em 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, 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 do WriteLine método aceita uma seqüência de caracteres de formato sistema autônomo um parâmetro. Portanto, você pode incorporar apenas uma seqüência de caracteres de formato literal sem uma telefonar explícita para o método.No entanto, se você usar o WriteLine método para exibir a saída de depurar no Visual Studio Saída janela, você precisará chamar explicitamente o Format método porque WriteLine só aceita uma seqüência de caracteres, não uma seqüência de caracteres de formato. Para obter mais informações sobre seqüências de caracteres de formato, consulte Tipos de Formatação.

Substrings

Uma subseqüência de caracteres é qualquer sequência de caracteres que está contida em uma sequê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 substring especificada por uma nova seqüência de caracteres. Como a 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 strings string usando métodos (guia de programação translation from VPE for Csharp) e Como: Modificar o Sumário de string (guia de programação translation from VPE for Csharp).

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 adquirir acesso somente leitura para caracteres individuais, sistema autônomo 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 o String métodos não fornecem a funcionalidade que você deve ter para modificar caracteres individuais em uma seqüência de caracteres, você pode usar um StringBuilderPara modificar as caracteres individuais "no local" do objeto e, em seguida, 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 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?

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

Uma seqüência de caracteres vazia é uma instância de um System.String objeto que contém zero caracteres. Seqüências vazias são usadas freqüentemente em vários cenários de programação para representar um campo de texto em branco.Você pode telefonar métodos em Esvaziar cadeias de caracteres porque eles são válido System.String objetos. Seqüências vazias são inicializadas da seguinte maneira:

string s = String.Empty;

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

static void Main()
{
    string str = "hello";
    string nullStr = null;
    string emptyStr = "a";

    string tempStr = str + nullStr; // tempStr = "hello"
    bool b = (emptyStr == nullStr);// b = false;
    string newStr = emptyStr + nullStr; // creates a new empty string
    int len = nullStr.Length; // throws NullReferenceException

}

Usando o StringBuilder para criação rápida de string

Operações de seqüência de caracteres no .NET são altamente otimizadas e na maioria dos casos não significativamente afetam o desempenho.No entanto, em alguns cenários, sistema autônomo loops forte que estão executando centenas ou milhares de vezes, operações de cadeias de caracteres podem afetar o desempenho.The StringBuilder classe cria um buffer de cadeia de caracteres que oferece melhor desempenho se seu programa executar várias manipulações de seqüência de caracteres. The StringBuilder seqüência de caracteres também permite que você reatribuir caracteres individuais, algo que o tipo de dados interna da seqüência de caracteres não oferece suporte. Por exemplo, este código 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 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, métodos de extensão e LINQ

Porque o String tipo implementa IEnumerable<T>, você pode usar os métodos de extensão definidos o 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 estão disponível no entanto. 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.

Consulte também

Partilhar via