String String String String Constructors

Definición

Sobrecargas

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

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero especificado que apunta a una 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(Char[]) String(Char[]) String(Char[]) String(Char[])

Inicializa una nueva instancia de la clase String en el valor indicado por una matriz de caracteres Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

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

Inicializa una nueva instancia de la clase String con el valor indicado por un carácter Unicode especificado que se repite un número de veces determinado.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

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

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero especificado que apunta a una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud.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(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inicializa una nueva instancia de la clase String con el valor indicado por una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud.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(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo especificado, una posición inicial dentro de dicha matriz y una longitud.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(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo especificado, una posición inicial dentro de dicha matriz, una longitud y un 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.

Comentarios

En esta sección:In this section:

Sintaxis de constructor sobrecargado Overloaded constructor syntax
Parámetros Parameters
Excepciones Exceptions
¿Qué método se debe llamar? Which method do I call?
Creación de cadenas Creating strings
Controlar cadenas repetitivas Handling repetitive strings
Ejemplos de crear instancias de cadenas:Examples of instantiating strings:
Uso de la asignación de cadenaUsing string assignment
Uso de una matriz de caracteresUsing a character array
Con una parte de una matriz de caracteres y un único carácter de repeticiónUsing a portion of a character array and repeating a single character
Mediante un puntero a una matriz de caracteresUsing a pointer to a character array
Uso de un puntero y un intervalo de una matrizUsing a pointer and a range of an array
Mediante un puntero a una matriz de bytes con signoUsing a pointer to a signed byte array
Información de versiónVersion information

Sintaxis de constructor sobrecargadoOverloaded constructor syntax

Constructores de cadena se dividen en dos categorías: las que no tienen parámetros de puntero y aquellos con los parámetros de puntero.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. Los constructores que utilizan punteros no son conformes a CLS.The constructors that use pointers are not CLS-compliant. Además, Visual Basic no admite el uso de punteros y C# requiere que el código que utiliza punteros para ejecutarse en un contexto no seguro.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 obtener más información, vea unsafe.For more information, see unsafe.

¿Para obtener orientación adicional acerca de cómo elegir una sobrecarga, vea qué método se debe llamar?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
Inicializa la nueva instancia con el valor indicado por una matriz de caracteres Unicode.Initializes the new instance to the value indicated by an array of Unicode characters. Este constructor copia caracteres Unicode (ejemplo).This constructor copies Unicode characters(example).

String(Char[] value, Int32 startIndex, Int32 length)
Inicializa la nueva instancia con el valor indicado por una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud (ejemplo).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 la nueva instancia en el valor indicada por un carácter Unicode especificado repite un número determinado de veces (ejemplo).Initializes the new instance to the value indicated by a specified Unicode character repeated a specified number of times (example).

String(char* value)
(No conforme a CLS) Inicializa la nueva instancia con el valor indicado por un puntero a una matriz de caracteres Unicode que termina con un carácter nulo (u+0000 o '\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'). (ejemplo).(example).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

String(char* value, Int32 startIndex, Int32 length)
(No conforme a CLS) Inicializa la nueva instancia con el valor indicado por un puntero a una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud.(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. El constructor copia los caracteres Unicode desde value empezando por índice startIndex y terminando en índice startIndex + length - 1 (ejemplo).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(No conforme a CLS) Inicializa la nueva instancia con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. La matriz se supone que representa una cadena codificada mediante la página de códigos del sistema actual (es decir, la codificación 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). El constructor procesa los caracteres de value a partir de la ubicación especificada por el puntero hasta que se alcanza un carácter nulo (0 x 00) (ejemplo).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length)
(No conforme a CLS) Inicializa la nueva instancia con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo, una posición inicial dentro de dicha matriz y una longitud.(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. La matriz se supone que representa una cadena codificada mediante la página de códigos del sistema actual (es decir, la codificación 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). El constructor procesa los caracteres de valor a partir startIndex hasta startIndex + length - 1 (ejemplo).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(No conforme a CLS) Inicializa la nueva instancia con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo, una posición inicial dentro de dicha matriz, una longitud y un 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.

Permiso: SecurityCriticalAttribute, requiere plena confianza para el llamador inmediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

ParámetrosParameters

Esta es una lista completa de parámetros utilizada por String constructores que no incluyen un parámetro de puntero.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Para los parámetros utilizados por cada sobrecarga, vea la sintaxis de sobrecarga anterior.For the parameters used by each overload, see the overload syntax above.

ParámetroParameter TipoType DescripciónDescription
value Char[]Char[] Matriz de caracteres Unicode.An array of Unicode characters.
c Char Carácter Unicode.A Unicode character.
startIndex Int32 La posición inicial en value del primer carácter en la nueva cadena.The starting position in value of the first character in the new string.

Valor predeterminado: 0Default value: 0
length Int32 El número de caracteres en value para incluir en la nueva cadena.The number of characters in value to include in the new string.

Valor predeterminado: Array.LengthDefault value: Array.Length
count Int32 El número de veces que el carácter c se repite en la nueva cadena.The number of times the character c is repeated in the new string. Si count es cero, el valor del nuevo objeto es String.Empty.If count is zero, the value of the new object is String.Empty.

Esta es una lista completa de parámetros utilizada por String constructores que incluyen un parámetro de puntero.Here is a complete list of parameters used by String constructors that include a pointer parameter. Para los parámetros utilizados por cada sobrecarga, vea la sintaxis de sobrecarga anterior.For the parameters used by each overload, see the overload syntax above.

ParámetroParameter TipoType DescripciónDescription
value Char*

O bien-or-

SByte*
Un puntero a una matriz terminada en null de caracteres Unicode o una matriz de enteros de 8 bits con signo.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. Si value es null o una matriz vacía, el valor de la nueva cadena es String.Empty.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 El índice del elemento de matriz que define el primer carácter en la nueva cadena.The index of the array element that defines the first character in the new string.

Valor predeterminado: 0Default value: 0
length Int32 El número de elementos de la matriz se usa para crear la nueva cadena.The number of array elements to use to create the new string. Si la longitud es cero, el constructor crea una cadena cuyo valor es String.Empty.If length is zero, the constructor creates a string whose value is String.Empty.

Valor predeterminado: Array.LengthDefault value: Array.Length
enc Encoding Objeto que especifica cómo el value se codifica la matriz.An object that specifies how the value array is encoded.

Valor predeterminado: Encoding.Default, o la página de códigos ANSI actual del sistemaDefault value: Encoding.Default, or the system's current ANSI code page

ExcepcionesExceptions

Presentamos una lista de excepciones producidas por los constructores que no incluyen los parámetros de puntero.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

ExcepciónException CondiciónCondition Iniciada porThrown by
ArgumentNullException value es null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length, o count es menor que cero.startIndex,length, or count is less than zero.

O bien-or-

La suma de startIndex y length es mayor que el número de elementos de value.The sum of startIndex and length is greater than the number of elements in value.

O bien-or-

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

String(Char[], Int32, Int32)

Presentamos una lista de excepciones producidas por los constructores que incluyen los parámetros de puntero.Here's a list of exceptions thrown by constructors that include pointer parameters.

ExcepciónException CondiciónCondition Iniciada porThrown by
ArgumentException value Especifica una matriz que contiene un carácter Unicode no válido.value specifies an array that contains an invalid Unicode character.

O bien-or-

value o value + startIndex especifica una dirección que es menor que 64 KB.value or value + startIndex specifies an address that is less than 64K.

O bien-or-

Un nuevo String no se pudo inicializar la instancia de la value matriz de bytes porque value no utiliza la codificación de página de código de forma predeterminada.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
Todos los constructores con punteros.All constructors with pointers.
ArgumentNullException value es null.value is 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.The current process does not have read access to all the addressed characters.

O bien-or-

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.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.

O bien-or-

La longitud de la nueva cadena es demasiado grande para asignar.The length of the new string is too large to allocate.
Todos los constructores con punteros.All constructors with pointers.
AccessViolationException value, o value + startIndex + length -1, especifica una dirección no válida.value, or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

¿Qué método se debe llamar?Which method do I call?

EnTo Llamada o useCall or use
Crear una cadena.Create a string. Asignación de un literal de cadena o una cadena existente (ejemplo)Assignment from a string literal or an existing string (example)
Crear una cadena de una matriz de caracteres completa.Create a string from an entire character array. String(Char[]) (ejemplo)String(Char[]) (example)
Crear una cadena de una parte de una matriz de caracteres.Create a string from a portion of a character array. String(Char[], Int32, Int32) (ejemplo)String(Char[], Int32, Int32) (example)
Crear una cadena que se repite el mismo carácter varias veces.Create a string that repeats the same character multiple times. String(Char, Int32) (ejemplo)String(Char, Int32) (example)
Cree una cadena de un puntero a una matriz de caracteres anchos o Unicode.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Crear una cadena de una parte de una matriz de caracteres anchos o Unicode mediante su puntero.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
Crear una cadena de C++ char matriz.Create a string from a C++ char array. String(SByte*), String(SByte*, Int32, Int32)String(SByte*), String(SByte*, Int32, Int32)

O bien-or-

String(SByte*, Int32, Int32, Encoding)
Crear una cadena de caracteres ASCII.Create a string from ASCII characters. ASCIIEncoding.GetString

Creación de cadenasCreating strings

Las más usadas técnica para crear cadenas mediante programación es una asignación simple, como se muestra en en este ejemplo.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. La String clase también incluye cuatro tipos de sobrecargas del constructor que le permite crear cadenas a partir de los valores siguientes:The String class also includes four types of constructor overloads that let you create strings from the following values:

  • Desde una matriz de caracteres (una matriz de caracteres con codificación UTF-16).From a character array (an array of UTF-16-encoded characters). Puede crear un nuevo String objeto a partir de los caracteres en toda la matriz o una parte de ella.You can create a new String object from the characters in the entire array or a portion of it. El String(Char[]) constructor copia todos los caracteres de la matriz a la nueva cadena.The String(Char[]) constructor copies all the characters in the array to the new string. El String(Char[], Int32, Int32) constructor copia los caracteres de índice startIndex al índice startIndex + length -1 a la nueva cadena.The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length - 1 to the new string. Si length es cero, el valor de la nueva cadena es String.Empty.If length is zero, the value of the new string is String.Empty.

    Si el código varias veces crea instancias de cadenas que tienen el mismo valor, puede mejorar el rendimiento de la aplicación mediante el uso de medios alternativos para creación de cadenas.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 obtener más información, consulte controlar cadenas repetitivas.For more information, see Handling repetitive strings.

  • Desde un único carácter que es duplicado cero, uno, o más veces, mediante el uso de la String(Char, Int32) constructor.From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Si count es cero, el valor de la nueva cadena es String.Empty.If count is zero, the value of the new string is String.Empty.

  • De un puntero a una matriz de caracteres terminada en null, usando la String(Char*) o String(Char*, Int32, Int32) constructor.From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. Toda la matriz o un intervalo especificado se puede usar para inicializar la cadena.Either the entire array or a specified range can be used to initialize the string. El constructor copia una secuencia de caracteres Unicode a partir del puntero especificado o desde el puntero especificado más startIndex y continuando hasta el final de la matriz o 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. Si value es un puntero nulo o length es cero, el constructor crea una cadena cuyo valor es String.Empty.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Si la operación de copia se ejecuta hasta el final de la matriz y la matriz no está terminada en null, el comportamiento del constructor es dependiente del 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. Esta condición podría provocar una infracción de acceso.Such a condition might cause an access violation.

    Si la matriz contiene los caracteres nulos incrustados (u+0000 o '\0') y el String(Char*, Int32, Int32) es llamar a la sobrecarga, la instancia de cadena contiene length las incluidas de caracteres nulos incrustados.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. El ejemplo siguiente muestra lo que sucede cuando se pasa un puntero a una matriz de 10 elementos que incluye dos caracteres null a la 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. Dado que la dirección es el principio de la matriz y todos los elementos de la matriz son que se agregarán a la cadena, el constructor crea una instancia de una cadena con diez caracteres, incluidos los dos valores null incrustados.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 otro lado, si la misma matriz se pasa a la String(Char*) constructor, el resultado es una cadena de cuatro caracteres que no incluye el primer carácter 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
    

    La matriz debe contener caracteres Unicode.The array must contain Unicode characters. En C++, esto significa que la matriz de caracteres debe estar definida como el administrado Chartipo [] o no administradowchar_ttipo [].In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    Si el String(Char*) es llamar a la sobrecarga y la matriz no está terminada en null, o si el String(Char*, Int32, Int32) es llamar a la sobrecarga y startIndex + length-1 incluye un intervalo que lo 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.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. Además, en el procesador Intel Itanium, las llamadas a la String(Char*, Int32, Int32) constructor puede producir un DataMisalignedException excepción.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. Si esto ocurre, llame a la String(Char[], Int32, Int32) en su lugar.If this occurs, call the String(Char[], Int32, Int32) instead.

  • De un puntero a una matriz de bytes con signo.From a pointer to a signed byte array. Toda la matriz o un intervalo especificado se puede usar para inicializar la cadena.Either the entire array or a specified range can be used to initialize the string. Se puede interpretar la secuencia de bytes mediante el uso de la página de códigos predeterminada de codificación o una codificación puede especificarse en la llamada al constructor.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. Si el constructor intenta crear una instancia de una cadena a partir de toda una matriz que no está terminada en null, o si el intervalo de la matriz de value + startIndex a value + startIndex + length -1 está fuera de la memoria asignada para la matriz, el comportamiento de este constructor es dependiente del sistema y puede producirse una infracción de acceso.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.

    Los tres constructores que incluyen una matriz de bytes con signo como un parámetro están diseñados principalmente para convertir un C++ char de matriz en una cadena, como se muestra en este ejemplo: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
    

    Si la matriz contiene caracteres nulos ('\0') o bytes cuyo valor es 0 y el String(SByte*, Int32, Int32) es llamar a la sobrecarga, la instancia de cadena contiene length las incluidas de caracteres nulos incrustados.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. El ejemplo siguiente muestra lo que sucede cuando se pasa un puntero a una matriz de 10 elementos que incluye dos caracteres null a la 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. Dado que la dirección es el principio de la matriz y todos los elementos de la matriz son que se agregarán a la cadena, el constructor crea una instancia de una cadena con diez caracteres, incluidos los dos valores null incrustados.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 otro lado, si la misma matriz se pasa a la String(SByte*) constructor, el resultado es una cadena de cuatro caracteres que no incluye el primer carácter 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
    

    Dado que el String(SByte*) y String(SByte*, Int32, Int32) constructores interpretan value mediante el uso de la página de códigos ANSI predeterminada, una llamada a estos constructores con matrices de bytes idéntica puede crear las cadenas que tienen valores diferentes en distintos sistemas.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.

Controlar cadenas repetitivasHandling repetitive strings

Las aplicaciones que analizan o descodifican secuencias de texto a menudo usan el String(Char[], Int32, Int32) constructor o StringBuilder.Append(Char[], Int32, Int32) método para convertir las secuencias de caracteres en una cadena.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. Creación de cadenas a varias veces con el mismo valor en lugar de crear y reutilizar una cadena, desperdicia memoria.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Si es probable que la creación de varias veces el mismo valor de cadena mediante una llamada a la String(Char[], Int32, Int32) anticipo de constructor, incluso si no sabe en cuál pueden ser esos valores de cadena idéntica, puede usar una tabla de búsqueda en su lugar.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 ejemplo, supongamos que lee y analizar un flujo de caracteres de un archivo que contiene los atributos y etiquetas XML.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. Cuando se analiza el flujo, varias veces encontrar ciertos tokens (es decir, secuencias de caracteres que tienen un significado simbólico).When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). Los tokens equivalentes a las cadenas "0", "1", "true" y "false" están probables que se producen con frecuencia en una secuencia XML.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

En lugar de convertir cada token en una nueva cadena, puede crear un System.Xml.NameTable objeto para mantener las cadenas más frecuentes.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. La NameTable objeto mejora el rendimiento, ya que recupera cadenas almacenadas sin asignar memoria temporal.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Si se produce un token, utilice el NameTable.Get(Char[], Int32, Int32) método para recuperar el token de la tabla.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. Si el token no existe, el método devuelve la cadena correspondiente.If the token exists, the method returns the corresponding string. Si el token no existe, use el NameTable.Add(Char[], Int32, Int32) método para insertar el testigo en la tabla y para obtener la cadena correspondiente.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.

Ejemplo 1: Uso de la asignación de cadenaExample 1: Using string assignment

El ejemplo siguiente crea una nueva cadena mediante la asignación de un literal de cadena.The following example creates a new string by assigning it a string literal. Crea una segunda cadena asignando el valor de la primera cadena a él.It creates a second string by assigning the value of the first string to it. Estas son las dos formas más comunes para crear una nueva instancia 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.

Ejemplo 2: Uso de una matriz de caracteresExample 2: Using a character array

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

Ejemplo 3: Con una parte de una matriz de caracteres y un único carácter de repeticiónExample 3: Using a portion of a character array and repeating a single character

En el ejemplo siguiente se muestra cómo crear un nuevo String una parte de una matriz de caracteres y cómo crear un nuevo objeto String objeto que contiene varias apariciones de un único carácter.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)

Ejemplo 4: Mediante un puntero a una matriz de caracteresExample 4: Using a pointer to a character array

En el ejemplo siguiente se muestra cómo crear un nuevo String objeto de un puntero a una matriz de caracteres.The following example demonstrates how to create a new String object from a pointer to an array of characters. El ejemplo de C# debe compilarse con la /unsafe modificador del 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!

Ejemplo 5: Crear una instancia de una cadena a partir de un puntero y un intervalo de una matrizExample 5: Instantiating a string from a pointer and a range of an array

El ejemplo siguiente examina los elementos de una matriz de caracteres para un punto o un signo de exclamación.The following example examines the elements of a character array for either a period or an exclamation point. Si encuentra uno, crea una instancia de una cadena de caracteres de la matriz que preceden a los símbolos de puntuación.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. Si no es así, crea una instancia de una cadena con todo el contenido de la matriz.If not, it instantiates a string with the entire contents of the array. El ejemplo de C# debe compilarse con la /unsafe modificador del 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

Ejemplo 6: Crear una instancia de una cadena de un puntero a una matriz de bytes con signoExample 6: Instantiating a string from a pointer to a signed byte array

El ejemplo siguiente muestra cómo puede crear una instancia de la String clase con el String(SByte*) constructor.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") );
}

Información de versiónVersion information

.NET Framework.NET Framework
Todas las sobrecargas se admiten en: 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 las sobrecargas se admiten en: 4, 3.5 SP1All overloads are supported in: 4, 3.5 SP1

Biblioteca de clases portablePortable Class Library
Todas las sobrecargas sin un SByte * se admiten el parámetroAll overloads without an SByte* parameter are supported

.NET para aplicaciones de la Tienda Windows.NET for Windows Store apps
Todas las sobrecargas sin un SByte * parámetro se admite en: Windows 8All overloads without an SByte* parameter are supported in: Windows 8

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

Importante

Esta API no es conforme a CLS.

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero especificado que apunta a una 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*

Puntero a una matriz de caracteres Unicode terminada en null.A pointer to a null-terminated array of Unicode characters.

Excepciones

El proceso actual no tiene acceso de lectura a todos los caracteres tratados.The current process does not have read access to all the addressed characters.

value especifica una matriz que contiene un carácter Unicode no válido o value especifica una dirección menor que 64000.value specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Seguridad

SecurityCriticalAttribute
requiere plena confianza para el llamador inmediato.requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

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

Inicializa una nueva instancia de la clase String en el valor indicado por una 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[]

Matriz de caracteres Unicode.An array of Unicode characters.

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

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(SByte*) String(SByte*) String(SByte*)

Importante

Esta API no es conforme a CLS.

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo.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*

Puntero a una matriz terminada en null de enteros de 8 bits con signo.A pointer to a null-terminated array of 8-bit signed integers. Los números enteros se interpretan utilizando la codificación actual para páginas de códigos de sistema (es decir, la codificación especificada por Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Excepciones

No se ha podido inicializar una nueva instancia de String mediante value, suponiendo que value se ha codificado en ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

La longitud de la nueva cadena a inicializar, que viene determinada por el carácter de terminación null de value, es demasiado grande para asignar.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 una dirección no válida.value specifies an invalid address.

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Seguridad

SecurityCriticalAttribute
requiere plena confianza para el llamador inmediato.requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

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

Inicializa una nueva instancia de la clase String con el valor indicado por un carácter Unicode especificado que se repite un número de veces determinado.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

Carácter Unicode.A Unicode character.

count
Int32 Int32 Int32 Int32

Número de veces que se presenta el parámetro c.The number of times c occurs.

Excepciones

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.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 no es conforme a CLS.

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero especificado que apunta a una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud.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*

Puntero a una matriz de caracteres Unicode.A pointer to an array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Posición inicial de value.The starting position within value.

length
Int32 Int32 Int32 Int32

Número de caracteres de value que se van a usar.The number of characters within value to use.

Excepciones

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.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 una matriz que contiene un carácter Unicode no válido, o value + startIndex especifica una dirección menor que 64000.value specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Seguridad

SecurityCriticalAttribute
requiere plena confianza para el llamador inmediato.requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.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 una nueva instancia de la clase String con el valor indicado por una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud.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[]

Matriz de caracteres Unicode.An array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Posición inicial de value.The starting position within value.

length
Int32 Int32 Int32 Int32

Número de caracteres de value que se van a usar.The number of characters within value to use.

Excepciones

startIndex o length es menor que cero.startIndex or length is less than zero.

O bien-or- La suma de startIndex y length es mayor que el número de elementos de value.The sum of startIndex and length is greater than the number of elements in value.

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

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

Importante

Esta API no es conforme a CLS.

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo especificado, una posición inicial dentro de dicha matriz y una longitud.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*

Puntero a una matriz de enteros de 8 bits con signo.A pointer to an array of 8-bit signed integers. Los números enteros se interpretan utilizando la codificación actual para páginas de códigos de sistema (es decir, la codificación 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

Posición inicial de value.The starting position within value.

length
Int32 Int32 Int32 Int32

Número de caracteres de value que se van a usar.The number of characters within value to use.

Excepciones

startIndex o length es menor que cero.startIndex or length is less than zero.

O bien-or- La dirección especificada por value + startIndex es demasiado grande para la plataforma actual, es decir, se ha desbordado el cálculo de la dirección.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

O bien-or- La longitud de la nueva cadena que se va a inicializar es demasiado grande para asignarla.The length of the new string to initialize is too large to allocate.

La dirección especificada por value + startIndex es inferior a 64 000.The address specified by value + startIndex is less than 64K.

O bien-or- No se ha podido inicializar una nueva instancia de String mediante value, suponiendo que value se ha codificado en ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndex y length colectivamente especifican una dirección no válida.value, startIndex, and length collectively specify an invalid address.

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Seguridad

SecurityCriticalAttribute
requiere plena confianza para el llamador inmediato.requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.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 no es conforme a CLS.

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo especificado, una posición inicial dentro de dicha matriz, una longitud y un 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*

Puntero a una matriz de enteros de 8 bits con signo.A pointer to an array of 8-bit signed integers.

startIndex
Int32 Int32 Int32 Int32

Posición inicial de value.The starting position within value.

length
Int32 Int32 Int32 Int32

Número de caracteres de value que se van a usar.The number of characters within value to use.

enc
Encoding Encoding Encoding Encoding

Un objeto que especifica la forma en que se codifica la matriz a la que value hace referencia.An object that specifies how the array referenced by value is encoded. Si el valor de enc es null, se supone que se trata de la codificación ANSI.If enc is null, ANSI encoding is assumed.

Excepciones

startIndex o length es menor que cero.startIndex or length is less than zero.

O bien-or- La dirección especificada por value + startIndex es demasiado grande para la plataforma actual, es decir, se ha desbordado el cálculo de la dirección.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

O bien-or- La longitud de la nueva cadena que se va a inicializar es demasiado grande para asignarla.The length of the new string to initialize is too large to allocate.

La dirección especificada por value + startIndex es inferior a 64 000.The address specified by value + startIndex is less than 64K.

O bien-or- No se ha podido inicializar una nueva instancia de String mediante value, suponiendo que value se ha codificado según lo especificado por enc.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex y length colectivamente especifican una dirección no válida.value, startIndex, and length collectively specify an invalid address.

Comentarios

Nota

Para obtener ejemplos y la información de uso completa sobre esta y otras String sobrecargas de constructor, vea el String resumen del constructor.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Seguridad

SecurityCriticalAttribute
requiere plena confianza para el llamador inmediato.requires full trust for the immediate caller. Este miembro no se puede usar código de confianza parcial o transparente.This member cannot be used by partially trusted or transparent code.

Se aplica a