String Konstruktory

Definicja

Inicjuje nowe wystąpienie klasy String.Initializes a new instance of the String class.

Przeciążenia

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[])

Inicjuje nowe wystąpienie String klasy do znaków Unicode wskazanych w określonej tablicy znaków.Initializes a new instance of the String class to the Unicode characters indicated in the specified character array.

String(ReadOnlySpan<Char>)

Inicjuje nowe wystąpienie String klasy do znaków Unicode wskazanych w określonym zakresie tylko do odczytu.Initializes a new instance of the String class to the Unicode characters indicated in the specified read-only span.

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)

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)

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)

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)

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)

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 i Encoding 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 konstruktoraOverloaded constructor syntax
WejścioweParameters
WyłączeniaExceptions
Którą metodę nazywam?Which method do I call?
Tworzenie ciągówCreating strings
Obsługa powtarzających się ciągówHandle repetitive strings

Przykłady tworzenia wystąpień ciągów:Examples of instantiating strings:

Użyj przypisania ciąguUse string assignment
Użyj tablicy znakówUse a character array
Użycie części tablicy znaków i powtarzanie pojedynczego znakuUse a portion of a character array and repeating a single character
Użyj wskaźnika do tablicy znakówUse a pointer to a character array
Użyj wskaźnika i zakresu tablicyUse a pointer and a range of an array
Użyj wskaźnika do podpisanej tablicy bajtówUse a pointer to a signed byte array

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, a język 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, zobacz artykuł niebezpieczny.For 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.String(Char[] value) 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).String(Char[] value, Int32 startIndex, Int32 length) 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).String(Char c, Int32 count) 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 ').String(char* value) (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ść.String(char* value, Int32 startIndex, Int32 length) (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 Unicode z value lokalizacji w indeksie startIndex i kończąc przy indeksie startIndex + 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.String(SByte* value) (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.String(SByte* value, Int32 startIndex, Int32 length) (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 z wartości rozpoczynając od startIndex 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.String(SByte* value, Int32 startIndex, Int32 length, Encoding enc) (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 początkowa value 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 c powtórzeń znaku 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.Default lub 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 value to 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 i length jest większa niż liczba elementów w value .The sum of startIndex and length is greater than the number of elements in value.

-lub--or-

Parametr count ma wartość niższą niż zero.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 value Określa tablicę zawierającą nieprawidłowy znak Unicode.value specifies an array that contains an invalid Unicode character.

-lub--or-

valuelub value + startIndex określa adres, 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 z value tablicy bajtowej, ponieważ nie value 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 value ma 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 valuelub value + startIndex + length -1 określa nieprawidłowy adres.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?

DziałanieTo 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 tablicy języka C++ char .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ówCreate 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. StringKlasa 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. String(Char[], Int32, Int32)Konstruktor kopiuje znaki z indeksu startIndex do indeksu startIndex + length -1 do nowego ciągu.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*) String(Char*, Int32, Int32) konstruktora or.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, rozpoczynając od określonego wskaźnika lub od określonego wskaźnika startIndex 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 lub length 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 znaki, w length 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 języku C++ oznacza to, że tablica znaków musi być zdefiniowana jako typ zarządzany Char [] lub niezarządzany wchar_t Typ [].In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    Jeśli String(Char*) Przeciążenie jest wywołane i tablica nie kończy się znakiem null lub jeśli String(Char*, Int32, Int32) Przeciążenie jest wywołane i startIndex + length -1 zawiera zakres, który jest poza pamięcią przydzieloną dla sekwencji znaków, 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 is outside the memory allocated for the sequence of characters, the behavior of the constructor is system-dependent, and an access violation may occur.

  • 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 z całej tablicy, która nie została zakończona znakiem null lub jeśli zakres tablicy z value + startIndex do value + startIndex + length -1 znajduje się 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ę bajtów jako parametr są przeznaczone głównie do konwersji tablicy C++ char 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 i String(SByte*, Int32, Int32) zostanie wywołana metoda przeciążenia, wystąpienie ciągu zawiera znaki, w length 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ż String(SByte*) String(SByte*, Int32, Int32) konstruktory i interpretują przy value 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.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ówHandle repetitive strings

Aplikacje, które analizują lub dekodowania strumieni tekstu często używają String(Char[], Int32, Int32) konstruktora lub StringBuilder.Append(Char[], Int32, Int32) 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. NameTableObiekt 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 metody, NameTable.Get(Char[], Int32, Int32) 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żyj przypisania ciąguExample 1: Use 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: użycie tablicy znakówExample 2: Use 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: Use 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żyj wskaźnika do tablicy znakówExample 4: Use 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. Przykład w języku C# należy kompilować 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: Instantiate 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. Przykład w języku C# należy kompilować 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: utworzenie wystąpienia ciągu ze wskaźnika do podpisanej tablicy bajtówExample 6: Instantiate a string from a pointer to a signed byte array

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

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);
public String (char* value);
[System.CLSCompliant(false)]
public String (char* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value);
new string : nativeptr<char> -> string
[<System.CLSCompliant(false)>]
new string : nativeptr<char> -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
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.

Atrybuty

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.

value Okreś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.

Dotyczy

String(Char[])

Inicjuje nowe wystąpienie String klasy do znaków Unicode wskazanych w określonej tablicy znaków.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[]

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.

Dotyczy

String(ReadOnlySpan<Char>)

Inicjuje nowe wystąpienie String klasy do znaków Unicode wskazanych w określonym zakresie tylko do odczytu.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>

Zakres tylko do odczytu znaków Unicode.A read-only span of Unicode characters.

Dotyczy

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);
public String (sbyte* value);
[System.CLSCompliant(false)]
public String (sbyte* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value);
new string : nativeptr<sbyte> -> string
[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
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).

Atrybuty

Wyjątki

value to null.value is null.

StringNie można zainicjować nowego wystąpienia programu przy użyciu polecenia value , przy założeniu, że value 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.

value okreś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.

Dotyczy

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

Znak Unicode.A Unicode character.

count
Int32

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

Wyjątki

Parametr count ma wartość niższą niż zero.count is less than zero.

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.

Dotyczy

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);
public String (char* value, int startIndex, int length);
[System.CLSCompliant(false)]
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
[<System.CLSCompliant(false)>]
new string : nativeptr<char> * int * int -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
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

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

length
Int32

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

Atrybuty

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.

Dotyczy

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

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

length
Int32

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

Wyjątki

value to null.value is null.

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

-lub--or-

Suma startIndex i length jest większa niż liczba elementów w value .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.

Dotyczy

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);
public String (sbyte* value, int startIndex, int length);
[System.CLSCompliant(false)]
public String (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
[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> * int * int -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
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

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

length
Int32

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

Atrybuty

Wyjątki

value to null.value is null.

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

-lub--or-

Adres określony przez value + startIndex jest za duży dla bieżącej platformy; oznacza to, że Obliczanie adresu zostało przepływane.The 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 + startIndex jest mniejszy niż 64 KB.The address specified by value + startIndex is less than 64K.

-lub--or-

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

value, startIndex i length 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.

Dotyczy

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 i Encoding 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);
public String (sbyte* value, int startIndex, int length, System.Text.Encoding? enc);
[System.CLSCompliant(false)]
public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);
[System.CLSCompliant(false)]
public String (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
[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
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

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

length
Int32

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

enc
Encoding

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

Atrybuty

Wyjątki

value to null.value is null.

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

-lub--or-

Adres określony przez value + startIndex jest za duży dla bieżącej platformy; oznacza to, że Obliczanie adresu zostało przepływane.The 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 + startIndex jest mniejszy niż 64 KB.The address specified by value + startIndex is less than 64K.

-lub--or-

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

value, startIndex i length 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.

Dotyczy