Constructor System.String

Artículo
01/30/2024

En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.

Sintaxis del constructor sobrecargado

Los constructores de cadena se dividen en dos categorías: las que no tienen parámetros de puntero y las que tienen parámetros de puntero. Los constructores que usan punteros no son compatibles con CLS. Además, Visual Basic no admite el uso de punteros y C# requiere código que use punteros para ejecutarse en un contexto no seguro. Para obtener más información, vea unsafe.

Para obtener instrucciones adicionales sobre cómo elegir una sobrecarga, consulte ¿A qué método se llama?.

String(Char[] value)
Inicializa la nueva instancia en el valor indicado por una matriz de caracteres Unicode. Este constructor copia caracteres Unicode(Ejemplo 2: Usar una matriz de caracteres).

String(Char[] value, Int32 startIndex, Int32 length)
Inicializa la nueva instancia en el valor indicado por una matriz de caracteres Unicode, una posición de carácter inicial dentro de esa matriz y una longitud (ejemplo 3: Usar una parte de una matriz de caracteres y repetir un solo carácter).

String(Char c, Int32 count)
Inicializa la nueva instancia en el valor indicado por un carácter Unicode especificado repetido un número especificado de veces (ejemplo 3: Usar una parte de una matriz de caracteres y repetir un solo carácter).

String(char* value)
(No compatible con CLS) Inicializa la nueva instancia en el valor indicado por un puntero a una matriz de caracteres Unicode terminados por un carácter NULL (U+0000 o '\0'). (Ejemplo 4: Usar un puntero a una matriz de caracteres).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato. Este miembro no se puede usar con código transparente o de confianza parcial.

String(char* value, Int32 startIndex, Int32 length)
(No compatible con CLS) Inicializa la nueva instancia en el valor indicado por un puntero a una matriz de caracteres Unicode, una posición de carácter inicial dentro de esa matriz y una longitud. El constructor copia los caracteres Unicode desde value el índice startIndex y termina en el índice startIndexlength + - 1 (ejemplo 5: Crear una instancia de una cadena desde un puntero y un intervalo de una matriz).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato. Este miembro no se puede usar con código transparente o de confianza parcial.

String(SByte* value)
(No compatible con CLS) Inicializa la nueva instancia en el valor indicado por un puntero a una matriz de enteros con signo de 8 bits. Se supone que la matriz representa una cadena codificada mediante la página de códigos del sistema actual (es decir, la codificación especificada por Encoding.Default). El constructor procesa caracteres desde value la ubicación especificada por el puntero hasta que se alcanza un carácter NULO (0x00) (Ejemplo 6: Crear una instancia de una cadena desde un puntero a una matriz de bytes firmada).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato. Este miembro no se puede usar con código transparente o de confianza parcial.

String(SByte* value, Int32 startIndex, Int32 length)
(No compatible con CLS) Inicializa la nueva instancia en el valor indicado por un puntero a una matriz de enteros con signo de 8 bits, una posición inicial dentro de esa matriz y una longitud. Se supone que la matriz representa una cadena codificada mediante la página de códigos del sistema actual (es decir, la codificación especificada por Encoding.Default). El constructor procesa caracteres del valor a partir startIndex de y termina en startIndexlength + - 1 (ejemplo 6: Crear una instancia de una cadena desde un puntero a una matriz de bytes firmada).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato. Este miembro no se puede usar con código transparente o de confianza parcial.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(No compatible con CLS) Inicializa la nueva instancia en el valor indicado por un puntero a una matriz de enteros con signo de 8 bits, una posición inicial dentro de esa matriz, una longitud y un Encoding objeto .

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato. Este miembro no se puede usar con código transparente o de confianza parcial.

Parámetros

Esta es una lista completa de los parámetros que usan String los constructores que no incluyen un parámetro de puntero. Para conocer los parámetros usados por cada sobrecarga, consulte la sintaxis de sobrecarga anterior.

Parámetro	Tipo	Descripción
`value`	Char[]	Matriz de caracteres Unicode.
`c`	Char	Carácter Unicode.
`startIndex`	Int32	Posición inicial del `value` primer carácter de la nueva cadena. Valor predeterminado: 0
`length`	Int32	Número de caracteres de que `value` se va a incluir en la nueva cadena. Valor predeterminado: Array.Length
`count`	Int32	Número de veces que el carácter `c` se repite en la nueva cadena. Si `count` es cero, el valor del nuevo objeto es String.Empty.

Esta es una lista completa de los parámetros que usan String los constructores que incluyen un parámetro de puntero. Para conocer los parámetros usados por cada sobrecarga, consulte la sintaxis de sobrecarga anterior.

Parámetro	Tipo	Descripción
`value`	Char* O bien SByte*	Puntero a una matriz terminada en null de caracteres Unicode o una matriz de enteros con signo de 8 bits. Si `value` es `null` o una matriz vacía, el valor de la nueva cadena es String.Empty.
`startIndex`	Int32	Índice del elemento de matriz que define el primer carácter de la nueva cadena. Valor predeterminado: 0
`length`	Int32	Número de elementos de matriz que se van a usar para crear la nueva cadena. Si length es cero, el constructor crea una cadena cuyo valor es String.Empty. Valor predeterminado: Array.Length
`enc`	Encoding	Objeto que especifica cómo se codifica la `value` matriz. Valor predeterminado: Encoding.Defaulto la página de códigos ANSI actual del sistema

Excepciones

Esta es una lista de excepciones producidas por constructores que no incluyen parámetros de puntero.

Exception	Condición	Producida por
ArgumentNullException	`value` es `null`.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	`startIndex`, `length` o `count` es menor que cero. O bien La suma de `startIndex` y `length` es mayor que el número de elementos de `value`. O bien `count` es menor que cero.	String(Char, Int32) String(Char[], Int32, Int32)

Esta es una lista de excepciones producidas por constructores que incluyen parámetros de puntero.

Exception	Condición	Producida por
ArgumentException	`value` especifica una matriz que contiene un carácter Unicode no válido. O bien `value` o `value` + `startIndex` especifica una dirección inferior a 64K. O bien No se pudo inicializar una nueva String instancia de la `value` matriz de bytes porque `value` no usa la codificación de página de códigos predeterminada.	Todos los constructores con punteros.
ArgumentNullException	`value` es null.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException	El proceso actual no tiene acceso de lectura a todos los caracteres tratados. O bien `startIndex` o `length` es menor que cero, `value` + `startIndex` produce un desbordamiento de puntero o el proceso actual no tiene acceso de lectura a todos los caracteres tratados. O bien La longitud de la nueva cadena es demasiado grande para asignar.	Todos los constructores con punteros.
AccessViolationException	`value`, o `value` + + `startIndexlength` - 1, especifica una dirección no válida.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

¿A qué método se llama?

En	Llamada o uso
Cree una cadena.	Asignación desde un literal de cadena o una cadena existente (ejemplo 1: Usar la asignación de cadenas)
Cree una cadena a partir de una matriz de caracteres completa.	String(Char[]) (Ejemplo 2: Usar una matriz de caracteres)
Cree una cadena a partir de una parte de una matriz de caracteres.	String(Char[], Int32, Int32) (Ejemplo 3: Usar una parte de una matriz de caracteres y repetir un solo carácter)
Cree una cadena que repita el mismo carácter varias veces.	String(Char, Int32) (Ejemplo 3: Usar una parte de una matriz de caracteres y repetir un solo carácter)
Cree una cadena desde un puntero a una matriz de caracteres Unicode o ancho.	String(Char*)
Cree una cadena a partir de una parte de una matriz de caracteres Unicode o ancho mediante su puntero.	String(Char*, Int32, Int32)
Cree una cadena a partir de una matriz de C++ `char` .	String(SByte), String(SByte, Int32, Int32) O bien String(SByte*, Int32, Int32, Encoding)
Cree una cadena a partir de caracteres ASCII.	ASCIIEncoding.GetString

Creación de cadenas

La técnica más usada para crear cadenas mediante programación es una asignación sencilla, como se muestra en el ejemplo 1. La String clase también incluye cuatro tipos de sobrecargas de constructor que permiten crear cadenas a partir de los valores siguientes:

Desde una matriz de caracteres (una matriz de caracteres con codificación UTF-16). Puede crear un nuevo String objeto a partir de los caracteres de toda la matriz o una parte de él. El String(Char[]) constructor copia todos los caracteres de la matriz en la nueva cadena. El String(Char[], Int32, Int32) constructor copia los caracteres del índice startIndex al índice startIndex + length : 1 a la nueva cadena. Si length es cero, el valor de la nueva cadena es String.Empty.

Si el código crea instancias repetidas de cadenas que tienen el mismo valor, puede mejorar el rendimiento de la aplicación mediante un medio alternativo para crear cadenas. Para obtener más información, consulte Control de cadenas repetitivas.
A partir de un único carácter duplicado cero, uno o más veces, mediante el String(Char, Int32) constructor . Si count es cero, el valor de la nueva cadena es String.Empty.
Desde un puntero a una matriz de caracteres terminada en NULL, mediante el String(Char*) constructor o String(Char*, Int32, Int32) . Se puede usar toda la matriz o un intervalo especificado para inicializar la cadena. El constructor copia una secuencia de caracteres Unicode a partir del puntero especificado o del puntero especificado más startIndex y continúa hasta el final de la matriz o para length caracteres. Si value es un puntero nulo o length es cero, el constructor crea una cadena cuyo valor es String.Empty. Si la operación de copia continúa al final de la matriz y la matriz no termina en null, el comportamiento del constructor depende del sistema. Esta condición puede provocar una infracción de acceso.

Si la matriz contiene caracteres NULL incrustados (U+0000 o '\0') y se llama a la String(Char*, Int32, Int32) sobrecarga, la instancia de cadena contiene length caracteres, incluidos los valores NULL incrustados. En el ejemplo siguiente se muestra lo que sucede cuando se pasa un puntero a una matriz de 10 elementos que incluye dos caracteres NULL al String(Char*, Int32, Int32) método . Dado que la dirección es el principio de la matriz y todos los elementos de la matriz se van a agregar a la cadena, el constructor crea una instancia de una cadena con diez caracteres, incluidos dos valores NULL incrustados. Por otro lado, si se pasa la misma matriz al String(Char*) constructor, el resultado es una cadena de cuatro caracteres que no incluye el primer carácter NULL.
```
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
```
La matriz debe contener caracteres Unicode. En C++, esto significa que la matriz de caracteres debe definirse como el tipo administrado Char[] o el tipo no administradowchar_t[].

Si se llama a la String(Char*) sobrecarga y la matriz no termina en null, o si se llama a la String(Char*, Int32, Int32) sobrecarga y startIndex + length-1 incluye un intervalo que está fuera de la memoria asignada para la secuencia de caracteres, el comportamiento del constructor depende del sistema y puede producirse una infracción de acceso.
Desde un puntero a una matriz de bytes firmada. Se puede usar toda la matriz o un intervalo especificado para inicializar la cadena. La secuencia de bytes se puede interpretar mediante la codificación de página de códigos predeterminada o se puede especificar una codificación en la llamada al constructor. Si el constructor intenta crear una instancia de una cadena de una matriz completa que no está terminada en NULL, o si el intervalo de la matriz de value + startIndex a + value + startIndexlength -1 está fuera de la memoria asignada para la matriz, el comportamiento de este constructor depende del sistema y puede producirse una infracción de acceso.

Los tres constructores que incluyen una matriz de bytes firmada como parámetro están diseñados principalmente para convertir una matriz de C++ char en una cadena, como se muestra en este ejemplo:
```
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
```
Si la matriz contiene caracteres NULL ('\0') o bytes cuyo valor es 0 y se llama a la String(SByte*, Int32, Int32) sobrecarga, la instancia de cadena contiene length caracteres, incluidos los valores NULL incrustados. En el ejemplo siguiente se muestra lo que sucede cuando se pasa un puntero a una matriz de 10 elementos que incluye dos caracteres NULL al String(SByte*, Int32, Int32) método . Dado que la dirección es el principio de la matriz y todos los elementos de la matriz se van a agregar a la cadena, el constructor crea una instancia de una cadena con diez caracteres, incluidos dos valores NULL incrustados. Por otro lado, si se pasa la misma matriz al String(SByte*) constructor, el resultado es una cadena de cuatro caracteres que no incluye el primer carácter NULL.
```
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
```
Dado que los constructores y String(SByte*, Int32, Int32) interpretan String(SByte*) value mediante la página de códigos ANSI predeterminada, llamar a estos constructores con matrices de bytes idénticas puede crear cadenas que tengan valores diferentes en distintos sistemas.

Controlar cadenas repetitivas

Las aplicaciones que analizan o descodifican secuencias de texto suelen usar el String(Char[], Int32, Int32) constructor o el StringBuilder.Append(Char[], Int32, Int32) método para convertir secuencias de caracteres en una cadena. Crear varias cadenas con el mismo valor en lugar de crear y reutilizar una cadena desperdicia memoria. Si es probable que cree repetidamente el mismo valor de cadena llamando al String(Char[], Int32, Int32) constructor, aunque no sepa con antelación cuáles son esos valores de cadena idénticos, puede usar una tabla de búsqueda en su lugar.

Por ejemplo, supongamos que lee y analiza una secuencia de caracteres de un archivo que contiene etiquetas y atributos XML. Al analizar la secuencia, se encuentran repetidamente determinados tokens (es decir, secuencias de caracteres que tienen un significado simbólico). Es probable que los tokens equivalentes a las cadenas "0", "1", "true" y "false" se produzcan con frecuencia en una secuencia XML.

En lugar de convertir cada token en una nueva cadena, puede crear un System.Xml.NameTable objeto que contenga cadenas que suelen producirse. El objeto mejora el NameTable rendimiento, ya que recupera cadenas almacenadas sin asignar memoria temporal. Cuando encuentre un token, use el NameTable.Get(Char[], Int32, Int32) método para recuperar el token de la tabla. Si el token existe, el método devuelve la cadena correspondiente. Si el token no existe, use el NameTable.Add(Char[], Int32, Int32) método para insertar el token en la tabla y para obtener la cadena correspondiente.

Ejemplo 1: Usar la asignación de cadenas

En el ejemplo siguiente se crea una nueva cadena asignando un literal de cadena. Crea una segunda cadena asignando el valor de la primera cadena a ella. Estas son las dos formas más comunes de crear instancias de un nuevo 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.

Ejemplo 2: Usar una matriz de caracteres

En el ejemplo siguiente se muestra cómo crear un nuevo String objeto a partir de una 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)))

Ejemplo 3: Usar una parte de una matriz de caracteres y repetir un solo carácter

En el ejemplo siguiente se muestra cómo crear un nuevo String objeto a partir de una parte de una matriz de caracteres y cómo crear un nuevo String objeto que contiene varias apariciones de un solo carácter.

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

Ejemplo 4: Usar un puntero a una matriz de caracteres

En el ejemplo siguiente se muestra cómo crear un nuevo String objeto desde un puntero a una matriz de caracteres. El ejemplo de C# debe compilarse mediante el /unsafe modificador del 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!

Ejemplo 5: Creación de instancias de una cadena desde un puntero y un intervalo de una matriz

En el ejemplo siguiente se examinan los elementos de una matriz de caracteres durante un punto o un signo de exclamación. Si se encuentra uno, crea una instancia de una cadena de los caracteres de la matriz que precede al símbolo de puntuación. Si no es así, crea una instancia de una cadena con todo el contenido de la matriz. El ejemplo de C# debe compilarse mediante el /unsafe modificador del 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

Ejemplo 6: Creación de instancias de una cadena desde un puntero a una matriz de bytes firmada

En el ejemplo siguiente se muestra cómo puede crear una instancia de la String clase con el String(SByte*) constructor .

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