String String String String Constructors

Definição

Sobrecargas

String(Char*) String(Char*) String(Char*)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de caracteres Unicode.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de inteiros com sinal de 8 bits, uma posição inicial na matriz e um comprimento.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inicializa uma nova instância da classe String para o valor indicado por uma matriz de caracteres Unicode, uma posição de caractere inicial dentro dessa matriz e um comprimento.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de caracteres Unicode, uma posição de caractere inicial dentro dessa matriz e um tamanho.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de inteiros com sinal de 8 bits, uma posição inicial na matriz, um comprimento e um objeto Encoding.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

String(SByte*) String(SByte*) String(SByte*)

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro para uma matriz de inteiros de 8 bits com sinal.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(Char[]) String(Char[]) String(Char[]) String(Char[])

Inicializa uma nova instância de String classe para o valor indicado por uma matriz de caracteres Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inicializa uma nova instância da classe String para o valor indicado por um caractere Unicode repetido um número de vezes especificado.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

Comentários

Nesta seção:In this section:

Sintaxe de construtor sobrecarregada Overloaded constructor syntax
Parâmetros Parameters
Exceções Exceptions
Qual método chamar? Which method do I call?
Criando cadeias de caracteres Creating strings
Manipulação de cadeias de caracteres repetitivas Handling repetitive strings
Exemplos de cadeias de caracteres ao instanciar:Examples of instantiating strings:
Usar a atribuição de cadeia de caracteresUsing string assignment
Usando uma matriz de caracteresUsing a character array
Usando uma parte de uma matriz de caracteres e repetindo um único caractereUsing a portion of a character array and repeating a single character
Usando um ponteiro para uma matriz de caracteresUsing a pointer to a character array
Usando um ponteiro e um intervalo de uma matrizUsing a pointer and a range of an array
Usando um ponteiro para uma matriz de bytes com sinalUsing a pointer to a signed byte array
Informações de versãoVersion information

Sintaxe de construtor sobrecarregadaOverloaded constructor syntax

Construtores de cadeia de caracteres se enquadram em duas categorias: aqueles sem parâmetros de ponteiro e aqueles com parâmetros de ponteiro.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. Os construtores que usam ponteiros não são compatíveis com CLS.The constructors that use pointers are not CLS-compliant. Além disso, o Visual Basic não suporta o uso de ponteiros e c# requer código que usa ponteiros para ser executado em um contexto inseguro.In addition, Visual Basic does not support the use of pointers, and C# requires code that uses pointers to run in an unsafe context. Para obter mais informações, consulte unsafe.For more information, see unsafe.

Para obter orientação adicional sobre como escolher uma sobrecarga, consulte qual método devo chamar?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
Inicializa a nova instância para o valor indicado por uma matriz de caracteres Unicode.Initializes the new instance to the value indicated by an array of Unicode characters. Este construtor copia caracteres Unicode (exemplo).This constructor copies Unicode characters(example).

String(Char[] value, Int32 startIndex, Int32 length)
Inicializa a nova instância para o valor indicado por uma matriz de caracteres Unicode, uma posição do caractere inicial dentro dessa matriz e um comprimento (exemplo).Initializes the new instance to the value indicated by an array of Unicode characters, a starting character position within that array, and a length (example).

String(Char c, Int32 count)
Inicializa a nova instância para o valor indicada por um caractere Unicode especificado repetido um número de vezes especificado (exemplo).Initializes the new instance to the value indicated by a specified Unicode character repeated a specified number of times (example).

String(char* value)
(Não compatível com CLS) Inicializa a nova instância para o valor indicado por um ponteiro para uma matriz de caracteres Unicode terminada por um caractere nulo (U + 0000 ou '\0').(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters that is terminated by a null character (U+0000 or '\0'). (exemplo).(example).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(char* value, Int32 startIndex, Int32 length)
(Não compatível com CLS) Inicializa a nova instância para o valor indicado por um ponteiro para uma matriz de caracteres Unicode, uma posição do caractere inicial dentro dessa matriz e um comprimento.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters, a starting character position within that array, and a length. O construtor copia os caracteres Unicode de value começando no índice startIndex e termina no índice startIndex + length - 1 (exemplo).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(Não compatível com CLS) Inicializa a nova instância para o valor indicado por um ponteiro para uma matriz de inteiros com sinal de 8 bits.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. A matriz é assumida para representar uma cadeia de caracteres codificada usando a página de código atual do sistema (ou seja, a codificação especificada por Encoding.Default).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). O construtor processa caracteres de value começando no local especificado pelo ponteiro até que um caractere nulo (0x00) seja atingido (exemplo).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length)
(Não compatível com CLS) Inicializa a nova instância para o valor indicado por um ponteiro para uma matriz de inteiros com sinal de 8 bits, uma posição inicial dentro dessa matriz e um comprimento.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, and a length. A matriz é assumida para representar uma cadeia de caracteres codificada usando a página de código atual do sistema (ou seja, a codificação especificada por Encoding.Default).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). O construtor processa caracteres do valor começando startIndex e termina em startIndex + length - 1 (exemplo).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Não compatível com CLS) Inicializa a nova instância para o valor indicado por um ponteiro para uma matriz de inteiros com sinal de 8 bits, uma posição inicial na matriz, um comprimento de e um Encoding objeto.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

ParâmetrosParameters

Aqui está uma lista completa dos parâmetros usados pelo String construtores que não incluem um parâmetro de ponteiro.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Para os parâmetros usados por cada sobrecarga, consulte a sintaxe de sobrecarga acima.For the parameters used by each overload, see the overload syntax above.

ParâmetroParameter TipoType DescriçãoDescription
value Char[]Char[] Uma matriz de caracteres Unicode.An array of Unicode characters.
c Char Um caractere Unicode.A Unicode character.
startIndex Int32 A posição inicial no value do primeiro caractere na nova cadeia de caracteres.The starting position in value of the first character in the new string.

Valor padrão: 0Default value: 0
length Int32 O número de caracteres em value para incluir na nova cadeia de caracteres.The number of characters in value to include in the new string.

Valor padrão: Array.LengthDefault value: Array.Length
count Int32 O número de vezes que o caractere c é repetido na nova cadeia de caracteres.The number of times the character c is repeated in the new string. Se count for zero, o valor do novo objeto é String.Empty.If count is zero, the value of the new object is String.Empty.

Aqui está uma lista completa dos parâmetros usados pelo String construtores que incluem um parâmetro de ponteiro.Here is a complete list of parameters used by String constructors that include a pointer parameter. Para os parâmetros usados por cada sobrecarga, consulte a sintaxe de sobrecarga acima.For the parameters used by each overload, see the overload syntax above.

ParâmetroParameter TipoType DescriçãoDescription
value Char*

- ou --or-

SByte*
Um ponteiro para uma matriz terminada em nulo de caracteres Unicode ou uma matriz de inteiros com sinal de 8 bits.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. Se value está null ou uma matriz vazia, o valor da nova cadeia de caracteres é String.Empty.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 O índice do elemento da matriz que define o primeiro caractere na nova cadeia de caracteres.The index of the array element that defines the first character in the new string.

Valor padrão: 0Default value: 0
length Int32 O número de elementos da matriz para usar para criar a nova cadeia de caracteres.The number of array elements to use to create the new string. Se o comprimento for zero, o construtor cria uma cadeia de caracteres cujo valor é String.Empty.If length is zero, the constructor creates a string whose value is String.Empty.

Valor padrão: Array.LengthDefault value: Array.Length
enc Encoding Um objeto que especifica como o value matriz é codificada.An object that specifies how the value array is encoded.

Valor padrão: Encoding.Default, ou a página de código ANSI atual do sistemaDefault value: Encoding.Default, or the system's current ANSI code page

ExceçõesExceptions

Aqui está uma lista de exceções geradas por construtores que não incluem os parâmetros de ponteiro.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

ExceçãoException CondiçãoCondition Lançado porThrown by
ArgumentNullException value é null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length, ou count é menor que zero.startIndex,length, or count is less than zero.

- ou --or-

A soma de startIndex e length é maior que o número de elementos em value.The sum of startIndex and length is greater than the number of elements in value.

- ou --or-

count é menor que zero.count is less than zero.
String(Char, Int32)

String(Char[], Int32, Int32)

Aqui está uma lista de exceções geradas por construtores que incluem parâmetros de ponteiro.Here's a list of exceptions thrown by constructors that include pointer parameters.

ExceçãoException CondiçãoCondition Lançado porThrown by
ArgumentException value Especifica uma matriz que contém um caractere Unicode inválido.value specifies an array that contains an invalid Unicode character.

- ou --or-

value ou value + startIndex Especifica um endereço que é menor que 64K.value or value + startIndex specifies an address that is less than 64K.

- ou --or-

Uma nova String instância não pôde ser inicializada a partir de value porque a matriz de bytes value não usa a codificação de página de código padrão.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
Todos os construtores com ponteiros.All constructors with pointers.
ArgumentNullException value é nulo.value is null. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException O processo atual não tem acesso de leitura a todos os caracteres endereçados.The current process does not have read access to all the addressed characters.

- ou --or-

startIndex ou length é menor que zero, value + startIndex causa um estouro do ponteiro ou o processo atual não tem acesso de leitura a todos os caracteres endereçados.startIndex or length is less than zero, value + startIndex cause a pointer overflow, or the current process does not have read access to all the addressed characters.

- ou --or-

O comprimento da nova cadeia de caracteres é muito grande para alocar.The length of the new string is too large to allocate.
Todos os construtores com ponteiros.All constructors with pointers.
AccessViolationException value, ou value + startIndex + length -1, especifica um endereço inválido.value, or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Qual método devo chamar?Which method do I call?

ParaTo Chamada ou usoCall or use
Crie uma cadeia de caracteres.Create a string. Atribuição de uma cadeia de caracteres literal ou uma cadeia de caracteres existente (exemplo)Assignment from a string literal or an existing string (example)
Crie uma cadeia de caracteres de uma matriz de caractere inteiro.Create a string from an entire character array. String(Char[]) (example)String(Char[]) (example)
Crie uma cadeia de caracteres de uma parte de uma matriz de caracteres.Create a string from a portion of a character array. String(Char[], Int32, Int32) (example)String(Char[], Int32, Int32) (example)
Crie uma cadeia de caracteres que se repete o mesmo caractere várias vezes.Create a string that repeats the same character multiple times. String(Char, Int32) (example)String(Char, Int32) (example)
Crie uma cadeia de caracteres de um ponteiro para uma Unicode ou uma matriz de caractere largo.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Crie uma cadeia de caracteres de uma parte de uma Unicode ou uma matriz de caractere largo usando seu ponteiro.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
Criar uma cadeia de caracteres de um C++ char matriz.Create a string from a C++ char array. String(SByte*), String(SByte*, Int32, Int32)String(SByte*), String(SByte*, Int32, Int32)

- ou --or-

String(SByte*, Int32, Int32, Encoding)
Crie uma cadeia de caracteres ASCII.Create a string from ASCII characters. ASCIIEncoding.GetString

Criando cadeias de caracteresCreating strings

Usado com mais frequência técnica para criar cadeias de caracteres de forma programática é uma atribuição simples, conforme ilustrado na Este exemplo.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. O String classe também inclui quatro tipos de sobrecargas de construtor que permitem que você crie cadeias de caracteres entre os seguintes valores:The String class also includes four types of constructor overloads that let you create strings from the following values:

  • De uma matriz de caracteres (uma matriz de caracteres codificada em UTF-16).From a character array (an array of UTF-16-encoded characters). Você pode criar um novo String objeto dos caracteres em toda a matriz ou uma parte dele.You can create a new String object from the characters in the entire array or a portion of it. O String(Char[]) construtor copia todos os caracteres na matriz para a nova cadeia de caracteres.The String(Char[]) constructor copies all the characters in the array to the new string. O String(Char[], Int32, Int32) construtor copia os caracteres de índice startIndex índice startIndex + length -1 para a nova cadeia de caracteres.The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length - 1 to the new string. Se length for zero, o valor da nova cadeia de caracteres é String.Empty.If length is zero, the value of the new string is String.Empty.

    Se seu código instancia repetidamente cadeias de caracteres que têm o mesmo valor, você pode melhorar o desempenho do aplicativo por meio de um meio alternativo de criação de cadeias de caracteres.If your code repeatedly instantiates strings that have the same value, you can improve application performance by using an alternate means of creating strings. Para obter mais informações, consulte tratando cadeias de caracteres repetitivas.For more information, see Handling repetitive strings.

  • De um único caractere que é zero duplicado, uma, ou mais vezes, usando o String(Char, Int32) construtor.From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Se count for zero, o valor da nova cadeia de caracteres é String.Empty.If count is zero, the value of the new string is String.Empty.

  • De um ponteiro para uma matriz de caracteres terminada em nulo, usando o String(Char*) ou String(Char*, Int32, Int32) construtor.From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. A matriz inteira ou um intervalo especificado pode ser usado para inicializar a cadeia de caracteres.Either the entire array or a specified range can be used to initialize the string. O construtor copia uma sequência de caracteres Unicode começando a partir o ponteiro especificado ou o ponteiro especificado adição startIndex e continuando até o final da matriz ou para length caracteres.The constructor copies a sequence of Unicode characters starting from the specified pointer or from the specified pointer plus startIndex and continuing to the end of the array or for length characters. Se value for um ponteiro nulo ou length for zero, o construtor cria uma cadeia de caracteres cujo valor é String.Empty.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Se a operação de cópia continua até o final da matriz e a matriz não é terminada em nulo, o comportamento do construtor é dependente do sistema.If the copy operation proceeds to the end of the array and the array is not null-terminated, the constructor behavior is system-dependent. Uma condição desse tipo pode causar uma violação de acesso.Such a condition might cause an access violation.

    Se a matriz contiver quaisquer caracteres nulos inseridos (U + 0000 ou '\0') e o String(Char*, Int32, Int32) sobrecarga é chamada, a instância de cadeia de caracteres contém length caracteres, incluindo qualquer inseridos valores nulos.If the array contains any embedded null characters (U+0000 or '\0') and the String(Char*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. O exemplo a seguir mostra o que acontece quando um ponteiro para uma matriz de 10 elementos que inclui dois caracteres nulos é passado para o String(Char*, Int32, Int32) método.The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(Char*, Int32, Int32) method. Como o endereço é o início da matriz e todos os elementos na matriz devem ser adicionadas à cadeia de caracteres, o construtor cria uma instância de uma cadeia de caracteres com dez caracteres, incluindo dois nulos incorporados.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. Por outro lado, se a mesma matriz é passada para o String(Char*) construtor, o resultado é uma cadeia de caracteres de quatro caracteres que não inclua o primeiro caractere nulo.On the other hand, if the same array is passed to the String(Char*) constructor, the result is a four-character string that does not include the first null character.

    using namespace System;
    
    void main()
    {
       wchar_t chars[] = { L'a', L'b', L'c', L'd', L'\0', L'A', L'B', 
                           L'C', L'D', L'\0' };
       Char* chPtr = chars;
       String^ s = gcnew String(chPtr, 0, 
                                sizeof(chars) / sizeof (wchar_t));            
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();
       
       s = gcnew String(chPtr);         
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();    
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          char[] chars = { 'a', 'b', 'c', 'd', '\0', 'A', 'B', 'C', 'D', '\0' };
          string s = null;
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr, 0, chars.Length);            
          } 
    
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr);         
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    A matriz deve conter caracteres Unicode.The array must contain Unicode characters. No C++, isso significa que a matriz de caracteres deve ser definido como o gerenciado Charnão gerenciado ou tipo []wchar_ttipo [].In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    Se o String(Char*) sobrecarga é chamada e a matriz não é terminada em nulo, ou se o String(Char*, Int32, Int32) sobrecarga é chamada e startIndex + length-1 inclui um intervalo que ela fora da memória alocada para a sequência de caracteres, o comportamento do construtor é dependente do sistema e pode ocorrer uma violação de acesso.If the String(Char*) overload is called and the array is not null-terminated, or if the String(Char*, Int32, Int32) overload is called and startIndex + length-1 includes a range that it outside the memory allocated for the sequence of characters, the behavior of the constructor is system-dependent, and an access violation may occur. Além disso, no processador Intel Itanium, chamadas para o String(Char*, Int32, Int32) construtor pode lançar um DataMisalignedException exceção.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. Se isso ocorrer, chame o String(Char[], Int32, Int32) em vez disso.If this occurs, call the String(Char[], Int32, Int32) instead.

  • De um ponteiro para uma matriz de bytes com sinal.From a pointer to a signed byte array. A matriz inteira ou um intervalo especificado pode ser usado para inicializar a cadeia de caracteres.Either the entire array or a specified range can be used to initialize the string. A sequência de bytes pode ser interpretada por meio da página de código padrão de codificação ou uma codificação pode ser especificada na chamada do construtor.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. Se o construtor tenta criar uma instância de uma cadeia de caracteres de uma matriz de inteira que não é terminada em nulo, ou se o intervalo da matriz de value + startIndex à value + startIndex + length -1 está fora da memória alocada para a matriz, o comportamento desse construtor é dependente do sistema e pode ocorrer uma violação de acesso.If the constructor tries to instantiate a string from an entire array that is not null-terminated, or if the range of the array from value + startIndex to value + startIndex + length -1 is outside of the memory allocated for the array, the behavior of this constructor is system-dependent, and an access violation may occur.

    Os três construtores que incluem uma matriz de bytes com sinal como um parâmetro são projetados principalmente para converter um C++ char de matriz para uma cadeia de caracteres, conforme mostrado neste exemplo:The three constructors that include a signed byte array as a parameter are designed primarily to convert a C++ char array to a string, as shown in this example:

    using namespace System;
    
    void main()
    {
          char chars[] = { 'a', 'b', 'c', 'd', '\x00' };
          
          char* charPtr = chars;
          String^ value = gcnew String(charPtr);
    
          Console::WriteLine(value);
    }
    // The example displays the following output:
    //      abcd
    

    Se a matriz contiver quaisquer caracteres nulos ('\0') ou bytes cujo valor é 0 e o String(SByte*, Int32, Int32) sobrecarga é chamada, a instância de cadeia de caracteres contém length caracteres, incluindo qualquer inseridos valores nulos.If the array contains any null characters ('\0') or bytes whose value is 0 and the String(SByte*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. O exemplo a seguir mostra o que acontece quando um ponteiro para uma matriz de 10 elementos que inclui dois caracteres nulos é passado para o String(SByte*, Int32, Int32) método.The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(SByte*, Int32, Int32) method. Como o endereço é o início da matriz e todos os elementos na matriz devem ser adicionadas à cadeia de caracteres, o construtor cria uma instância de uma cadeia de caracteres com dez caracteres, incluindo dois nulos incorporados.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. Por outro lado, se a mesma matriz é passada para o String(SByte*) construtor, o resultado é uma cadeia de caracteres de quatro caracteres que não inclua o primeiro caractere nulo.On the other hand, if the same array is passed to the String(SByte*) constructor, the result is a four-character string that does not include the first null character.

    using namespace System;
    
    void main()
    {
       char bytes[] = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 
                        0x44, 0x00 };
       
       char* bytePtr = bytes;
       String^ s = gcnew String(bytePtr, 0, sizeof(bytes) / sizeof (char));
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       
       Console::WriteLine();
       
       s = gcnew String(bytePtr);
    
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();       
    }
    // The example displays the following output:
    //      0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //      0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 0x44, 0x00 };
          
          string s = null;
          fixed (sbyte* bytePtr = bytes) {
             s = new string(bytePtr, 0, bytes.Length);
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          
          Console.WriteLine();    
    
          fixed(sbyte* bytePtr = bytes) {
             s = new string(bytePtr);         
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    Porque o String(SByte*) e String(SByte*, Int32, Int32) construtores interpretam value usando a página de código ANSI padrão, chamar esses construtores com matrizes de byte idênticos pode criar cadeias de caracteres que têm valores diferentes em sistemas diferentes.Because the String(SByte*) and String(SByte*, Int32, Int32) constructors interpret value by using the default ANSI code page, calling these constructors with identical byte arrays may create strings that have different values on different systems.

Identificando cadeias de caracteres repetitivasHandling repetitive strings

Os aplicativos que analisam ou decodificar fluxos de texto geralmente usam o String(Char[], Int32, Int32) construtor ou o StringBuilder.Append(Char[], Int32, Int32) método para converter as sequências de caracteres em uma cadeia de caracteres.Apps that parse or decode streams of text often use the String(Char[], Int32, Int32) constructor or the StringBuilder.Append(Char[], Int32, Int32) method to convert sequences of characters into a string. Repetidamente, criando novas cadeias de caracteres com o mesmo valor em vez de criar e reutilizar uma cadeia de caracteres desperdiça memória.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Se você provavelmente criar o mesmo valor de cadeia de caracteres repetidamente chamando o String(Char[], Int32, Int32) de adiantamento de construtor, mesmo se você não souber em quais esses valores de cadeia de caracteres idênticos podem ser, você pode usar uma tabela de pesquisa em vez disso.If you are likely to create the same string value repeatedly by calling the String(Char[], Int32, Int32) constructor, even if you don't know in advance what those identical string values may be, you can use a lookup table instead.

Por exemplo, suponha que você ler e analisar um fluxo de caracteres de um arquivo que contém as marcas XML e atributos.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. Quando você analisa o fluxo, você encontrar repetidamente determinados tokens (ou seja, sequências de caracteres que têm um significado simbólico).When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). Tokens equivalentes às cadeias de caracteres "0", "1", "true" e "false" têm probabilidade de ocorrer com frequência em um fluxo XML.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

Em vez de converter cada token em uma nova cadeia de caracteres, você pode criar um System.Xml.NameTable objeto para armazenar cadeias de caracteres que ocorrem com frequência.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. O NameTable objeto melhora o desempenho, porque ele recupera cadeias de caracteres armazenadas sem alocação de memória temporária.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Quando você encontrar um token, use o NameTable.Get(Char[], Int32, Int32) método para recuperar o token da tabela.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. Se o token existir, o método retorna a cadeia de caracteres correspondente.If the token exists, the method returns the corresponding string. Se o token não existe, use o NameTable.Add(Char[], Int32, Int32) método para inserir o token na tabela e obter a cadeia de caracteres correspondente.If the token does not exist, use the NameTable.Add(Char[], Int32, Int32) method to insert the token into the table and to get the corresponding string.

Exemplo 1: usando atribuição da cadeia de caracteresExample 1: Using string assignment

O exemplo a seguir cria uma nova cadeia de caracteres, atribuindo a ela um literal de cadeia de caracteres.The following example creates a new string by assigning it a string literal. Ele cria uma segunda cadeia de caracteres, atribuindo o valor da primeira cadeia de caracteres a ele.It creates a second string by assigning the value of the first string to it. Essas são as duas formas mais comuns para instanciar um novo String objeto.These are the two most common ways to instantiate a new String object.

using namespace System;

void main()
{
   String^ value1 = L"This is a string.";
   String^ value2 = value1;
   Console::WriteLine(value1);
   Console::WriteLine(value2);
}
// The example displays the following output:
//    This is a string.
//    This is a string.
using System;

public class Example
{
   public static void Main()
   {
      String value1 = "This is a string.";
      String value2 = value1;
      Console.WriteLine(value1);
      Console.WriteLine(value2);
   }
}
// The example displays the following output:
//    This is a string.
//    This is a string.
Module Example
   Public Sub Main()
      Dim value1 As String = "This is a string."
      Dim value2 As String = value1
      Console.WriteLine(value1)
      Console.WriteLine(value2)
   End Sub
End Module
' The example displays the following output:
'    This is a string.
'    This is a string.

Exemplo 2: usando uma matriz de caracteresExample 2: Using a character array

O exemplo a seguir demonstra como criar um novo String objeto a partir de uma matriz de caracteres.The following example demonstrates how to create a new String object from a character array.

// Unicode Mathematical operators
wchar_t charArray1[4] = {L'\x2200',L'\x2202',L'\x200F',L'\x2205'};
wchar_t * lptstr1 =  &charArray1[ 0 ];
String^ wszMathSymbols = gcnew String( lptstr1 );

// Unicode Letterlike Symbols
wchar_t charArray2[4] = {L'\x2111',L'\x2118',L'\x2122',L'\x2126'};
wchar_t * lptstr2 =  &charArray2[ 0 ];
String^ wszLetterLike = gcnew String( lptstr2 );

// Compare Strings - the result is false
Console::WriteLine( String::Concat( L"The Strings are equal? ", (0 == String::Compare( wszLetterLike, wszMathSymbols ) ? (String^)"TRUE" : "FALSE") ) );
// Unicode Mathematical operators
char [] charArr1 = {'\u2200','\u2202','\u200F','\u2205'};
String szMathSymbols = new String(charArr1);

// Unicode Letterlike Symbols
char [] charArr2 = {'\u2111','\u2118','\u2122','\u2126'};
String szLetterLike = new String (charArr2);

// Compare Strings - the result is false
Console.WriteLine("The Strings are equal? " +
    (String.Compare(szMathSymbols, szLetterLike)==0?"true":"false") );
' Unicode Mathematical operators
Dim charArr1() As Char = {ChrW(&H2200), ChrW(&H2202), _
                          ChrW(&H200F), ChrW(&H2205)}
Dim szMathSymbols As New String(charArr1)

' Unicode Letterlike Symbols
Dim charArr2() As Char = {ChrW(&H2111), ChrW(&H2118), _
                          ChrW(&H2122), ChrW(&H2126)}
Dim szLetterLike As New String(charArr2)

' Compare Strings - the result is false
Console.WriteLine("The strings are equal? " & _
        CStr(szMathSymbols.Equals(szLetterLike))) 

Exemplo 3: usando uma parte de uma matriz de caracteres e repetindo um único caractereExample 3: Using a portion of a character array and repeating a single character

O exemplo a seguir demonstra como criar um novo String objeto a partir de uma parte de uma matriz de caracteres e como criar um novo String objeto que contém várias ocorrências de um único caractere.The following example demonstrates how to create a new String object from a portion of a character array, and how to create a new String object that contains multiple occurrences of a single character.

// Create a Unicode String with 5 Greek Alpha characters
String^ szGreekAlpha = gcnew String( L'\x0391',5 );

// Create a Unicode String with a Greek Omega character
wchar_t charArray5[3] = {L'\x03A9',L'\x03A9',L'\x03A9'};
String^ szGreekOmega = gcnew String( charArray5,2,1 );
String^ szGreekLetters = String::Concat( szGreekOmega, szGreekAlpha, szGreekOmega->Clone() );

// Examine the result
Console::WriteLine( szGreekLetters );

// The first index of Alpha
int ialpha = szGreekLetters->IndexOf( L'\x0391' );

// The last index of Omega
int iomega = szGreekLetters->LastIndexOf( L'\x03A9' );
Console::WriteLine( String::Concat(  "The Greek letter Alpha first appears at index ", Convert::ToString( ialpha ) ) );
Console::WriteLine( String::Concat(  " and Omega last appears at index ", Convert::ToString( iomega ),  " in this String." ) );
// Create a Unicode String with 5 Greek Alpha characters
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode String with a Greek Omega character
String szGreekOmega = new String(new char [] {'\u03A9','\u03A9','\u03A9'},2,1);

String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone());

// Examine the result
Console.WriteLine(szGreekLetters);

// The first index of Alpha
int ialpha = szGreekLetters.IndexOf('\u0391');
// The last index of Omega
int iomega = szGreekLetters.LastIndexOf('\u03A9');

Console.WriteLine("The Greek letter Alpha first appears at index " + ialpha +
    " and Omega last appears at index " + iomega + " in this String.");
' Create a Unicode String with 5 Greek Alpha characters
Dim szGreekAlpha As New String(ChrW(&H0391), 5)
' Create a Unicode String with a Greek Omega character
Dim szGreekOmega As New String(New Char() {ChrW(&H03A9), ChrW(&H03A9), _
                                           ChrW(&H03A9)}, 2, 1)

Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
                                             szGreekOmega.Clone())

' Examine the result
Console.WriteLine(szGreekLetters)

' The first index of Alpha
Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
' The last index of Omega
Dim iomega As Integer = szGreekLetters.LastIndexOf(ChrW(&H03A9))

Console.WriteLine("The Greek letter Alpha first appears at index {0}.", _ 
                  ialpha)
Console.WriteLIne("The Greek letter Omega last appears at index {0}.", _
                  iomega)

Exemplo 4: usando um ponteiro para uma matriz de caracteresExample 4: Using a pointer to a character array

O exemplo a seguir demonstra como criar um novo String objeto de um ponteiro para uma matriz de caracteres.The following example demonstrates how to create a new String object from a pointer to an array of characters. O exemplo c# deve ser compilado usando o /unsafe comutador de compilador.The C# example must be compiled by using the /unsafe compiler switch.

using namespace System;

void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   String^ value = gcnew String(charPtr);
   Console::WriteLine(value);
}
// The example displays the following output:
//        Hello world!
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      string value;
      
      fixed (char* charPtr = characters) {
         value = new String(charPtr);
      }                            
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//        Hello world!

Exemplo 5: criando uma instância de uma cadeia de caracteres a partir de um ponteiro e um intervalo de uma matrizExample 5: Instantiating a string from a pointer and a range of an array

O exemplo a seguir examina os elementos de uma matriz de caracteres por um período ou um ponto de exclamação.The following example examines the elements of a character array for either a period or an exclamation point. Se um for encontrado, ele cria uma instância de uma cadeia de caracteres dos caracteres na matriz que precedem o símbolo de pontuação.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. Caso contrário, ele cria uma instância de uma cadeia de caracteres com todo o conteúdo da matriz.If not, it instantiates a string with the entire contents of the array. O exemplo c# deve ser compilado usando o /unsafe comutador de compilador.The C# example must be compiled using the /unsafe compiler switch.

using namespace System;


void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   int length = 0;
   Char* iterator = charPtr;

   while (*iterator != '\x0000')
   {
      if (*iterator == L'!' || *iterator == L'.')
         break;
      *iterator++;
      length++;
   }
   String^ value = gcnew String(charPtr, 0, length);
   Console::WriteLine(value);
}
// The example displays the following output:
//      Hello World
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      String value;
      
      fixed (char* charPtr = characters) {
         int length = 0;
         Char* iterator = charPtr;
   
         while (*iterator != '\x0000')
         {
            if (*iterator == '!' || *iterator == '.')
               break;
            iterator++;
            length++;
         }
         value = new String(charPtr, 0, length);
      }
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//      Hello World

Exemplo 6: criando uma instância de uma cadeia de caracteres a partir de um ponteiro para uma matriz de bytes assinadosExample 6: Instantiating a string from a pointer to a signed byte array

O exemplo a seguir demonstra como você pode criar uma instância das String classe com o String(SByte*) construtor.The following example demonstrates how you can create an instance of the String class with the String(SByte*) constructor.

// Null terminated ASCII characters in a simple char array
char charArray3[4] = {0x41,0x42,0x43,0x00};
char * pstr3 =  &charArray3[ 0 ];
String^ szAsciiUpper = gcnew String( pstr3 );
char charArray4[4] = {0x61,0x62,0x63,0x00};
char * pstr4 =  &charArray4[ 0 ];
String^ szAsciiLower = gcnew String( pstr4,0,sizeof(charArray4) );

// Prints "ABC abc"
Console::WriteLine( String::Concat( szAsciiUpper,  " ", szAsciiLower ) );

// Compare Strings - the result is true
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper->ToUpper(), szAsciiLower->ToUpper() ) ? (String^)"TRUE" :  "FALSE") ) );

// This is the effective equivalent of another Compare method, which ignores case
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper, szAsciiLower, true ) ? (String^)"TRUE" :  "FALSE") ) );
unsafe
{
    // Null terminated ASCII characters in an sbyte array
    String szAsciiUpper = null;
    sbyte[] sbArr1 = new sbyte[] { 0x41, 0x42, 0x43, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiUpper = sbArr1)
    {
        szAsciiUpper = new String(pAsciiUpper);
    }
    String szAsciiLower = null;
    sbyte[] sbArr2 = { 0x61, 0x62, 0x63, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiLower = sbArr2)
    {
        szAsciiLower = new String(pAsciiLower, 0, sbArr2.Length);
    }
    // Prints "ABC abc"
    Console.WriteLine(szAsciiUpper + " " + szAsciiLower);

    // Compare Strings - the result is true
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper())==0?"true":"false") );

    // This is the effective equivalent of another Compare method, which ignores case
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper, szAsciiLower, true)==0?"true":"false") );
}

Informações de versãoVersion information

.NET Framework.NET Framework
Todas as sobrecargas são suportadas em: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0All overloads are supported in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile.NET Framework Client Profile
Todas as sobrecargas são suportadas em: 4, 3.5 SP1All overloads are supported in: 4, 3.5 SP1

Biblioteca de Classes PortátilPortable Class Library
Todas as sobrecargas sem um SByte * parâmetro têm suporteAll overloads without an SByte* parameter are supported

.NET para aplicativos da Windows Store.NET for Windows Store apps
Todas as sobrecargas sem um SByte * parâmetro têm suporte em: Windows 8All overloads without an SByte* parameter are supported in: Windows 8

String(Char*) String(Char*) String(Char*)

Importante

Esta API não está em conformidade com CLS.

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de caracteres Unicode.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

public:
 String(char* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value);
new string : nativeptr<char> -> string

Parâmetros

value
Char*

Um ponteiro para uma matriz de caracteres Unicode terminada em nulo.A pointer to a null-terminated array of Unicode characters.

Exceções

O processo atual não tem acesso de leitura a todos os caracteres endereçados.The current process does not have read access to all the addressed characters.

value especifica uma matriz que contém um caractere Unicode inválido ou value especifica um endereço menor que 64000.value specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Importante

Esta API não está em conformidade com CLS.

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de inteiros com sinal de 8 bits, uma posição inicial na matriz e um comprimento.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

public:
 String(System::SByte* value, int startIndex, int length);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length);
new string : nativeptr<sbyte> * int * int -> string

Parâmetros

value
SByte*

Um ponteiro para uma matriz de inteiros com sinal de 8 bits.A pointer to an array of 8-bit signed integers. Os inteiros são interpretados usando a codificação da página de código do sistema atual (ou seja, a codificação especificada por Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32 Int32 Int32 Int32

A posição inicial dentro de value.The starting position within value.

length
Int32 Int32 Int32 Int32

O número de caracteres dentro de value a ser usado.The number of characters within value to use.

Exceções

startIndex ou length é menor que zero.startIndex or length is less than zero.

- ou --or- O endereço especificado por value + startIndex é grande demais para a plataforma atual; ou seja, o cálculo do endereço estourou.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

- ou --or- O comprimento da nova cadeia de caracteres a ser inicializada é muito grande para alocar.The length of the new string to initialize is too large to allocate.

O endereço especificado por value + startIndex é menor que 64K.The address specified by value + startIndex is less than 64K.

- ou --or- Não foi possível inicializar uma nova instância de String usando value, supondo-se que value está codificado em ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndex e length coletivamente especificam um endereço inválido.value, startIndex, and length collectively specify an invalid address.

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inicializa uma nova instância da classe String para o valor indicado por uma matriz de caracteres Unicode, uma posição de caractere inicial dentro dessa matriz e um comprimento.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

public:
 String(cli::array <char> ^ value, int startIndex, int length);
public String (char[] value, int startIndex, int length);
new string : char[] * int * int -> string
Public Sub New (value As Char(), startIndex As Integer, length As Integer)

Parâmetros

value
Char[]

Uma matriz de caracteres Unicode.An array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

A posição inicial dentro de value.The starting position within value.

length
Int32 Int32 Int32 Int32

O número de caracteres dentro de value a ser usado.The number of characters within value to use.

Exceções

startIndex ou length é menor que zero.startIndex or length is less than zero.

- ou --or- A soma de startIndex e length é maior que o número de elementos em value.The sum of startIndex and length is greater than the number of elements in value.

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Importante

Esta API não está em conformidade com CLS.

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de caracteres Unicode, uma posição de caractere inicial dentro dessa matriz e um tamanho.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

public:
 String(char* value, int startIndex, int length);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value, int startIndex, int length);
new string : nativeptr<char> * int * int -> string

Parâmetros

value
Char*

Um ponteiro para uma matriz de caracteres Unicode.A pointer to an array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

A posição inicial dentro de value.The starting position within value.

length
Int32 Int32 Int32 Int32

O número de caracteres dentro de value a ser usado.The number of characters within value to use.

Exceções

startIndex ou length é menor que zero, value + startIndex causa um estouro do ponteiro ou o processo atual não tem acesso de leitura a todos os caracteres endereçados.startIndex or length is less than zero, value + startIndex cause a pointer overflow, or the current process does not have read access to all the addressed characters.

value especifica uma matriz que contém um caractere Unicode inválido ou value + startIndex especifica um endereço menor que 64000.value specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Importante

Esta API não está em conformidade com CLS.

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro especificado para uma matriz de inteiros com sinal de 8 bits, uma posição inicial na matriz, um comprimento e um objeto Encoding.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

public:
 String(System::SByte* value, int startIndex, int length, System::Text::Encoding ^ enc);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

Parâmetros

value
SByte*

Um ponteiro para uma matriz de inteiros com sinal de 8 bits.A pointer to an array of 8-bit signed integers.

startIndex
Int32 Int32 Int32 Int32

A posição inicial dentro de value.The starting position within value.

length
Int32 Int32 Int32 Int32

O número de caracteres dentro de value a ser usado.The number of characters within value to use.

enc
Encoding Encoding Encoding Encoding

Um objeto que especifica como a matriz é referenciada por value é codificada.An object that specifies how the array referenced by value is encoded. Se enc for null, a codificação ANSI será assumida.If enc is null, ANSI encoding is assumed.

Exceções

startIndex ou length é menor que zero.startIndex or length is less than zero.

- ou --or- O endereço especificado por value + startIndex é grande demais para a plataforma atual; ou seja, o cálculo do endereço estourou.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

- ou --or- O comprimento da nova cadeia de caracteres a ser inicializada é muito grande para alocar.The length of the new string to initialize is too large to allocate.

O endereço especificado por value + startIndex é menor que 64K.The address specified by value + startIndex is less than 64K.

- ou --or- Não foi possível inicializar uma nova instância de String usando value, supondo-se que value está codificado conforme especificado por enc.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex e length coletivamente especificam um endereço inválido.value, startIndex, and length collectively specify an invalid address.

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(SByte*) String(SByte*) String(SByte*)

Importante

Esta API não está em conformidade com CLS.

Inicializa uma nova instância da classe String para o valor indicado por um ponteiro para uma matriz de inteiros de 8 bits com sinal.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

public:
 String(System::SByte* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value);
new string : nativeptr<sbyte> -> string

Parâmetros

value
SByte*

Um ponteiro para uma matriz de inteiros de 8 bits com sinal com terminação nula.A pointer to a null-terminated array of 8-bit signed integers. Os inteiros são interpretados usando a codificação da página de código do sistema atual (ou seja, a codificação especificada por Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Exceções

Não foi possível inicializar uma nova instância de String usando value, supondo-se que value está codificado em ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

O comprimento da nova cadeia de caracteres a ser inicializada, que é determinado pelo caractere de terminação nula value, é muito grande para ser alocado.The length of the new string to initialize, which is determined by the null termination character of value, is too large to allocate.

value especifica um endereço inválido.value specifies an invalid address.

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)

public:
 String(ReadOnlySpan<char> value);
public String (ReadOnlySpan<char> value);
new string : ReadOnlySpan<char> -> string
Public Sub New (value As ReadOnlySpan(Of Char))

Parâmetros

String(Char[]) String(Char[]) String(Char[]) String(Char[])

Inicializa uma nova instância de String classe para o valor indicado por uma matriz de caracteres Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

public:
 String(cli::array <char> ^ value);
public String (char[] value);
new string : char[] -> string
Public Sub New (value As Char())

Parâmetros

value
Char[]

Uma matriz de caracteres Unicode.An array of Unicode characters.

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inicializa uma nova instância da classe String para o valor indicado por um caractere Unicode repetido um número de vezes especificado.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

public:
 String(char c, int count);
public String (char c, int count);
new string : char * int -> string
Public Sub New (c As Char, count As Integer)

Parâmetros

c
Char Char Char Char

Um caractere Unicode.A Unicode character.

count
Int32 Int32 Int32 Int32

O número de vezes que c ocorre.The number of times c occurs.

Exceções

Comentários

Observação

Para exemplos e informações de uso abrangentes sobre este e outras sobrecargas do construtor String, consulte o resumo do construtor String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Aplica-se a