Construtor System.String

Artigo
10/31/2024

Este artigo fornece observações complementares à documentação de referência para essa API.

Sintaxe de construtor sobrecarregada

Os construtores de cadeia de caracteres se enquadram em duas categorias: aqueles sem parâmetros de ponteiro e aqueles com parâmetros de ponteiro. Os construtores que usam ponteiros não são compatíveis com CLS. Além disso, o Visual Basic não dá suporte ao uso de ponteiros e o C# requer que o código que usa ponteiros seja executado em um contexto não seguro. Para obter mais informações, consulte unsafe.

Para obter diretrizes adicionais sobre como escolher uma sobrecarga, consulte Qual método devo chamar?.

String(Char[] value)
Inicializa a nova instância com o valor indicado por uma matriz de caracteres Unicode. Esse construtor copia caracteres Unicode (Exemplo 2: Usar uma matriz de caracteres).

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 de caractere inicial dentro dessa matriz e um comprimento (Exemplo 3: usar uma parte de uma matriz de caracteres e repetir um único caractere).

String(Char c, Int32 count)
Inicializa a nova instância com o valor indicado por um caractere Unicode especificado repetido um número especificado de vezes (Exemplo 3: Usar uma parte de uma matriz de caracteres e repetir um único caractere).

String(char* value)
(Não compatível com CLS) Inicializa a nova instância com o valor indicado por um ponteiro para uma matriz de caracteres Unicode que é encerrada por um caractere nulo (U+0000 ou '\0'). (Exemplo 4: Usar um ponteiro para uma matriz de caracteres).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.

String(char* value, Int32 startIndex, Int32 length)
(Não compatível com CLS) Inicializa a nova instância com o valor indicado por um ponteiro para uma matriz de caracteres Unicode, uma posição de caractere inicial dentro dessa matriz e um comprimento. O construtor copia os caracteres Unicode do value início no índice startIndex e do término no índice startIndexlength + - 1 (Exemplo 5: instanciar uma cadeia de caracteres de um ponteiro e um intervalo de uma matriz).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.

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 assinados de 8 bits. Supõe-se que a matriz represente uma cadeia de caracteres codificada usando a página de código do sistema atual (ou seja, a codificação especificada por Encoding.Default). O construtor processa caracteres desde value o início do local especificado pelo ponteiro até que um caractere nulo (0x00) seja alcançado (Exemplo 6: instanciar uma cadeia de caracteres de um ponteiro para uma matriz de bytes assinada).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.

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. Supõe-se que a matriz represente uma cadeia de caracteres codificada usando a página de código do sistema atual (ou seja, a codificação especificada por Encoding.Default). O construtor processa caracteres do valor começando em startIndex e terminando em startIndexlength + - 1 (Exemplo 6: instanciar uma cadeia de caracteres de um ponteiro para uma matriz de bytes assinada).

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.

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 dentro dessa matriz, um comprimento e um Encoding objeto.

Permissão: SecurityCriticalAttribute, requer confiança total para o chamador imediato. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.

Parâmetros

Aqui está uma lista completa de parâmetros usados por String construtores que não incluem um parâmetro de ponteiro. Para os parâmetros usados por cada sobrecarga, consulte a sintaxe de sobrecarga acima.

Parâmetro	Tipo	Descrição
`value`	Char[]	Uma matriz de caracteres Unicode.
`c`	Char	Um caractere Unicode.
`startIndex`	Int32	A posição inicial em `value` do primeiro caractere na nova cadeia de caracteres. Valor padrão: 0
`length`	Int32	O número de caracteres a `value` serem incluídos na nova cadeia de caracteres. Valor padrão: Array.Length
`count`	Int32	O número de vezes que o caractere `c` é repetido na nova cadeia de caracteres. Se `count` for zero, o valor do novo objeto será String.Empty.

Aqui está uma lista completa de parâmetros usados por String construtores que incluem um parâmetro de ponteiro. Para os parâmetros usados por cada sobrecarga, consulte a sintaxe de sobrecarga acima.

Parâmetro	Tipo	Descrição
`value`	Char* -ou- SByte*	Um ponteiro para uma matriz terminada em nulo de caracteres Unicode ou uma matriz de inteiros assinados de 8 bits. Se `value` for `null` ou uma matriz vazia, o valor da nova string será String.Empty.
`startIndex`	Int32	O índice do elemento de matriz que define o primeiro caractere na nova cadeia de caracteres. Valor padrão: 0
`length`	Int32	O número de elementos de matriz a serem usados para criar a nova cadeia de caracteres. Se length for zero, o construtor criará uma string cujo valor é String.Empty. Valor padrão: Array.Length
`enc`	Encoding	Um objeto que especifica como a `value` matriz é codificada. Valor padrão: Encoding.Default, ou a página de código ANSI atual do sistema

Exceções

Aqui está uma lista de exceções geradas por construtores que não incluem parâmetros de ponteiro.

Exceção	Condição	Lançado por
ArgumentNullException	`value` é `null`.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	`startIndex`, `length` ou `count` é menor que zero. -ou- A soma de `startIndex` e `length` é maior que o número de elementos em `value`. -ou- `count` é menor que zero.	String(Char, Int32) String(Char[], Int32, Int32)

Aqui está uma lista de exceções geradas por construtores que incluem parâmetros de ponteiro.

Exceção	Condição	Lançado por
ArgumentException	`value` especifica uma matriz que contém um caractere Unicode inválido. -ou- `value` ou `value` + `startIndex` especifica um endereço inferior a 64K. -ou- Uma nova String instância não pôde ser inicializada a `value` partir da matriz de bytes porque `value` não usa a codificação de página de código padrão.	Todos os construtores com ponteiros.
ArgumentNullException	`value` é nulo.	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. -ou- `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. -ou- O comprimento da nova cadeia de caracteres é muito grande para ser alocado.	Todos os construtores com ponteiros.
AccessViolationException	`value`, ou `value` + + `startIndexlength` - 1, especifica um endereço inválido.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

Qual método devo chamar?

Para	Ligar ou usar
Crie uma cadeia de caracteres.	Atribuição de um literal de cadeia de caracteres ou de uma cadeia de caracteres existente (Exemplo 1: usar atribuição de cadeia de caracteres)
Crie uma cadeia de caracteres a partir de uma matriz de caracteres inteira.	String(Char[]) (Exemplo 2: Usar uma matriz de caracteres)
Crie uma cadeia de caracteres a partir de uma parte de uma matriz de caracteres.	String(Char[], Int32, Int32) (Exemplo 3: Usar uma parte de uma matriz de caracteres e repetir um único caractere)
Crie uma cadeia de caracteres que repita o mesmo caractere várias vezes.	String(Char, Int32) (Exemplo 3: Usar uma parte de uma matriz de caracteres e repetir um único caractere)
Crie uma cadeia de caracteres de um ponteiro para uma matriz de caracteres Unicode ou larga.	String(Char*)
Crie uma cadeia de caracteres a partir de uma parte de uma matriz de caracteres Unicode ou larga usando seu ponteiro.	String(Char*, Int32, Int32)
Crie uma cadeia de caracteres a partir de uma matriz C++ `char` .	String(SByte), String(SByte, Int32, Int32) -ou- String(SByte*, Int32, Int32, Encoding)
Crie uma cadeia de caracteres a partir de caracteres ASCII.	ASCIIEncoding.GetString

Criar cadeias de caracteres

A técnica mais comumente usada para criar cadeias de caracteres programaticamente é a atribuição simples, conforme ilustrado no Exemplo 1. A String classe também inclui quatro tipos de sobrecargas de construtor que permitem criar cadeias de caracteres a partir dos seguintes valores:

De uma matriz de caracteres (uma matriz de caracteres codificados em UTF-16). Você pode criar um novo String objeto a partir dos caracteres em toda a matriz ou em uma parte dela. O String(Char[]) construtor copia todos os caracteres da matriz para a nova cadeia de caracteres. O String(Char[], Int32, Int32) construtor copia os caracteres de índice startIndex para índice startIndex + length - 1 para a nova cadeia de caracteres. Se length for zero, o valor da nova cadeia de caracteres será String.Empty.

Se o código instanciar repetidamente cadeias de caracteres com o mesmo valor, você poderá melhorar o desempenho do aplicativo usando um meio alternativo de criar cadeias de caracteres. Para obter mais informações, consulte Manipular cadeias de caracteres repetitivas.
De um único caractere que é duplicado zero, uma ou mais vezes, usando o String(Char, Int32) construtor. Se count for zero, o valor da nova cadeia de caracteres será String.Empty.
De um ponteiro para uma matriz de caracteres terminada em nulo, usando o String(Char*) construtor or String(Char*, Int32, Int32) . A matriz inteira ou um intervalo especificado pode ser usado para inicializar a cadeia de caracteres. O construtor copia uma sequência de caracteres Unicode começando do ponteiro especificado ou do ponteiro especificado mais startIndex e continuando até o final da matriz ou para length caracteres. Se value for um ponteiro nulo ou length for zero, o construtor criará uma cadeia de caracteres cujo valor é String.Empty. Se a operação de cópia prosseguir até o final da matriz e a matriz não for terminada em nulo, o comportamento do construtor será dependente do sistema. Essa condição pode causar uma violação de acesso.

Se a matriz contiver caracteres nulos inseridos (U+0000 ou '\0') e a String(Char*, Int32, Int32) sobrecarga for chamada, a instância da cadeia de caracteres conterá length caracteres, incluindo nulos inseridos. 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. Como o endereço é o início da matriz e todos os elementos da matriz devem ser adicionados à cadeia de caracteres, o construtor instancia uma cadeia de caracteres com dez caracteres, incluindo dois nulos inseridos. Por outro lado, se a mesma matriz for passada para o String(Char*) construtor, o resultado será uma cadeia de caracteres de quatro caracteres que não inclui o primeiro caractere nulo.
```
using System;

public class Example2
{
   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($"{(ushort)ch:X4} ");
      Console.WriteLine();
      
      fixed(char* chPtr = chars) {
         s = new string(chPtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
```
#nowarn "9"
open System

let chars = [| 'a'; 'b'; 'c'; 'd'; '\000'; 'A'; 'B'; 'C'; 'D'; '\000' |]
let s =
    use chPtr = fixed chars
    String(chPtr, 0, chars.Length)

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""

let s2 = 
    use chPtr = fixed chars
    String chPtr    

for ch in s2 do
    printf $"{uint16 ch:X4} "
printfn ""  
// 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. Em C++, isso significa que a matriz de caracteres deve ser definida como o tipo gerenciado Char[] ou o tipo não gerenciadowchar_t[].

Se a String(Char*) sobrecarga for chamada e a matriz não for terminada em nulo, ou se a String(Char*, Int32, Int32) sobrecarga for chamada e startIndex + length-1 incluir um intervalo que está fora da memória alocada para a sequência de caracteres, o comportamento do construtor será dependente do sistema e poderá ocorrer uma violação de acesso.
De um ponteiro para uma matriz de bytes assinada. A matriz inteira ou um intervalo especificado pode ser usado para inicializar a cadeia de caracteres. A sequência de bytes pode ser interpretada usando a codificação de página de código padrão ou uma codificação pode ser especificada na chamada do construtor. Se o construtor tentar instanciar uma cadeia de caracteres de uma matriz inteira que não seja terminada em nulo ou se o intervalo da matriz de value + startIndex a value + + startIndexlength -1 estiver fora da memória alocada para a matriz, o comportamento desse construtor será dependente do sistema e poderá ocorrer uma violação de acesso.

Os três construtores que incluem uma matriz de bytes assinada como um parâmetro são projetados principalmente para converter uma matriz C++ char em uma cadeia de caracteres, conforme mostrado neste exemplo:
```
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 caracteres nulos ('\0') ou bytes cujo valor é 0 e a String(SByte*, Int32, Int32) sobrecarga for chamada, a instância de cadeia de caracteres conterá length caracteres, incluindo nulos inseridos. 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. Como o endereço é o início da matriz e todos os elementos da matriz devem ser adicionados à cadeia de caracteres, o construtor instancia uma cadeia de caracteres com dez caracteres, incluindo dois nulos inseridos. Por outro lado, se a mesma matriz for passada para o String(SByte*) construtor, o resultado será uma cadeia de caracteres de quatro caracteres que não inclui o primeiro caractere nulo.
```
using System;

public class Example5
{
   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($"{(ushort)ch:X4} ");
      
      Console.WriteLine();    

      fixed(sbyte* bytePtr = bytes) {
         s = new string(bytePtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
```
#nowarn "9"
open System

let bytes = 
    [| 0x61y; 0x62y; 0x063y; 0x064y; 0x00y; 0x41y; 0x42y; 0x43y; 0x44y; 0x00y |]

let s =
    use bytePtr = fixed bytes
    String(bytePtr, 0, bytes.Length)

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""

let s2 =
    use bytePtr = fixed bytes
    String bytePtr         

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
Como os String(SByte*) construtores and String(SByte*, Int32, Int32) interpretam value usando a página de código ANSI padrão, chamar esses construtores com matrizes de bytes idênticas pode criar cadeias de caracteres com valores diferentes em sistemas diferentes.

Lidar com cadeias de caracteres repetitivas

Os aplicativos que analisam ou decodificam fluxos de texto geralmente usam o String(Char[], Int32, Int32) construtor ou o StringBuilder.Append(Char[], Int32, Int32) método para converter sequências de caracteres em uma cadeia de caracteres. Criar repetidamente novas cadeias de caracteres com o mesmo valor em vez de criar e reutilizar uma cadeia de caracteres desperdiça memória. Se for provável que você crie o mesmo valor de cadeia de caracteres repetidamente chamando o String(Char[], Int32, Int32) construtor, mesmo que não saiba com antecedência quais podem ser esses valores de cadeia de caracteres idênticos, poderá usar uma tabela de pesquisa.

Por exemplo, suponha que você leia e analise um fluxo de caracteres de um arquivo que contém marcas e atributos XML. Ao analisar o fluxo, você encontra repetidamente determinados tokens (ou seja, sequências de caracteres que têm um significado simbólico). Tokens equivalentes às cadeias de caracteres "0", "1", "true" e "false" provavelmente ocorrerão com frequência em um fluxo XML.

Em vez de converter cada token em uma nova cadeia de caracteres, você pode criar um System.Xml.NameTable objeto para conter cadeias de caracteres comuns. O NameTable objeto melhora o desempenho, pois recupera cadeias de caracteres armazenadas sem alocar memória temporária. Quando você encontrar um token, use o NameTable.Get(Char[], Int32, Int32) método para recuperá-lo da tabela. Se o token existir, o método retornará a cadeia de caracteres correspondente. Se o token não existir, use o NameTable.Add(Char[], Int32, Int32) método para inserir o token na tabela e obter a cadeia de caracteres correspondente.

Exemplo 1: Usar atribuição de cadeia de caracteres

O exemplo a seguir cria uma nova cadeia de caracteres atribuindo-lhe um literal de cadeia de caracteres. Ele cria uma segunda string atribuindo o valor da primeira string a ela. Essas são as duas maneiras mais comuns de instanciar um novo String objeto.

using System;

public class Example3
{
   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.

let value1 = "This is a string."
let value2 = value1
printfn "%s" value1
printfn "%s" 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: Usar uma matriz de caracteres

O exemplo a seguir demonstra como criar um novo String objeto a partir de uma matriz de caracteres.

// 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
let charArr1 = [| '\u2200'; '\u2202'; '\u200F'; '\u2205' |]
let szMathSymbols = String charArr1

// Unicode Letterlike Symbols
let charArr2 = [| '\u2111'; '\u2118'; '\u2122'; '\u2126' |]
let szLetterLike = String charArr2

// Compare Strings - the result is false
printfn $"The Strings are equal? %b{String.Compare(szMathSymbols, szLetterLike) = 0}"

' 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: Usar uma parte de uma matriz de caracteres e repetir um único caractere

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.

// 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
let szGreekAlpha = String('\u0391',5)
// Create a Unicode String with a Greek Omega character
let szGreekOmega = String([| '\u03A9'; '\u03A9'; '\u03A9' |],2,1)

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

// Examine the result
printfn $"{szGreekLetters}"

// The first index of Alpha
let ialpha = szGreekLetters.IndexOf '\u0391'
// The last index of Omega
let iomega = szGreekLetters.LastIndexOf '\u03A9'

printfn $"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: Usar um ponteiro para uma matriz de caracteres

O exemplo a seguir demonstra como criar um novo String objeto de um ponteiro para uma matriz de caracteres. O exemplo de C# deve ser compilado usando a opção do /unsafe compilador.

using System;

public class Example4
{
   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!

#nowarn "9"
open System

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' ' 
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

let value =
    use charPtr = fixed characters
    String charPtr

printfn $"{value}"
// The example displays the following output:
//        Hello world!

Exemplo 5: instanciar uma cadeia de caracteres de um ponteiro e um intervalo de uma matriz

O exemplo a seguir examina os elementos de uma matriz de caracteres para um ponto ou um ponto de exclamação. Se um for encontrado, ele instancia uma cadeia de caracteres dos caracteres na matriz que precedem o símbolo de pontuação. Caso contrário, ele instancia uma cadeia de caracteres com todo o conteúdo da matriz. O exemplo de C# deve ser compilado usando a opção do /unsafe compilador.

using System;

public class Example1
{
   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

#nowarn "9"
open System
open FSharp.NativeInterop

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' '
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

[<EntryPoint>]
let main _ =
    use charPtr = fixed characters
    let mutable length = 0
    let mutable iterator = charPtr
    let mutable broken = false
    while not broken && NativePtr.read iterator <> '\u0000' do
        if NativePtr.read iterator = '!' || NativePtr.read iterator = '.' then
            broken <- true
        else
            iterator <- NativePtr.add iterator 1
            length <- length + 1
    String(charPtr, 0, length)
    |> printfn "%s"
    0
// The example displays the following output:
//      Hello World

Exemplo 6: instanciar uma cadeia de caracteres de um ponteiro para uma matriz de bytes assinada

O exemplo a seguir demonstra como você pode criar uma instância da String classe com o String(SByte*) construtor.

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") );
}

// Null terminated ASCII characters in an sbyte array
let szAsciiUpper =
    let sbArr1 = [| 0x41y; 0x42y; 0x43y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiUpper = fixed sbArr1
    String pAsciiUpper

let szAsciiLower =
    let sbArr2 = [| 0x61y; 0x62y; 0x63y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiLower = fixed sbArr2 
    String(pAsciiLower, 0, sbArr2.Length)

// Prints "ABC abc"
printfn $"{szAsciiUpper} {szAsciiLower}"

// Compare Strings - the result is true
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper()) = 0}"

// This is the effective equivalent of another Compare method, which ignores case
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper, szAsciiLower, true) = 0}"