String Konstruktory

Definice

Inicializuje novou instanci třídy String.Initializes a new instance of the String class.

Přetížení

String(Char*)

Inicializuje novou instanci třídy String 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[])

Inicializuje novou instanci třídy String do znaků Unicode uvedených v zadaném poli znaků.Initializes a new instance of the String class to the Unicode characters indicated in the specified character array.

String(ReadOnlySpan<Char>)

Inicializuje novou instanci třídy String do znaků Unicode uvedených v zadaném rozsahu jen pro čtení.Initializes a new instance of the String class to the Unicode characters indicated in the specified read-only span.

String(SByte*)

Inicializuje novou instanci třídy String 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)

Inicializuje novou instanci třídy String na hodnotu určenou zadaným znakem Unicode, která se opakuje po zadaném počtu 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)

Inicializuje novou instanci třídy String 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)

Inicializuje novou instanci třídy String 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)

Inicializuje novou instanci třídy String 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)

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

Poznámky

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

Přetížená syntaxe konstruktoru Overloaded constructor syntax
parametrůParameters
výjimekExceptions
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 počínaje indexem 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é 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 počínaje z umístění určeného ukazatelem, dokud není dosaženo znaku null (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é 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 z hodnoty počínaje startIndex 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é celé číslo se znaménkem, počáteční pozice v rámci tohoto pole, délku a objekt Encoding.(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

Tady 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 TypType 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ího 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ů v 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 je count 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 TypType 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 je value null nebo prázdné pole, hodnota nového řetězce je String.Empty.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 je pole value 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ému.Default 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 value je null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex, length nebo count je menší než nula.startIndex,length, or count is less than zero.

-nebo--or-

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

-nebo--or-

count je 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 value určuje pole, které obsahuje neplatný znak Unicode.value specifies an array that contains an invalid Unicode character.

-nebo--or-

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

-nebo--or-

Novou instanci String nebylo možné inicializovat z pole value 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 value je 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-

startIndex nebo length je menší než nula, value startIndex + nezpůsobí přetečení ukazatele, nebo aktuální proces nemá přístup pro čtení ke všem adresám, které se na něj odkazuje.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 nebo value + startIndex + length-1 určuje neplatnou adresu.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 pole C++ char.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. Třída String 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ý objekt String 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. Konstruktor String(Char[]) 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. Konstruktor String(Char[], Int32, Int32) kopíruje znaky z indexu startIndex do indexu startIndex + length-1 do nového řetězce.The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length - 1 to the new string. Pokud je length 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í konstruktoru String(Char, Int32).From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Pokud je count 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í konstruktoru String(Char*) 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 nebo pro length znaky.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 je value ukazatel s hodnotou null nebo je length 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 je volána String(Char*, Int32, Int32) 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ž ukazatel na pole 10 prvků, který obsahuje dva znaky null, je předán metodě String(Char*, Int32, Int32).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 stejné pole předáno konstruktoru String(Char*), 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 ManagedChar[], nebo jako nespravovanýwchar_t[].In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    Pokud je zavolána přetížení String(Char*) a pole není ukončeno hodnotou null, nebo pokud je volána String(Char*, Int32, Int32) přetížení a startIndex + length-1, zahrnuje rozsah, který je mimo paměť přidělenou sekvenci znaků. , 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í konstruktoru String(Char*, Int32, Int32) mohou vyvolat výjimku DataMisalignedException.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 místo toho String(Char[], Int32, Int32).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, které není zakončené hodnotou null, nebo pokud rozsah pole z value + startIndex na value + startIndex + length-1 je mimo paměť pro pole přidělené, 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řevedení 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 je volána String(SByte*, Int32, Int32) 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ž ukazatel na pole 10 prvků, který obsahuje dva znaky null, je předán metodě String(SByte*, Int32, Int32).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 stejné pole předáno konstruktoru String(SByte*), 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 tomu, že konstruktory String(SByte*) a String(SByte*, Int32, Int32) 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 často používají konstruktor String(Char[], Int32, Int32) nebo metodu StringBuilder.Append(Char[], Int32, Int32) k převodu posloupnosti 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 konstruktoru String(Char[], Int32, Int32), 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řevedení každého tokenu na nový řetězec můžete vytvořit objekt System.Xml.NameTable, který bude uchovávat č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. Objekt NameTable 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 metodu NameTable.Get(Char[], Int32, Int32) 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 metodu NameTable.Add(Char[], Int32, Int32) 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ězceExample 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 objektu String.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ý objekt String 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ý objekt String z části pole znaků a jak vytvořit nový objekt String, 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ý objekt String 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 kompilován pomocí přepínače kompilátoru /unsafe.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í přepínače kompilátoru /unsafe.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 třídy String pomocí konstruktoru String(SByte*).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
Verze s podporou všech přetíž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

Profil klienta rozhraní .NET Framework.NET Framework Client Profile
Verze s podporou všech přetížení: 4, 3.5 SP1All overloads are supported in: 4, 3.5 SP1

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

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

String(Char*)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci třídy String 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.

Atributy

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.

value určuje pole, které obsahuje neplatný znak Unicode, nebo value Určuje adresu 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 přetížení konstruktoru String naleznete v souhrnu String 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[])

Inicializuje novou instanci třídy String do znaků Unicode uvedených v zadaném poli znaků.Initializes a new instance of the String class to the Unicode characters indicated in the specified character array.

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 přetížení konstruktoru String naleznete v souhrnu String konstruktoru.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(ReadOnlySpan<Char>)

Inicializuje novou instanci třídy String do znaků Unicode uvedených v zadaném rozsahu jen pro čtení.Initializes a new instance of the String class to the Unicode characters indicated in the specified read-only span.

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

Parametry

value
ReadOnlySpan<Char>

Rozsah znaků Unicode, který je jen pro čtení.A read-only span of Unicode characters.

String(SByte*)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci třídy String 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 Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Atributy

Výjimky

value je null.value is null.

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

Délka nového řetězce, který má být inicializován, který je určen koncovým znakem null value, 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.

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

Poznámky

Poznámka

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

Inicializuje novou instanci třídy String na hodnotu určenou zadaným znakem Unicode, která se opakuje po zadaném počtu 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

Znak kódování UnicodeA Unicode character.

count
Int32

Počet pokusů c.The number of times c occurs.

Výjimky

count je menší než nula.count is less than zero.

Poznámky

Poznámka

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

String(Char*, Int32, Int32)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci třídy String 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

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

length
Int32

Počet znaků v value, které se mají použít.The number of characters within value to use.

Atributy

Výjimky

startIndex nebo length je menší než nula, value startIndex + nezpůsobí přetečení ukazatele, nebo aktuální proces nemá přístup pro čtení ke všem adresám, které se na něj odkazuje.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 určuje pole, které obsahuje neplatný znak Unicode, nebo value + startIndex Určuje adresu 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 přetížení konstruktoru String naleznete v souhrnu String 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)

Inicializuje novou instanci třídy String 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

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

length
Int32

Počet znaků v value, které se mají použít.The number of characters within value to use.

Výjimky

value je null.value is null.

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

-nebo--or- Součet startIndex a length je větší než počet elementů v value.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 přetížení konstruktoru String naleznete v souhrnu String konstruktoru.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(SByte*, Int32, Int32)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci třídy String 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 Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32

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

length
Int32

Počet znaků v value, které se mají použít.The number of characters within value to use.

Atributy

Výjimky

value je null.value is null.

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

-nebo--or- Adresa zadaná v value + startIndex je pro aktuální platformu moc velká. To znamená, že došlo k přetečení výpočtu adres.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á v value + startIndex je menší než 64 KB.The address specified by value + startIndex is less than 64K.

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

value, startIndex a length souhrnně zadejte 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 přetížení konstruktoru String naleznete v souhrnu String 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)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

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

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

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

length
Int32

Počet znaků v value, které se mají použít.The number of characters within value to use.

enc
Encoding

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

Atributy

Výjimky

value je null.value is null.

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

-nebo--or- Adresa zadaná v value + startIndex je pro aktuální platformu moc velká. To znamená, že došlo k přetečení výpočtu adres.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á v value + startIndex je menší než 64 KB.The address specified by value + startIndex is less than 64K.

-nebo--or- Novou instanci String nebylo možné inicializovat pomocí value, předpokladem, že value je kódována podle enc.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex a length souhrnně zadejte 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 přetížení konstruktoru String naleznete v souhrnu String 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