String String String String Constructors

Definicja

Przeciążenia

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

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków 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[])

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez tablicę znaków 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*)

Inicjuje nowe wystąpienie String klasy do wartości wskazywanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem.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)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony znak Unicode powtórzony określoną liczbę razy.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)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków Unicode, początkowej pozycji znaku w tej tablicy i długości.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)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez tablicę znaków Unicode, początkową pozycję znaku w tej tablicy i długość.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)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy i długości.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)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, czyli pozycji początkowej w tej tablicy, długości Encoding i obiektu.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.

Uwagi

W tej sekcji:In this section:

Składnia przeciążonego konstruktora Overloaded constructor syntax
Wejściowe Parameters
Wyłączenia Exceptions
Którą metodę nazywam? Which method do I call?
Tworzenie ciągów Creating strings
Obsługa powtarzających się ciągów Handling repetitive strings
Przykłady tworzenia wystąpień ciągów:Examples of instantiating strings:
Używanie przypisania ciąguUsing string assignment
Korzystanie z tablicy znakówUsing a character array
Użycie części tablicy znaków i powtarzanie pojedynczego znakuUsing a portion of a character array and repeating a single character
Używanie wskaźnika do tablicy znakówUsing a pointer to a character array
Używanie wskaźnika i zakresu tablicyUsing a pointer and a range of an array
Używanie wskaźnika do podpisanej tablicy bajtówUsing a pointer to a signed byte array
Informacje o wersjiVersion information

Przeciążona składnia konstruktoraOverloaded constructor syntax

Konstruktory ciągów dzielą się na dwie kategorie: te bez parametrów wskaźnika i z parametrami wskaźnika.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. Konstruktory używające wskaźników nie są zgodne ze specyfikacją CLS.The constructors that use pointers are not CLS-compliant. Ponadto Visual Basic nie obsługuje użycia wskaźników i C# wymaga kodu, który używa wskaźników do uruchamiania w niebezpiecznym kontekście.In addition, Visual Basic does not support the use of pointers, and C# requires code that uses pointers to run in an unsafe context. Aby uzyskać więcej informacji, niebezpiecznyFor more information, see unsafe.

Aby uzyskać dodatkowe wskazówki dotyczące wybierania przeciążenia, zobacz, która metoda jest wywoływana?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
Inicjuje nowe wystąpienie do wartości wskazanej przez tablicę znaków Unicode.Initializes the new instance to the value indicated by an array of Unicode characters. Ten Konstruktor kopiuje znaki Unicode (przykład).This constructor copies Unicode characters(example).

String(Char[] value, Int32 startIndex, Int32 length)
Inicjuje nowe wystąpienie do wartości wskazanej przez tablicę znaków Unicode, początkową pozycję znaku w tej tablicy i długość (przykład).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)
Inicjuje nowe wystąpienie do wartości wskazanej przez określony znak Unicode powtórzone określoną liczbę razy (przykład).Initializes the new instance to the value indicated by a specified Unicode character repeated a specified number of times (example).

String(char* value)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazywanej przez wskaźnik do tablicy znaków Unicode, która kończy się znakiem null (U + 0000 lub ' \ 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'). (przykład).(example).

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

String(char* value, Int32 startIndex, Int32 length)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazywanej przez wskaźnik do tablicy znaków Unicode, początkowy znak w tej tablicy i długość.(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 kopiuje znaki value Unicode z lokalizacji w indeksie startIndex startIndex i kończąc przy indeksie + length -1 (przykład).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazywanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. Przyjęto, że tablica reprezentuje ciąg zakodowany przy użyciu bieżącej strony kodowej systemu (czyli kodowania określonego przez 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 przetwarza znaki z value lokalizacji określonej przez wskaźnik do momentu osiągnięcia znaku null (0x00) (przykład).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazywanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy i długości.(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. Przyjęto, że tablica reprezentuje ciąg zakodowany przy użyciu bieżącej strony kodowej systemu (czyli kodowania określonego przez 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 przetwarza znaki startIndex z wartości rozpoczynając od i kończąc na + startIndex length -1 (przykład).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazywanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, czyli pozycji początkowej w tej tablicy, długości i Encoding obiektu.(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.

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

ParametryParameters

Poniżej znajduje się kompletna lista parametrów używanych przez String konstruktory, które nie zawierają parametru wskaźnika.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Dla parametrów używanych przez każde przeciążenie, zobacz powyżej temat dotyczący składni przeciążenia.For the parameters used by each overload, see the overload syntax above.

ParametrParameter TypType OpisDescription
value Char[]Char[] Tablica znaków Unicode.An array of Unicode characters.
c Char Znak Unicode.A Unicode character.
startIndex Int32 Pozycja value początkowa pierwszego znaku w nowym ciągu.The starting position in value of the first character in the new string.

Wartość domyślna: 0Default value: 0
length Int32 Liczba znaków w value do uwzględnienia w nowym ciągu.The number of characters in value to include in the new string.

Wartość domyślna:Array.LengthDefault value: Array.Length
count Int32 Liczba powtórzeń znaku c w nowym ciągu.The number of times the character c is repeated in the new string. Jeśli count jest równa zero, wartość nowego obiektu to String.Empty.If count is zero, the value of the new object is String.Empty.

Poniżej znajduje się kompletna lista parametrów używanych przez String konstruktory, które zawierają parametr wskaźnika.Here is a complete list of parameters used by String constructors that include a pointer parameter. Dla parametrów używanych przez każde przeciążenie, zobacz powyżej temat dotyczący składni przeciążenia.For the parameters used by each overload, see the overload syntax above.

ParametrParameter TypType OpisDescription
value Char*

—lub—-or-

SByte*
Wskaźnik do tablicy o wartościach Unicode zakończonych znakiem null lub tablicy 8-bitowych liczb całkowitych ze znakiem.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. Jeśli value jest null lub jest pustą tablicą, wartość nowego ciągu to String.Empty.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 Indeks elementu tablicy, który definiuje pierwszy znak w nowym ciągu.The index of the array element that defines the first character in the new string.

Wartość domyślna: 0Default value: 0
length Int32 Liczba elementów tablicy, które mają zostać użyte do utworzenia nowego ciągu.The number of array elements to use to create the new string. Jeśli długość wynosi zero, Konstruktor tworzy ciąg, którego wartość to String.Empty.If length is zero, the constructor creates a string whose value is String.Empty.

Wartość domyślna:Array.LengthDefault value: Array.Length
enc Encoding Obiekt, który określa sposób value kodowania tablicy.An object that specifies how the value array is encoded.

Wartość domyślna: Encoding.Defaultlub bieżąca strona kodowa ANSI systemuDefault value: Encoding.Default, or the system's current ANSI code page

WyjątkiExceptions

Poniżej znajduje się Lista wyjątków zgłoszonych przez konstruktory, które nie zawierają parametrów wskaźnika.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

WyjątekException WarunekCondition Generowane przezThrown by
ArgumentNullException valuejest null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length, lub count jest mniejsza od zera.startIndex,length, or count is less than zero.

—lub—-or-

Suma startIndex valuei length jest większa niż liczba elementów w.The sum of startIndex and length is greater than the number of elements in value.

—lub—-or-

countjest mniejsza od zera.count is less than zero.
String(Char, Int32)

String(Char[], Int32, Int32)

Poniżej znajduje się Lista wyjątków zgłoszonych przez konstruktory, które zawierają parametry wskaźnika.Here's a list of exceptions thrown by constructors that include pointer parameters.

WyjątekException WarunekCondition Generowane przezThrown by
ArgumentException valueOkreśla tablicę zawierającą nieprawidłowy znak Unicode.value specifies an array that contains an invalid Unicode character.

—lub—-or-

valuelub value określaadres,startIndex który jest mniejszy niż 64 KB. + value or value + startIndex specifies an address that is less than 64K.

—lub—-or-

Nie można String zainicjować nowego wystąpienia value z tablicy bajtowej, ponieważ value nie używa domyślnego kodowania strony kodowej.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
Wszystkie konstruktory ze wskazówkami.All constructors with pointers.
ArgumentNullException valuema wartość null.value is null. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException Bieżący proces nie ma dostępu do odczytu do wszystkich znaków w adresie.The current process does not have read access to all the addressed characters.

—lub—-or-

startIndexlub length jest mniejsza od zera, value + startIndex powoduje przepełnienie wskaźnika lub bieżący proces nie ma dostępu do odczytu do wszystkich znaków.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.

—lub—-or-

Długość nowego ciągu jest zbyt duża, aby można było przydzielić.The length of the new string is too large to allocate.
Wszystkie konstruktory ze wskazówkami.All constructors with pointers.
AccessViolationException value``value lub -1length określa nieprawidłowyadres.startIndex + + value, or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Jaką metodę wywołać?Which method do I call?

ZadanieTo Wywołanie lub użycieCall or use
Utwórz ciąg.Create a string. Przypisanie z literału ciągu lub istniejącego ciągu (przykład)Assignment from a string literal or an existing string (example)
Utwórz ciąg z całej tablicy znaków.Create a string from an entire character array. String(Char[])(przykład)String(Char[]) (example)
Utwórz ciąg z części tablicy znaków.Create a string from a portion of a character array. String(Char[], Int32, Int32)(przykład)String(Char[], Int32, Int32) (example)
Utwórz ciąg powtarzający ten sam znak wielokrotnie.Create a string that repeats the same character multiple times. String(Char, Int32)(przykład)String(Char, Int32) (example)
Utwórz ciąg ze wskaźnika do tablicy znaków Unicode lub szerokiej.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Utwórz ciąg z części tablicy Unicode lub Wide Character przy użyciu jej wskaźnika.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
Utwórz ciąg z C++ char tablicy.Create a string from a C++ char array. String(SByte*), String(SByte*, Int32, Int32)String(SByte*), String(SByte*, Int32, Int32)

—lub—-or-

String(SByte*, Int32, Int32, Encoding)
Utwórz ciąg z znaków ASCII.Create a string from ASCII characters. ASCIIEncoding.GetString

Tworzenie ciągówCreating strings

Najczęściej stosowana technika tworzenia ciągów programistycznych jest prostym przypisaniem, jak pokazano w tym przykładzie.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. String Klasa zawiera również cztery typy przeciążeń konstruktorów, które umożliwiają tworzenie ciągów z następujących wartości:The String class also includes four types of constructor overloads that let you create strings from the following values:

  • Z tablicy znaków (tablica znaków zakodowanych w formacie UTF-16).From a character array (an array of UTF-16-encoded characters). Można utworzyć nowy String obiekt na podstawie znaków w całej tablicy lub jego części.You can create a new String object from the characters in the entire array or a portion of it. String(Char[]) Konstruktor kopiuje wszystkie znaki w tablicy do nowego ciągu.The String(Char[]) constructor copies all the characters in the array to the new string. startIndex startIndex + Konstruktor kopiuje znaki z indeksu do indeksulength -1 do nowego ciągu. 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. Jeśli length jest równa zero, wartość nowego ciągu to String.Empty.If length is zero, the value of the new string is String.Empty.

    Jeśli kod wielokrotnie tworzy wystąpienia ciągów, które mają taką samą wartość, można zwiększyć wydajność aplikacji przy użyciu alternatywnego sposobu tworzenia ciągów.If your code repeatedly instantiates strings that have the same value, you can improve application performance by using an alternate means of creating strings. Aby uzyskać więcej informacji, zobacz Obsługa powtarzających się ciągów.For more information, see Handling repetitive strings.

  • Z pojedynczego znaku, który jest zduplikowany zero, jeden lub więcej razy, za pomocą String(Char, Int32) konstruktora.From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Jeśli count jest równa zero, wartość nowego ciągu to String.Empty.If count is zero, the value of the new string is String.Empty.

  • Ze wskaźnika do tablicy znaków zakończonych znakiem null przy użyciu String(Char*) konstruktora or. String(Char*, Int32, Int32)From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. Do zainicjowania ciągu można wykorzystać macierz w całości lub w określonym zakresie.Either the entire array or a specified range can be used to initialize the string. Konstruktor kopiuje sekwencję znaków Unicode startIndex , rozpoczynając od określonego wskaźnika lub od określonego wskaźnika i i kontynuując do końca tablicy lub dla length znaków.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. Jeśli value jest wskaźnikiem typu null length lub jest zerem, Konstruktor tworzy ciąg, którego wartość to String.Empty.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Jeśli operacja kopiowania przechodzi do końca tablicy, a tablica nie zostanie zakończona null, zachowanie konstruktora jest zależne od systemu.If the copy operation proceeds to the end of the array and the array is not null-terminated, the constructor behavior is system-dependent. Taki warunek może spowodować naruszenie zasad dostępu.Such a condition might cause an access violation.

    Jeśli tablica zawiera wszystkie osadzone znaki null (U + 0000 lub ' \ 0 ') i String(Char*, Int32, Int32) zostanie wywołana metoda przeciążenia, wystąpienie ciągu zawiera length znaki, w tym wszelkie osadzone wartości 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. W poniższym przykładzie pokazano, co się dzieje, gdy wskaźnik do tablicy 10 elementów, który zawiera dwa znaki null, jest przesyłany do String(Char*, Int32, Int32) metody.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. Ponieważ adres jest początkową tablicę, a wszystkie elementy w tablicy są dodawane do ciągu, Konstruktor tworzy wystąpienie ciągu z dziesięć znaków, w tym dwóch osadzonych wartości 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. Z drugiej strony, jeśli ta sama tablica zostanie przekazana do String(Char*) konstruktora, wynik jest ciągiem zawierającym cztery znaki, który nie zawiera pierwszego znaku 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
    

    Tablica musi zawierać znaki Unicode.The array must contain Unicode characters. W C++, oznacza to, że tablica znaków musi być zdefiniowana jako typ zarządzany Char[] lub niezarządzanywchar_ttyp [].In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    length + startIndex String(Char*, Int32, Int32) Jeśli Przeciążenie jest wywołane i tablica nie została zakończona znakiem null lub jeśli Przeciążenie jest wywołane i-1 zawiera zakres, który poza pamięcią przydzieloną dla sekwencji znaków, String(Char*) zachowanie konstruktora jest zależne od systemu i może wystąpić naruszenie zasad dostępu.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. Ponadto w procesorze Intel Itanium wywołania do String(Char*, Int32, Int32) konstruktora mogą DataMisalignedException zgłosić wyjątek.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. W String(Char[], Int32, Int32) takim przypadku Wywołaj zamiast niego.If this occurs, call the String(Char[], Int32, Int32) instead.

  • Ze wskaźnika do podpisanej tablicy bajtów.From a pointer to a signed byte array. Do zainicjowania ciągu można wykorzystać macierz w całości lub w określonym zakresie.Either the entire array or a specified range can be used to initialize the string. Sekwencję bajtów można interpretować przy użyciu domyślnego kodowania strony kodowej lub można określić kodowanie w wywołaniu konstruktora.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. Jeśli Konstruktor próbuje utworzyć wystąpienie ciągu value z całej tablicy, która nie jest zakończona zerem, lub jeśli zakres tablicy od do value + startIndex + startIndex + length -1 jest poza pamięcią przydzieloną dla tablicy, zachowanie tego konstruktora jest zależne od systemu i może wystąpić naruszenie zasad dostępu.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.

    Trzy konstruktory, które zawierają podpisany tablicę bajtową jako parametr, są przeznaczone głównie do C++ char konwersji tablicy na ciąg, jak pokazano w tym przykładzie: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
    

    Jeśli tablica zawiera znaki null (' \ 0 ') lub bajty, których wartość jest równa 0 String(SByte*, Int32, Int32) i zostanie wywołana metoda przeciążenia, wystąpienie ciągu length zawiera znaki, w tym wszelkie osadzone wartości 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. W poniższym przykładzie pokazano, co się dzieje, gdy wskaźnik do tablicy 10 elementów, który zawiera dwa znaki null, jest przesyłany do String(SByte*, Int32, Int32) metody.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. Ponieważ adres jest początkową tablicę, a wszystkie elementy w tablicy są dodawane do ciągu, Konstruktor tworzy wystąpienie ciągu z dziesięć znaków, w tym dwóch osadzonych wartości 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. Z drugiej strony, jeśli ta sama tablica zostanie przekazana do String(SByte*) konstruktora, wynik jest ciągiem zawierającym cztery znaki, który nie zawiera pierwszego znaku 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
    

    Ponieważ konstruktory String(SByte*, Int32, Int32) value i interpretują przy użyciu domyślnej strony kodowej ANSI, wywoływanie tych konstruktorów z identycznymi tablicami bajtowymi może tworzyć ciągi, które mają różne wartości w różnych systemach. String(SByte*)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.

Obsługa powtarzających się ciągówHandling repetitive strings

Aplikacje, które analizują lub dekodowania strumieni tekstu często String(Char[], Int32, Int32) używają konstruktora StringBuilder.Append(Char[], Int32, Int32) lub metody do konwertowania sekwencji znaków na ciąg.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. Wielokrotne tworzenie nowych ciągów o tej samej wartości zamiast tworzenia i ponownego używania jednego ciągu pamięci.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Jeśli prawdopodobnie chcesz wielokrotnie utworzyć tę samą wartość ciągu przez wywołanie String(Char[], Int32, Int32) konstruktora, nawet jeśli nie wiesz, jakie są identyczne wartości ciągu, możesz zamiast tego użyć tabeli odnośników.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.

Załóżmy na przykład, że odczytywanie i analizowanie strumienia znaków z pliku zawierającego Tagi i atrybuty XML.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. Podczas analizowania strumienia często występują pewne tokeny (czyli sekwencje znaków, które mają znaczenie symboliczne).When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). Tokeny równoważne z ciągami "0", "1", "true" i "false" mogą występować często w strumieniu XML.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

Zamiast konwertować każdy token do nowego ciągu, można utworzyć System.Xml.NameTable obiekt, który będzie przechowywać często występujące ciągi.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. NameTable Obiekt podnosi wydajność, ponieważ pobiera przechowywane ciągi bez przydzielania pamięci tymczasowej.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Gdy napotkasz token, użyj NameTable.Get(Char[], Int32, Int32) metody, aby pobrać token z tabeli.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. Jeśli token istnieje, metoda zwraca odpowiedni ciąg.If the token exists, the method returns the corresponding string. Jeśli token nie istnieje, użyj NameTable.Add(Char[], Int32, Int32) metody, aby wstawić token do tabeli i uzyskać odpowiedni ciąg.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.

Przykład 1: Używanie przypisania ciąguExample 1: Using string assignment

Poniższy przykład tworzy nowy ciąg, przypisując go literałem ciągu.The following example creates a new string by assigning it a string literal. Tworzy drugi ciąg przez przypisanie wartości pierwszego ciągu do niego.It creates a second string by assigning the value of the first string to it. Są to dwa najczęstsze sposoby tworzenia wystąpienia nowego String obiektu.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.

Przykład 2: Korzystanie z tablicy znakówExample 2: Using a character array

W poniższym przykładzie pokazano, jak utworzyć nowy String obiekt z tablicy znaków.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))) 

Przykład 3: Użycie części tablicy znaków i powtarzanie pojedynczego znakuExample 3: Using a portion of a character array and repeating a single character

W poniższym przykładzie pokazano, jak utworzyć nowy String obiekt z części tablicy znaków i jak utworzyć nowy String obiekt, który zawiera wiele wystąpień pojedynczego 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)

Przykład 4: Używanie wskaźnika do tablicy znakówExample 4: Using a pointer to a character array

W poniższym przykładzie pokazano, jak utworzyć nowy String obiekt ze wskaźnika do tablicy znaków.The following example demonstrates how to create a new String object from a pointer to an array of characters. C# Przykład musi być skompilowany przy użyciu /unsafe przełącznika kompilatora.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!

Przykład 5: Tworzenie wystąpienia ciągu ze wskaźnika i zakresu tablicyExample 5: Instantiating a string from a pointer and a range of an array

Poniższy przykład analizuje elementy tablicy znaków dla kropki lub wykrzyknika.The following example examines the elements of a character array for either a period or an exclamation point. Jeśli zostanie znaleziony, tworzy wystąpienie ciągu znaków w tablicy, która poprzedza symbol interpunkcji.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. W przeciwnym razie tworzy wystąpienie ciągu z całą zawartością tablicy.If not, it instantiates a string with the entire contents of the array. C# Przykład musi być skompilowany przy użyciu /unsafe przełącznika kompilatora.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

Przykład 6: Tworzenie wystąpienia ciągu ze wskaźnika do podpisanej tablicy bajtówExample 6: Instantiating a string from a pointer to a signed byte array

Poniższy przykład ilustruje, jak można utworzyć wystąpienie String klasy String(SByte*) za pomocą konstruktora.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") );
}

Informacje o wersjiVersion information

.NET Framework.NET Framework
Wszystkie przeciążenia są obsługiwane w programie: 4,5, 4, 3,5, 3,0, 2,0, 1,1, 1,0All overloads are supported in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile.NET Framework Client Profile
Wszystkie przeciążenia są obsługiwane w programie: 4, 3,5 Z DODATKIEM SP1All overloads are supported in: 4, 3.5 SP1

Biblioteka klas przenośnychPortable Class Library
Wszystkie przeciążenia bez SByte * parametru są obsługiwaneAll overloads without an SByte* parameter are supported

Środowisko .NET dla aplikacji do Sklepu Windows.NET for Windows Store apps
Wszystkie przeciążenia bez SByte * parametru są obsługiwane w programie: Windows 8All overloads without an SByte* parameter are supported in: Windows 8

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

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków 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*

Wskaźnik do tablicy znaków Unicode zakończonych wartością null.A pointer to a null-terminated array of Unicode characters.

Wyjątki

Bieżący proces nie ma dostępu do odczytu do wszystkich znaków w adresie.The current process does not have read access to all the addressed characters.

valueOkreśla tablicę zawierającą nieprawidłowy znak Unicode lub value określa adres mniejszy niż 64000.value specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpieczenia

SecurityCriticalAttribute
Wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

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

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez tablicę znaków 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[]

Tablica znaków Unicode.An array of Unicode characters.

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.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*)

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Inicjuje nowe wystąpienie String klasy do wartości wskazywanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem.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*

Wskaźnik do tablicy zakończonych znakiem null 8-bitowych liczb całkowitych ze znakiem.A pointer to a null-terminated array of 8-bit signed integers. Liczby całkowite są interpretowane przy użyciu bieżącego kodowania strony kodowej systemu (czyli kodowania określonego przez Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Wyjątki

Nie można zainicjować nowego String wystąpienia programu przy użyciu polecenia value, przy value założeniu, że jest zakodowana w ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

Długość nowego ciągu do zainicjowania, która jest określana przez znak zakończenia null elementu value, jest zbyt duża do przydzielenia.The length of the new string to initialize, which is determined by the null termination character of value, is too large to allocate.

valueokreśla nieprawidłowy adres.value specifies an invalid address.

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpieczenia

SecurityCriticalAttribute
Wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

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

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony znak Unicode powtórzony określoną liczbę razy.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 Unicode.A Unicode character.

count
Int32 Int32 Int32 Int32

Liczba wystąpień c .The number of times c occurs.

Wyjątki

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.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)

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków Unicode, początkowej pozycji znaku w tej tablicy i długości.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*

Wskaźnik do tablicy znaków Unicode.A pointer to an array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Pozycja początkowa w value.The starting position within value.

length
Int32 Int32 Int32 Int32

Liczba znaków value do użycia.The number of characters within value to use.

Wyjątki

startIndexlub length jest mniejsza od zera, value + startIndex powoduje przepełnienie wskaźnika lub bieżący proces nie ma dostępu do odczytu do wszystkich znaków.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.

valueOkreśla tablicę zawierającą nieprawidłowy znak Unicode lub value + startIndex określa adres mniejszy niż 64000.value specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpieczenia

SecurityCriticalAttribute
Wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.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)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez tablicę znaków Unicode, początkową pozycję znaku w tej tablicy i długość.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[]

Tablica znaków Unicode.An array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Pozycja początkowa w value.The starting position within value.

length
Int32 Int32 Int32 Int32

Liczba znaków value do użycia.The number of characters within value to use.

Wyjątki

startIndexlub length jest mniejsza od zera.startIndex or length is less than zero.

—lub—-or- Suma startIndex valuei length jest większa niż liczba elementów w.The sum of startIndex and length is greater than the number of elements in value.

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.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)

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy i długości.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*

Wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem.A pointer to an array of 8-bit signed integers. Liczby całkowite są interpretowane przy użyciu bieżącego kodowania strony kodowej systemu (czyli kodowania określonego przez Default).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32 Int32 Int32 Int32

Pozycja początkowa w value.The starting position within value.

length
Int32 Int32 Int32 Int32

Liczba znaków value do użycia.The number of characters within value to use.

Wyjątki

startIndexlub length jest mniejsza od zera.startIndex or length is less than zero.

—lub—-or- Adres określony przez value + jestzadużydlabieżącejplatformy;oznaczato,żeObliczanieadresuzostałoprzepływane.startIndexThe address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

—lub—-or- Długość nowego ciągu do zainicjowania jest zbyt duża, aby można było przydzielić.The length of the new string to initialize is too large to allocate.

Adres określony przez value + jestmniejszyniż64KBstartIndex .The address specified by value + startIndex is less than 64K.

—lub—-or- Nie można zainicjować nowego String wystąpienia programu przy użyciu polecenia value, przy value założeniu, że jest zakodowana w ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndex ilength zbiorczo Określ nieprawidłowy adres.value, startIndex, and length collectively specify an invalid address.

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpieczenia

SecurityCriticalAttribute
Wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.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)

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, czyli pozycji początkowej w tej tablicy, długości Encoding i obiektu.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*

Wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem.A pointer to an array of 8-bit signed integers.

startIndex
Int32 Int32 Int32 Int32

Pozycja początkowa w value.The starting position within value.

length
Int32 Int32 Int32 Int32

Liczba znaków value do użycia.The number of characters within value to use.

enc
Encoding Encoding Encoding Encoding

Obiekt, który określa sposób kodowania tablicy, do value której się odwołuje.An object that specifies how the array referenced by value is encoded. Jeśli enc jestnull, założono kodowanie ANSI.If enc is null, ANSI encoding is assumed.

Wyjątki

startIndexlub length jest mniejsza od zera.startIndex or length is less than zero.

—lub—-or- Adres określony przez value + jestzadużydlabieżącejplatformy;oznaczato,żeObliczanieadresuzostałoprzepływane.startIndexThe address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

—lub—-or- Długość nowego ciągu do zainicjowania jest zbyt duża, aby można było przydzielić.The length of the new string to initialize is too large to allocate.

Adres określony przez value + jestmniejszyniż64KBstartIndex .The address specified by value + startIndex is less than 64K.

—lub—-or- Nie można zainicjować nowego String wystąpienia programu przy użyciu polecenia value, przy value założeniu, że jest enczakodowany jako określony przez.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex ilength zbiorczo Określ nieprawidłowy adres.value, startIndex, and length collectively specify an invalid address.

Uwagi

Uwaga

Przykłady i kompleksowe informacje o użyciu tego i innych String przeciążeń konstruktora można znaleźć w String podsumowaniu konstruktora.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Zabezpieczenia

SecurityCriticalAttribute
Wymaga pełnego zaufania do bezpośredniego obiektu wywołującego.requires full trust for the immediate caller. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.This member cannot be used by partially trusted or transparent code.

Dotyczy