String String String String Constructors

Definice

Přetížení

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

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole znaků 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[])

Inicializuje novou instanci String třídy na hodnotu určenou polem znaků 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*)

Inicializuje novou instanci String třídy na hodnotu určenou ukazatelem na pole 8bitových celých čísel se znaménkem.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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným znakem Unicode a opakuje zadaný počet opakování.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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole znaků Unicode, počáteční pozici znaku v tomto poli a délku.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)

Inicializuje novou instanci String třídy na hodnotu určenou polem znaků Unicode, počáteční polohou znaku v tomto poli a délkou.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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitové celé číslo se znaménkem, počáteční pozice v tomto poli a délku.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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitových celých čísel se znaménkem, počáteční pozice v tomto poli, délka Encoding a objekt.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.

Poznámky

V této části:In this section:

Syntaxe přetíženého konstruktoru Overloaded constructor syntax
Ukazatelů Parameters
Výjimek Exceptions
Kterou metodu můžu zavolat? Which method do I call?
Vytváření řetězců Creating strings
Zpracování opakovaných řetězců Handling repetitive strings
Příklady řetězců vytváření instancí:Examples of instantiating strings:
Použití přiřazení řetězcůUsing string assignment
Použití pole znakůUsing a character array
Použití části pole znaků a opakování jednoho znakuUsing a portion of a character array and repeating a single character
Použití ukazatele na pole znakůUsing a pointer to a character array
Použití ukazatele a rozsahu poleUsing a pointer and a range of an array
Použití ukazatele na podepsané bajtové poleUsing a pointer to a signed byte array
Informace o verziVersion information

Syntaxe přetíženého konstruktoruOverloaded constructor syntax

Konstruktory řetězců spadají do dvou kategorií: ty bez parametrů ukazatele a ty s parametry ukazatele.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. Konstruktory, které používají ukazatele, nejsou kompatibilní se specifikací CLS.The constructors that use pointers are not CLS-compliant. Kromě toho Visual Basic nepodporuje použití ukazatelů a C# vyžaduje kód, který používá ukazatele ke spuštění v nezabezpečeném kontextu.In addition, Visual Basic does not support the use of pointers, and C# requires code that uses pointers to run in an unsafe context. Další informace najdete v tématu unsafe.For more information, see unsafe.

Další pokyny k výběru přetížení najdete v tématu kterou metodu můžu zavolat?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
Inicializuje novou instanci na hodnotu určenou polem znaků Unicode.Initializes the new instance to the value indicated by an array of Unicode characters. Tento konstruktor kopíruje znaky Unicode (příklad).This constructor copies Unicode characters(example).

String(Char[] value, Int32 startIndex, Int32 length)
Inicializuje novou instanci na hodnotu určenou polem znaků Unicode, počáteční polohou znaku v tomto poli a délkou (například).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)
Inicializuje novou instanci na hodnotu určenou zadaným znakem Unicode a opakuje zadaný počet opakování (příklad).Initializes the new instance to the value indicated by a specified Unicode character repeated a specified number of times (example).

String(char* value)
(Není kompatibilní se specifikací CLS) Inicializuje novou instanci na hodnotu určenou ukazatelem na pole znaků Unicode, které je ukončeno znakem null (U + 0000 nebo \ 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'). (příklad).(example).

Oprávnění: SecurityCriticalAttribute, vyžaduje úplný vztah důvěryhodnosti pro bezprostředního volajícího.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

String(char* value, Int32 startIndex, Int32 length)
(Není kompatibilní se specifikací CLS) Inicializuje novou instanci na hodnotu určenou ukazatelem na pole znaků Unicode, počáteční pozici znaku v tomto poli a délku.(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. Konstruktor kopíruje znaky Unicode z value začínajících na index startIndex a končí na indexu startIndex + length -1 (příklad).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Oprávnění: SecurityCriticalAttribute, vyžaduje úplný vztah důvěryhodnosti pro bezprostředního volajícího.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(Není kompatibilní se specifikací CLS) Inicializuje novou instanci na hodnotu určenou ukazatelem na pole 8bitových celých čísel se znaménkem.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. Předpokládá se, že pole představuje řetězec kódovaný pomocí aktuální systémové znakové stránky (to znamená kódování určené parametrem 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). Konstruktor zpracovává znaky od value umístění určeného ukazatelem, dokud není dosažen znak null (0x00) (příklad).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

Oprávnění: SecurityCriticalAttribute, vyžaduje úplný vztah důvěryhodnosti pro bezprostředního volajícího.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length)
(Není kompatibilní se specifikací CLS) Inicializuje novou instanci na hodnotu určenou ukazatelem na pole 8bitové celé číslo se znaménkem, počáteční pozice v tomto poli a délku.(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. Předpokládá se, že pole představuje řetězec kódovaný pomocí aktuální systémové znakové stránky (to znamená kódování určené parametrem 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). Konstruktor zpracovává znaky startIndex z hodnoty počínaje a končící na + startIndex length -1 (příklad).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Oprávnění: SecurityCriticalAttribute, vyžaduje úplný vztah důvěryhodnosti pro bezprostředního volajícího.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Není kompatibilní se specifikací CLS) Inicializuje novou instanci na hodnotu určenou ukazatelem na pole 8bitových celých čísel se znaménkem, počáteční pozice v rámci tohoto pole, délka a Encoding objekt.(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.

Oprávnění: SecurityCriticalAttribute, vyžaduje úplný vztah důvěryhodnosti pro bezprostředního volajícího.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

ParametryParameters

Zde je úplný seznam parametrů používaných String konstruktory, které nezahrnují parametr ukazatele.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Parametry, které používají jednotlivá přetížení, naleznete v předchozí syntaxi přetížení.For the parameters used by each overload, see the overload syntax above.

ParametrParameter typeType PopisDescription
value Char[]Char[] Pole znaků Unicode.An array of Unicode characters.
c Char Znak kódování UnicodeA Unicode character.
startIndex Int32 Počáteční pozice v value prvním znaku v novém řetězci.The starting position in value of the first character in the new string.

Výchozí hodnota: 0Default value: 0
length Int32 Počet znaků value , které mají být zahrnuty do nového řetězce.The number of characters in value to include in the new string.

Výchozí hodnota:Array.LengthDefault value: Array.Length
count Int32 Počet opakování znaku c v novém řetězci.The number of times the character c is repeated in the new string. Pokud count je nula, hodnota nového objektu je String.Empty.If count is zero, the value of the new object is String.Empty.

Zde je úplný seznam parametrů používaných String konstruktory, které obsahují parametr ukazatele.Here is a complete list of parameters used by String constructors that include a pointer parameter. Parametry, které používají jednotlivá přetížení, naleznete v předchozí syntaxi přetížení.For the parameters used by each overload, see the overload syntax above.

ParametrParameter typeType PopisDescription
value Char*

-nebo--or-

SByte*
Ukazatel na pole zakončené znakem null znaků Unicode nebo pole se znaménkem 8bitové hodnoty se znaménkem.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. Pokud value String.Emptyje null nebo prázdné pole, hodnota nového řetězce je.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 Index prvku pole, který definuje první znak v novém řetězci.The index of the array element that defines the first character in the new string.

Výchozí hodnota: 0Default value: 0
length Int32 Počet prvků pole, které mají být použity k vytvoření nového řetězce.The number of array elements to use to create the new string. Pokud je délka nula, vytvoří konstruktor řetězec, jehož hodnota je String.Empty.If length is zero, the constructor creates a string whose value is String.Empty.

Výchozí hodnota:Array.LengthDefault value: Array.Length
enc Encoding Objekt, který určuje, jak value je pole kódováno.An object that specifies how the value array is encoded.

Výchozí hodnota: Encoding.Defaultnebo aktuální znaková stránka ANSI systémuDefault value: Encoding.Default, or the system's current ANSI code page

VýjimkyExceptions

Tady je seznam výjimek vyvolaných konstruktory, které neobsahují parametry ukazatele.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

VýjimkaException PodmínkaCondition VyvolanéThrown by
ArgumentNullException valueje null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length nebocount je menší než nula.startIndex,length, or count is less than zero.

-nebo--or-

Součet startIndex valuea length je větší než počet elementů v.The sum of startIndex and length is greater than the number of elements in value.

-nebo--or-

countje menší než nula.count is less than zero.
String(Char, Int32)

String(Char[], Int32, Int32)

Zde je seznam výjimek vyvolaných konstruktory, které obsahují parametry ukazatele.Here's a list of exceptions thrown by constructors that include pointer parameters.

VýjimkaException PodmínkaCondition VyvolanéThrown by
ArgumentException valueUrčuje pole, které obsahuje neplatný znak Unicode.value specifies an array that contains an invalid Unicode character.

-nebo--or-

valuenebo value Určujeadresu,startIndex která je menší než 64 KB. + value or value + startIndex specifies an address that is less than 64K.

-nebo--or-

Nepodařilo se String inicializovat novou instanci value z pole bajtů, protože value nepoužívá výchozí kódování znakové stránky.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
Všechny konstruktory s odkazy.All constructors with pointers.
ArgumentNullException valuemá hodnotu null.value is null. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException Aktuální proces nemá přístup pro čtení všech adresních znaků.The current process does not have read access to all the addressed characters.

-nebo--or-

startIndexnebo length je menší než nula, value + startIndex způsobí přetečení ukazatele, nebo aktuální proces nemá přístup pro čtení všech adresních znaků.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.

-nebo--or-

Délka nového řetězce je příliš velká pro přidělení.The length of the new string is too large to allocate.
Všechny konstruktory s odkazy.All constructors with pointers.
AccessViolationException value``value nebo -1length určuje neplatnou adresu. + startIndex + value, or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Jakou metodu mám volat?Which method do I call?

Chcete-liTo Zavolat nebo použítCall or use
Vytvořte řetězec.Create a string. Přiřazení z řetězcového literálu nebo existujícího řetězce (příklad)Assignment from a string literal or an existing string (example)
Vytvoří řetězec z celého pole znaků.Create a string from an entire character array. String(Char[])(příklad)String(Char[]) (example)
Vytvoří řetězec z části pole znaků.Create a string from a portion of a character array. String(Char[], Int32, Int32)(příklad)String(Char[], Int32, Int32) (example)
Vytvoří řetězec, který opakuje stejný znak několikrát.Create a string that repeats the same character multiple times. String(Char, Int32)(příklad)String(Char, Int32) (example)
Vytvoří řetězec z ukazatele na pole znaků Unicode nebo roztažitelné.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Vytvořte řetězec z části pole znaků Unicode nebo s velkým počtem znaků pomocí ukazatele.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
Vytvoří řetězec z C++ char pole.Create a string from a C++ char array. String(SByte*), String(SByte*, Int32, Int32)String(SByte*), String(SByte*, Int32, Int32)

-nebo--or-

String(SByte*, Int32, Int32, Encoding)
Vytvoří řetězec ze znaků ASCII.Create a string from ASCII characters. ASCIIEncoding.GetString

Vytváření řetězcůCreating strings

Nejběžněji používaná technika pro vytváření řetězců programově je jednoduché přiřazení, jak je znázorněno v tomto příkladu.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. String Třída také obsahuje čtyři typy přetížení konstruktoru, které umožňují vytvořit řetězce z následujících hodnot:The String class also includes four types of constructor overloads that let you create strings from the following values:

  • Z pole znaků (pole znaků kódovaných ve formátu UTF-16).From a character array (an array of UTF-16-encoded characters). Můžete vytvořit nový String objekt ze znaků v celém poli nebo jeho části.You can create a new String object from the characters in the entire array or a portion of it. String(Char[]) Konstruktor zkopíruje všechny znaky v poli do nového řetězce.The String(Char[]) constructor copies all the characters in the array to the new string. startIndex startIndex + Konstruktor kopíruje znaky z indexu do indexulength -1 do nového řetězce. String(Char[], Int32, Int32)The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length - 1 to the new string. Pokud length je nula, hodnota nového řetězce je String.Empty.If length is zero, the value of the new string is String.Empty.

    Pokud váš kód opakovaně vytvoří instanci řetězců, které mají stejnou hodnotu, můžete zvýšit výkon aplikace pomocí alternativního způsobu vytváření řetězců.If your code repeatedly instantiates strings that have the same value, you can improve application performance by using an alternate means of creating strings. Další informace najdete v tématu zpracování opakujících se řetězců.For more information, see Handling repetitive strings.

  • Z jednoho znaku, který je duplicitní nula, jednou nebo vícekrát, pomocí String(Char, Int32) konstruktoru.From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Pokud count je nula, hodnota nového řetězce je String.Empty.If count is zero, the value of the new string is String.Empty.

  • Z ukazatele na pole znaku zakončeného hodnotou null pomocí String(Char*) konstruktoru nebo. String(Char*, Int32, Int32)From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. Řetězec lze inicializovat pomocí celého pole nebo určeného rozsahu.Either the entire array or a specified range can be used to initialize the string. Konstruktor kopíruje sekvenci znaků Unicode počínaje zadaným ukazatelem nebo ze zadaného ukazatele plus startIndex a pokračuje na konec pole length nebo znaků.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. Pokud value je ukazatel s hodnotou null length nebo nula, vytvoří konstruktor řetězec, jehož hodnota je String.Empty.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Pokud operace kopírování pokračuje na konec pole a pole nemá zakončené znakem null, chování konstruktoru je závislé na systému.If the copy operation proceeds to the end of the array and the array is not null-terminated, the constructor behavior is system-dependent. Taková podmínka může způsobit narušení přístupu.Such a condition might cause an access violation.

    Pokud pole obsahuje všechny vložené znaky null (U + 0000 nebo ' \ 0 ') a String(Char*, Int32, Int32) je zavoláno přetížení, instance řetězce obsahuje length znaky včetně všech vložených hodnot null.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. Následující příklad ukazuje, co se stane, když se do String(Char*, Int32, Int32) metody předává ukazatel na pole 10 prvků, které obsahují dva znaky null.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. Vzhledem k tomu, že adresa je začátek pole a všechny prvky v poli mají být přidány do řetězce, konstruktor vytvoří instanci řetězce s deseti znaky, včetně dvou vložených hodnot null.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. Na druhé straně, pokud je do String(Char*) konstruktoru předáno stejné pole, je výsledkem řetězec se čtyřmi znaky, který nezahrnuje první znak null.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
    

    Pole musí obsahovat znaky Unicode.The array must contain Unicode characters. V C++, to znamená, že pole znaků musí být definováno buď jako typ Managed Char[], nebo nespravovanýwchar_ttyp [].In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    + String(Char*, Int32, Int32) startIndexPokud je voláno lengthpřetížení a pole není ukončeno hodnotou null, nebo pokud je přetížení voláno a-1, zahrnuje rozsah, který je mimo paměť přidělenou sekvenci znaků, String(Char*) chování konstruktoru je závislé na systému a může dojít k narušení přístupu.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. Kromě toho v procesorech Intel Itanium volání String(Char*, Int32, Int32) konstruktoru může DataMisalignedException vyvolat výjimku.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. Pokud k tomu dojde, zavolejte String(Char[], Int32, Int32) místo toho.If this occurs, call the String(Char[], Int32, Int32) instead.

  • Z ukazatele na podepsané bajtové pole.From a pointer to a signed byte array. Řetězec lze inicializovat pomocí celého pole nebo určeného rozsahu.Either the entire array or a specified range can be used to initialize the string. Posloupnost bajtů lze interpretovat pomocí výchozího kódování znakové stránky, nebo je možné zadat kódování ve volání konstruktoru.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. Pokud se konstruktor pokusí vytvořit instanci řetězce z celého pole, value které není zakončené hodnotou null, nebo pokud rozsah pole od do value + startIndex + startIndex + length -1 je mimo paměť přidělenou poli, chování tohoto konstruktoru je závislé na systému a může dojít k narušení přístupu.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.

    Tři konstruktory, které obsahují podepsané bajtové pole jako parametr, jsou navrženy primárně pro převod C++ char pole na řetězec, jak je znázorněno v následujícím příkladu: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
    

    Pokud pole obsahuje jakékoli znaky null (' \ 0 ') nebo bajtů, jejichž hodnota je 0 a String(SByte*, Int32, Int32) je volána přetížení, instance řetězce obsahuje length znaky včetně všech vložených hodnot null.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. Následující příklad ukazuje, co se stane, když se do String(SByte*, Int32, Int32) metody předává ukazatel na pole 10 prvků, které obsahují dva znaky null.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. Vzhledem k tomu, že adresa je začátek pole a všechny prvky v poli mají být přidány do řetězce, konstruktor vytvoří instanci řetězce s deseti znaky, včetně dvou vložených hodnot null.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. Na druhé straně, pokud je do String(SByte*) konstruktoru předáno stejné pole, je výsledkem řetězec se čtyřmi znaky, který nezahrnuje první znak null.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
    

    Vzhledem k String(SByte*) tomu String(SByte*, Int32, Int32) , že konstruktory a interpretují value pomocí výchozí znakové stránky ANSI, volání těchto konstruktorů se stejnými poli bajtů může vytvořit řetězce, které mají různé hodnoty v různých systémech.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.

Zpracování opakujících se řetězcůHandling repetitive strings

Aplikace, které analyzují nebo dekódují proudy textu String(Char[], Int32, Int32) často používají konstruktor StringBuilder.Append(Char[], Int32, Int32) nebo metodu pro převod sekvencí znaků na řetězec.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. Opakované vytváření nových řetězců se stejnou hodnotou namísto vytvoření a opakovaného použití jednoho řetězce odpad paměti.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Pokud je pravděpodobně vhodné vytvořit stejnou řetězcovou hodnotu opakovaně voláním String(Char[], Int32, Int32) konstruktoru, a to i v případě, že ještě nevíte, co stejné řetězcové hodnoty můžou být, můžete místo toho použít vyhledávací tabulku.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.

Předpokládejme například, že si přečtete a analyzujete datový proud znaků ze souboru, který obsahuje značky a atributy XML.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. Při analýze datového proudu opakovaně narazíte na určité tokeny (tj. sekvence znaků, které mají symbolický význam).When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). Tokeny, které jsou ekvivalentní řetězcům "0", "1", "true" a "false", mohou často nastat v datovém proudu XML.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

Místo převádění každého tokenu na nový řetězec můžete vytvořit System.Xml.NameTable objekt, který bude obsahovat často vyskytující se řetězce.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. NameTable Objekt zvyšuje výkon, protože načítá uložené řetězce bez přidělení dočasné paměti.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Když narazíte na token, použijte NameTable.Get(Char[], Int32, Int32) metodu k načtení tokenu z tabulky.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. Pokud token existuje, metoda vrátí odpovídající řetězec.If the token exists, the method returns the corresponding string. Pokud token neexistuje, použijte NameTable.Add(Char[], Int32, Int32) metodu pro vložení tokenu do tabulky a k získání odpovídajícího řetězce.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.

Příklad 1: Použití přiřazení řetězcůExample 1: Using string assignment

Následující příklad vytvoří nový řetězec přiřazením řetězcového literálu.The following example creates a new string by assigning it a string literal. Vytvoří druhý řetězec přiřazením hodnoty prvního řetězce k němu.It creates a second string by assigning the value of the first string to it. Jedná se o dva nejběžnější způsoby vytvoření instance nového String objektu.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.

Příklad 2: Použití pole znakůExample 2: Using a character array

Následující příklad ukazuje, jak vytvořit nový String objekt z pole znaků.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))) 

Příklad 3: Použití části pole znaků a opakování jednoho znakuExample 3: Using a portion of a character array and repeating a single character

Následující příklad ukazuje, jak vytvořit nový String objekt z části pole znaků a jak vytvořit nový String objekt, který obsahuje více výskytů jednoho znaku.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)

Příklad 4: Použití ukazatele na pole znakůExample 4: Using a pointer to a character array

Následující příklad ukazuje, jak vytvořit nový String objekt z ukazatele na pole znaků.The following example demonstrates how to create a new String object from a pointer to an array of characters. C# Příklad musí být zkompilován pomocí /unsafe přepínače kompilátoru.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!

Příklad 5: Vytvoření instance řetězce z ukazatele a rozsahu poleExample 5: Instantiating a string from a pointer and a range of an array

Následující příklad prověřuje prvky pole znaků pro tečku nebo vykřičník.The following example examines the elements of a character array for either a period or an exclamation point. Pokud je nalezen, vytvoří instanci řetězce ze znaků v poli, které předcházejí symbol interpunkce.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. V takovém případě vytvoří instanci řetězce s celým obsahem pole.If not, it instantiates a string with the entire contents of the array. C# Příklad musí být kompilován pomocí /unsafe přepínače kompilátoru.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

Příklad 6: Vytvoření instance řetězce z ukazatele na podepsané bajtové poleExample 6: Instantiating a string from a pointer to a signed byte array

Následující příklad ukazuje, jak lze vytvořit instanci String třídy String(SByte*) s konstruktorem.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") );
}

Informace o verziVersion information

.NET Framework.NET Framework
Všechna přetížení jsou podporovaná v: 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

Profil klienta rozhraní .NET Framework.NET Framework Client Profile
Všechna přetížení jsou podporovaná v: 4, 3.5 SP1All overloads are supported in: 4, 3.5 SP1

Přenosná knihovna třídPortable Class Library
Všechna přetížení bez SByte * parametru jsou podporovaná.All overloads without an SByte* parameter are supported

Aplikace .NET pro Windows Store.NET for Windows Store apps
Všechna přetížení bez SByte * parametru jsou podporovaná v: Windows 8All overloads without an SByte* parameter are supported in: Windows 8

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

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole znaků 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

Parametry

value
Char*

Ukazatel na pole zakončené znakem null znaků Unicode.A pointer to a null-terminated array of Unicode characters.

Výjimky

Aktuální proces nemá přístup pro čtení všech adresních znaků.The current process does not have read access to all the addressed characters.

valueUrčuje pole, které obsahuje neplatný znak Unicode, nebo value adresa je menší než 64000.value specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpečení

SecurityCriticalAttribute
vyžaduje úplný vztah důvěryhodnosti pro bezprostředně volajícího.requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

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

Inicializuje novou instanci String třídy na hodnotu určenou polem znaků 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())

Parametry

value
Char[]

Pole znaků Unicode.An array of Unicode characters.

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.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))

Parametry

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

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci String třídy na hodnotu určenou ukazatelem na pole 8bitových celých čísel se znaménkem.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

Parametry

value
SByte*

Ukazatel na pole zakončené znakem null a 8bitové celé číslo se znaménkem.A pointer to a null-terminated array of 8-bit signed integers. Celá čísla jsou interpretována pomocí aktuálního kódování znakové stránky systému (to znamená kódování určeného parametrem Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Výjimky

String Nebylo možné inicializovat novou instanci pomocí value, předpokládá value se, že je v kódování ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

Délka nového řetězce k inicializaci, který je určen koncovým znakem valuenull, je příliš velký pro přidělení.The length of the new string to initialize, which is determined by the null termination character of value, is too large to allocate.

valueurčuje neplatnou adresu.value specifies an invalid address.

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpečení

SecurityCriticalAttribute
vyžaduje úplný vztah důvěryhodnosti pro bezprostředně volajícího.requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

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

Inicializuje novou instanci String třídy na hodnotu určenou zadaným znakem Unicode a opakuje zadaný počet opakování.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)

Parametry

c
Char Char Char Char

Znak kódování UnicodeA Unicode character.

count
Int32 Int32 Int32 Int32

Počet c výskytů.The number of times c occurs.

Výjimky

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.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)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole znaků Unicode, počáteční pozici znaku v tomto poli a délku.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

Parametry

value
Char*

Ukazatel na pole znaků Unicode.A pointer to an array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Počáteční pozice v rámci value.The starting position within value.

length
Int32 Int32 Int32 Int32

Počet znaků v rámci value , které mají být použity.The number of characters within value to use.

Výjimky

startIndexnebo length je menší než nula, value + startIndex způsobí přetečení ukazatele, nebo aktuální proces nemá přístup pro čtení všech adresních znaků.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.

valueUrčuje pole, které obsahuje neplatný znak Unicode, nebo value + startIndex adresa je menší než 64000.value specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpečení

SecurityCriticalAttribute
vyžaduje úplný vztah důvěryhodnosti pro bezprostředně volajícího.requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.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)

Inicializuje novou instanci String třídy na hodnotu určenou polem znaků Unicode, počáteční polohou znaku v tomto poli a délkou.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)

Parametry

value
Char[]

Pole znaků Unicode.An array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Počáteční pozice v rámci value.The starting position within value.

length
Int32 Int32 Int32 Int32

Počet znaků v rámci value , které mají být použity.The number of characters within value to use.

Výjimky

startIndexnebo length je menší než nula.startIndex or length is less than zero.

-nebo--or- Součet startIndex valuea length je větší než počet elementů v.The sum of startIndex and length is greater than the number of elements in value.

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.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)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitové celé číslo se znaménkem, počáteční pozice v tomto poli a délku.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

Parametry

value
SByte*

Ukazatel na pole 8bitových celých čísel se znaménkem.A pointer to an array of 8-bit signed integers. Celá čísla jsou interpretována pomocí aktuálního kódování znakové stránky systému (to znamená kódování určeného parametrem Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32 Int32 Int32 Int32

Počáteční pozice v rámci value.The starting position within value.

length
Int32 Int32 Int32 Int32

Počet znaků v rámci value , které mají být použity.The number of characters within value to use.

Výjimky

startIndexnebo length je menší než nula.startIndex or length is less than zero.

-nebo--or- Adresa zadaná value + vjeproaktuálníplatformumocvelká;toznamená,žesepřeteklstartIndex výpočet adresy.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

-nebo--or- Délka nového řetězce k inicializaci je příliš velká pro přidělení.The length of the new string to initialize is too large to allocate.

Adresa zadaná value + vrámcijemenšístartIndex než 64 KB.The address specified by value + startIndex is less than 64K.

-nebo--or- String Nebylo možné inicializovat novou instanci pomocí value, předpokládá value se, že je v kódování ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndex alength společně zadat neplatnou adresu.value, startIndex, and length collectively specify an invalid address.

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpečení

SecurityCriticalAttribute
vyžaduje úplný vztah důvěryhodnosti pro bezprostředně volajícího.requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.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)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitových celých čísel se znaménkem, počáteční pozice v tomto poli, délka Encoding a objekt.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

Parametry

value
SByte*

Ukazatel na pole 8bitových celých čísel se znaménkem.A pointer to an array of 8-bit signed integers.

startIndex
Int32 Int32 Int32 Int32

Počáteční pozice v rámci value.The starting position within value.

length
Int32 Int32 Int32 Int32

Počet znaků v rámci value , které mají být použity.The number of characters within value to use.

enc
Encoding Encoding Encoding Encoding

Objekt, který určuje, jak je pole odkazované value v kódování.An object that specifies how the array referenced by value is encoded. V takovém případě enc se předpokládá kódování ANSI. nullIf enc is null, ANSI encoding is assumed.

Výjimky

startIndexnebo length je menší než nula.startIndex or length is less than zero.

-nebo--or- Adresa zadaná value + vjeproaktuálníplatformumocvelká;toznamená,žesepřeteklstartIndex výpočet adresy.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

-nebo--or- Délka nového řetězce k inicializaci je příliš velká pro přidělení.The length of the new string to initialize is too large to allocate.

Adresa zadaná value + vrámcijemenšístartIndex než 64 KB.The address specified by value + startIndex is less than 64K.

-nebo--or- Novou instanci String nelze inicializovat pomocí value, předpokládá value se, že je zakódována jako určena encparametrem.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex alength společně zadat neplatnou adresu.value, startIndex, and length collectively specify an invalid address.

Poznámky

Poznámka

Příklady a komplexní informace o použití tohoto a dalších String přetížení konstruktoru String naleznete v souhrnu konstruktoru.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpečení

SecurityCriticalAttribute
vyžaduje úplný vztah důvěryhodnosti pro bezprostředně volajícího.requires full trust for the immediate caller. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.This member cannot be used by partially trusted or transparent code.

Platí pro