String Konstruktorok

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Inicializálja a String osztály új példányát.

Túlterhelések

Név	Description
String(Char*)	Inicializálja az String osztály új példányát a megadott mutató által jelzett értékre Unicode-karakterek tömbje felé.
String(Char[])	Inicializálja az String osztály új példányát a megadott karaktertömbben megjelölt Unicode-karakterekre.
String(ReadOnlySpan<Char>)	Inicializálja az String osztály új példányát a megadott írásvédett időtartamban megadott Unicode-karakterekre.
String(SByte*)	Inicializálja az String osztály új példányát a 8 bites aláírt egész számok tömbjének mutatója által jelzett értékre.
String(Char, Int32)	Inicializálja az String osztály új példányát egy megadott Unicode-karakter által jelzett értékre, amely többször ismétlődik.
String(Char*, Int32, Int32)	Inicializálja az String osztály új példányát egy megadott Unicode-karakterekből álló tömbre mutató által jelzett értékre, a tömbön belüli kezdő karakterpozícióra és a hosszra.
String(Char[], Int32, Int32)	Inicializálja az String osztály új példányát a Unicode-karakterek tömbje által jelzett értékre, a tömbön belüli kezdő karakterpozícióra és a hosszra.
String(SByte*, Int32, Int32)	Inicializálja az String osztály új példányát a megadott mutató által jelzett értékre egy 8 bites aláírt egész számokat tartalmazó tömbre, a tömbön belüli kezdőpozícióra és egy hosszra.
String(SByte*, Int32, Int32, Encoding)	Inicializálja az String osztály új példányát a megadott mutató által jelzett értékre egy 8 bites aláírt egész számokat tartalmazó tömbre, a tömbön belüli kezdőpozícióra, egy hosszra és egy objektumra Encoding .

Megjegyzések

Túlterhelt konstruktor szintaxisa

A sztringkonstruktorok két kategóriába sorolhatók : a mutatóparaméterek nélküli és a mutatóparaméterekkel rendelkezőkbe. A mutatókat használó konstruktorok nem CLS-kompatibilisek. Emellett a Visual Basic nem támogatja a mutatók használatát, a C# pedig olyan kódot igényel, amely mutatókat használ a nem biztonságos környezetben való futtatáshoz. További információ: nem biztonságos.

A túlterhelés kiválasztásával kapcsolatos további útmutatásért lásd : Melyik metódust hívhatom meg?.

String(Char[] value)
Inicializálja az új példányt a Unicode-karakterek tömbje által jelzett értékre. Ez a konstruktor Unicode-karaktereket másol (2. példa: Karaktertömb használata).

String(Char[] value, Int32 startIndex, Int32 length)
Inicializálja az új példányt a Unicode-karakterek tömbje által jelzett értékre, a tömbben lévő kezdő karakterpozícióra és egy hosszra (3. példa: Karaktertömb egy részének használata és egyetlen karakter ismétlése).

String(Char c, Int32 count)
Inicializálja az új példányt arra az értékre, amelyet egy megadott Unicode-karakter jelez, és adott számú alkalommal ismétlődik (3. példa: Egy karaktertömb egy részének használata és egyetlen karakter ismétlése).

String(char* value)
(Nem CLS-kompatibilis) Inicializálja az új példányt a null karakterrel végződő Unicode-karakterek tömbjének mutatója által jelzett értékre (U+0000 vagy \0). (4. példa: Mutató használata karaktertömbhöz).

String(char* value, Int32 startIndex, Int32 length)
(Nem CLS-kompatibilis) Inicializálja az új példányt egy Unicode-karakterekből álló tömbre mutató mutató értékre, a tömbön belüli kezdő karakterpozícióra és egy hosszra. A konstruktor átmásolja a Unicode-karaktereket a value-ból kiindulva, az startIndex indextől kezdve, az startIndex + length indexig – 1 (5. példa: Sztring példányosítása egy mutatóból és egy tömbtartományból).

String(SByte* value)
(Nem CLS-kompatibilis) Inicializálja az új példányt egy olyan mutató által jelzett értékkel, amely a 8 bites előjeles egész számokat tartalmazó tömbre mutat. A tömböt úgy tekintjük, hogy az aktuális rendszerkódlap használatával kódolt karakterláncot jelöl (vagyis a Encoding.Default által megadott kódolás). A konstruktor a karaktereket az egérmutató által megadott helytől value kezdve a null karakter (0x00) eléréséig dolgozza fel (6. példa: Sztring példányosítása mutatóról aláírt bájttömbre).

String(SByte* value, Int32 startIndex, Int32 length)
(Nem CLS-kompatibilis) Inicializálja az új példányt a 8 bites aláírt egész számokat tartalmazó tömbre mutató mutató értékre, a tömbön belüli kezdőpozícióra és a hosszra. A tömböt úgy tekintjük, hogy az aktuális rendszerkódlap használatával kódolt karakterláncot jelöl (vagyis a Encoding.Default által megadott kódolás). A konstruktor a karaktereket az startIndex pozíciótól kezdve az startIndex + length - 1 előtti karakterig dolgozza fel (6. példa: Sztring példányosítása mutatóból aláírt bájttömbből).

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Nem CLS-kompatibilis) Inicializálja az új példányt a 8 bites aláírt egész számokat tartalmazó tömbre mutató mutató értékre, a tömbön belüli kezdőpozícióra, egy hosszra és egy objektumra Encoding .

Paraméterek

Íme a mutatóparamétert nem tartalmazó konstruktorok által String használt paraméterek teljes listája. Az egyes túlterhelések által használt paraméterekért tekintse meg a fenti túlterhelési szintaxist.

Paraméter	Típus	Description
value	Char[]	Unicode-karakterek tömbje.
c	Char	Unicode-karakter.
startIndex	Int32	Az új karaktersor első karakterének kezdőpozíciója a value. Alapértelmezett érték: 0
length	Int32	Az új láncba belefoglalandó karakterek száma a value-ben. Alapértelmezett érték: Array.Length
count	Int32	A karakter c ismétlődésének száma az új sztringben. Ha count nulla, az új objektum értéke .String.Empty

Íme a mutatóparamétert tartalmazó konstruktorok által String használt paraméterek teljes listája. Az egyes túlterhelések által használt paraméterekért tekintse meg a fenti túlterhelési szintaxist.

Paraméter	Típus	Description
value	Char* -vagy- SByte*	Unicode-karaktereket tartalmazó nullával lezárt tömbre mutató mutató vagy 8 bites aláírt egész számokat tartalmazó tömb. Ha value vagy üres null tömb, akkor az új sztring értéke String.Empty.
startIndex	Int32	Az új karakterlánc első karakterét meghatározó tömbelem indexe. Alapértelmezett érték: 0
length	Int32	Az új sztring létrehozásához használandó tömbelemek száma. Ha a hossz nulla, a konstruktor létrehoz egy sztringet, amelynek értéke .String.Empty Alapértelmezett érték: Array.Length
enc	Encoding	Egy objektum, amely meghatározza, hogyan van a value tömb kódolva. Alapértelmezett érték: Encoding.Defaultvagy a rendszer aktuális ANSI-kódlapja

Exceptions

Íme egy lista a konstruktorok által dobott kivételekről, amelyek nem tartalmaznak mutatóparamétereket.

Exception	Condition	Keletkezett:
ArgumentNullException	value az null.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	startIndex, lengthvagy count kisebb, mint nulla. -vagy- startIndex és length összege nagyobb, mint a value elemeinek száma. -vagy- count kisebb, mint nulla.	String(Char, Int32) String(Char[], Int32, Int32)

Íme a mutatóparamétereket tartalmazó konstruktorok által kiadott kivételek listája.

Exception	Condition	Keletkezett:
ArgumentException	value érvénytelen Unicode-karaktert tartalmazó tömböt ad meg. -vagy- value vagy value + startIndex 64 000-nél kisebb címet ad meg. -vagy- Egy új String példány nem inicializálható a value bájttömbből, mert value nem használja az alapértelmezett kódlapkódolást.	Az összes konstruktor mutatókkal.
ArgumentNullException	value null értékű.	String(SByte*) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException	Az aktuális folyamat nem rendelkezik olvasási hozzáféréssel az összes címzett karakterhez. -vagy- startIndex vagy length kisebb, mint nulla, value + startIndex túlcsordulást okoz, vagy az aktuális folyamat nem rendelkezik olvasási hozzáféréssel az összes címzett karakterhez. -vagy- Az új karaktersor hossza túl nagy a lefoglaláshoz.	Az összes konstruktor mutatókkal.
AccessViolationException	value value + startIndex + length vagy - 1, érvénytelen címet ad meg.	String(SByte*) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

Melyik metódust hívhatom meg?

Címzett	Hívj vagy használj
Sztring létrehozása.	Hozzárendelés karakterlánc-literálból vagy meglévő karakterláncból (1. példa: Karakterlánc hozzárendelése használata)
Sztring létrehozása egy teljes karaktertömbből.	String(Char[]) (2. példa: Karaktertömb használata)
Sztring létrehozása egy karaktertömb egy részéből.	String(Char[], Int32, Int32) (3. példa: Karaktertömb egy részének használata és egyetlen karakter ismétlése)
Hozzon létre egy sztringet, amely többször ugyanazt a karaktert ismétli.	String(Char, Int32) (3. példa: Karaktertömb egy részének használata és egyetlen karakter ismétlése)
Hozzon létre egy stringet egy Unicode vagy széles karaktertömbre mutató pointerből.	String(Char*)
Hozzon létre egy sztringet egy Unicode vagy széles karaktertömb egy részéből az egérmutató használatával.	String(Char*, Int32, Int32)
C++ char tömbből string létrehozása.	String(SByte*), String(SByte*, Int32, Int32) -vagy- String(SByte*, Int32, Int32, Encoding)
Sztring létrehozása ASCII-karakterekből.	ASCIIEncoding.GetString

Sztringek létrehozása

A stringek programozott létrehozására leggyakrabban használt módszer az egyszerű hozzárendelés, ahogyan az 1. példában is látható. Az String osztály négy konstruktor-túlterhelési típust is tartalmaz, amelyek segítségével sztringeket hozhat létre a következő értékekből:

• Karaktertömbből (UTF-16 kódolású karakterekből álló tömb). Létrehozhat egy új String objektumot a teljes tömb vagy annak egy része karaktereiből. A String(Char[]) konstruktor a tömb összes karakterét átmásolja az új sztringbe. A String(Char[], Int32, Int32) konstruktor a startIndex és startIndex + length közötti karaktereket másolja az új karakterláncba, az length-t beleértve. Ha length nulla, az új karakterlánc értéke String.Empty.

  Ha a kód ismételten példányosítja az azonos értékű sztringeket, a sztringek létrehozásának alternatív eszközeivel javíthatja az alkalmazás teljesítményét. További információ: Ismétlődő sztringek kezelése.

• Egyetlen karakterből, amely nulla, egy vagy több alkalommal ismétlődik, a String(Char, Int32) konstruktor által. Ha count nulla, az új karakterlánc értéke String.Empty.

• A mutatótól a nullával lezárt karaktertömbig a String(Char*) vagy String(Char*, Int32, Int32) konstruktor használatával. A sztring inicializálásához használhatja a teljes tömböt vagy egy megadott tartományt. A konstruktor a megadott mutatótól vagy a megadott mutató plusz startIndex pozíciójától kiindulva az Unicode-karakterek sorozatát másolja, egészen a tömb végéig vagy az adott számú, length karakterig. Ha value null mutató vagy length nulla, a konstruktor létrehoz egy sztringet, amelynek értéke .String.Empty Ha a másolási művelet a tömb végéig folytatódik, és a tömb nem null értékű, a konstruktor működése rendszerfüggő. Egy ilyen feltétel hozzáférés-szabálysértést okozhat.

  Ha a tömb beágyazott null karaktereket (U+0000 vagy '\0') tartalmaz, és meghívják a String(Char*, Int32, Int32) túlterhelést, a karakterlánc példány length karaktereket tartalmaz, beleértve a beágyazott null karaktereket is. Az alábbi példa bemutatja, mi történik, ha egy 10 elemből álló tömbre mutató mutatót ad át a String(Char*, Int32, Int32) metódusnak, amely két null karaktert tartalmaz. Mivel a cím a tömb kezdete, és a tömb összes elemét hozzá kell adni a sztringhez, a konstruktor létrehoz egy tíz karakterből álló sztringet, beleértve két beágyazott null karaktert. Ha viszont ugyanazt a tömböt továbbítja a String(Char*) konstruktornak, az eredmény egy négy karakterből áll, amely nem tartalmazza az első null karaktert.

  using System;
  
  public class Example2
  {
     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($"{(ushort)ch:X4} ");
        Console.WriteLine();
        
        fixed(char* chPtr = chars) {
           s = new string(chPtr);         
        }
        
        foreach (var ch in s)
           Console.Write($"{(ushort)ch:X4} ");
        Console.WriteLine();    
     }
  }
  // The example displays the following output:
  //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
  //       0061 0062 0063 0064
  

  #nowarn "9"
  open System
  
  let chars = [| 'a'; 'b'; 'c'; 'd'; '\000'; 'A'; 'B'; 'C'; 'D'; '\000' |]
  let s =
      use chPtr = fixed chars
      String(chPtr, 0, chars.Length)
  
  for ch in s do
      printf $"{uint16 ch:X4} "
  printfn ""
  
  let s2 = 
      use chPtr = fixed chars
      String chPtr    
  
  for ch in s2 do
      printf $"{uint16 ch:X4} "
  printfn ""  
  // The example displays the following output:
  //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
  //       0061 0062 0063 0064
  

  A tömbnek Unicode-karaktereket kell tartalmaznia. A C++-ban ez azt jelenti, hogy a karaktertömböt felügyelt Char[] típusként vagy nem felügyeltwchar_t[] típusként kell definiálni.

  Ha a rendszer meghívja a String(Char*) túlterhelést, és a tömb nem null értékű, vagy ha a rendszer meghívja a String(Char*, Int32, Int32) túlterhelést, és startIndex + lengtha -1 olyan tartományt tartalmaz, amely a karakterek sorozatához lefoglalt memórián kívül esik, a konstruktor viselkedése rendszerfüggő, és hozzáférés-megsértés léphet fel.

• Egy mutatóból aláírt bájttömbé. A sztring inicializálásához használhatja a teljes tömböt vagy egy megadott tartományt. A bájtok sorozata az alapértelmezett kódlapkódolással értelmezhető, vagy a konstruktorhívásban megadhatja a kódolást. Ha a konstruktor egy olyan sztringet próbál létrehozni egy teljes tömbből, amely nem null értékű, vagy ha a tömb value + startIndexvalue + startIndex + length-1 tartománya kívül esik a tömb számára lefoglalt memórián, a konstruktor működése rendszerfüggő, és hozzáférés-megsértés léphet fel.

  A paraméterként aláírt bájttömböt tartalmazó három konstruktor elsősorban egy C++ char tömb sztringgé alakítására lett kialakítva, ahogyan az ebben a példában látható:

  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
  

  Ha a tömb tartalmaz olyan null karaktereket ('\0') vagy bájtokat, amelyek értéke 0, és a String(SByte*, Int32, Int32) túlterhelés meghívása történik, a sztringpéldány karaktereket tartalmaz length , beleértve a beágyazott null értékeket is. Az alábbi példa bemutatja, mi történik, ha egy 10 elemből álló tömbre mutató mutatót ad át a String(SByte*, Int32, Int32) metódusnak, amely két null karaktert tartalmaz. Mivel a cím a tömb kezdete, és a tömb összes elemét hozzá kell adni a sztringhez, a konstruktor létrehoz egy tíz karakterből álló sztringet, beleértve két beágyazott null karaktert. Ha viszont ugyanazt a tömböt továbbítja a String(SByte*) konstruktornak, az eredmény egy négy karakterből áll, amely nem tartalmazza az első null karaktert.

  using System;
  
  public class Example5
  {
     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($"{(ushort)ch:X4} ");
        
        Console.WriteLine();    
  
        fixed(sbyte* bytePtr = bytes) {
           s = new string(bytePtr);         
        }
        
        foreach (var ch in s)
           Console.Write($"{(ushort)ch:X4} ");
        Console.WriteLine();    
     }
  }
  // The example displays the following output:
  //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
  //       0061 0062 0063 0064
  

  #nowarn "9"
  open System
  
  let bytes = 
      [| 0x61y; 0x62y; 0x063y; 0x064y; 0x00y; 0x41y; 0x42y; 0x43y; 0x44y; 0x00y |]
  
  let s =
      use bytePtr = fixed bytes
      String(bytePtr, 0, bytes.Length)
  
  for ch in s do
      printf $"{uint16 ch:X4} "
  printfn ""
  
  let s2 =
      use bytePtr = fixed bytes
      String bytePtr         
  
  for ch in s do
      printf $"{uint16 ch:X4} "
  printfn ""
  // The example displays the following output:
  //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
  //       0061 0062 0063 0064
  

  Mivel a String(SByte*) és String(SByte*, Int32, Int32) konstruktorok az alapértelmezett ANSI kódlap használatával értelmezik value-t, azonos bájttömbök használata esetén ezek a konstruktorok különböző rendszereken különböző értékű karakterláncokat hozhatnak létre.

Ismétlődő karakterláncok kezelése

A szövegfolyamokat elemző vagy dekódoló alkalmazások gyakran használják a String(Char[], Int32, Int32) konstruktort vagy a metódust a StringBuilder.Append(Char[], Int32, Int32) karaktersorozatok sztringgé alakításához. Az új sztringek ismételt létrehozása ugyanazzal az értékkel ahelyett, hogy egy sztringet hoz létre és használ fel, memóriát pazarol. Ha a String(Char[], Int32, Int32) konstruktor meghívásával valószínűleg ismételten létrehoz ugyanazt a karakterlánc értéket, akkor is, ha nem tudja előre, hogy mik lehetnek ezek az azonos karakterlánc értékek, használhat helyette egy keresési táblát.

Tegyük fel például, hogy egy XML-címkéket és attribútumokat tartalmazó fájlból olvas és elemez egy karakterfolyamot. A stream elemzésekor ismételten találkozik bizonyos tokenekkel (azaz szimbolikus jelentéssel rendelkező karaktersorozatokkal). A "0", "1", "true" és "false" sztringekkel megegyező tokenek valószínűleg gyakran fordulnak elő egy XML-adatfolyamban.

Az egyes tokenek új sztringgé alakítása helyett létrehozhat egy System.Xml.NameTable objektumot a gyakran előforduló sztringek tárolásához. Az NameTable objektum javítja a teljesítményt, mivel ideiglenes memória kiosztása nélkül kéri le a tárolt sztringeket. Amikor egy tokennel találkozik, a NameTable.Get(Char[], Int32, Int32) módszer használatával szerezze be a tokent a táblázatból. Ha a token létezik, a metódus a megfelelő karakterláncot adja vissza. Ha a jogkivonat nem létezik, a NameTable.Add(Char[], Int32, Int32) metódus használatával szúrja be a jogkivonatot a táblába, és kérje le a megfelelő sztringet.

1. példa: Sztring-hozzárendelés használata

Az alábbi példa egy új karakterláncot hoz létre egy karakterlánc-literál hozzárendelésével. Létrehoz egy második sztringet az első sztring értékének hozzárendelésével. Ez a két leggyakoribb módszer egy új String objektum példányosítására.

using System;

public class Example3
{
   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.

let value1 = "This is a string."
let value2 = value1
printfn "%s" value1
printfn "%s" 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.

2. példa: Karaktertömb használata

Az alábbi példa bemutatja, hogyan hozhat létre új String objektumot egy karaktertömbből.

// 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
let charArr1 = [| '\u2200'; '\u2202'; '\u200F'; '\u2205' |]
let szMathSymbols = String charArr1

// Unicode Letterlike Symbols
let charArr2 = [| '\u2111'; '\u2118'; '\u2122'; '\u2126' |]
let szLetterLike = String charArr2

// Compare Strings - the result is false
printfn $"The Strings are equal? %b{String.Compare(szMathSymbols, szLetterLike) = 0}"

' 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)))

3. példa: Karaktertömb egy részének használata és egyetlen karakter ismétlése

Az alábbi példa bemutatja, hogyan hozhat létre új String objektumot egy karaktertömb egy részéből, és hogyan hozhat létre egy új String objektumot, amely egyetlen karakter több előfordulását tartalmazza.

// 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
let szGreekAlpha = String('\u0391',5)
// Create a Unicode String with a Greek Omega character
let szGreekOmega = String([| '\u03A9'; '\u03A9'; '\u03A9' |],2,1)

let szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone())

// Examine the result
printfn $"{szGreekLetters}"

// The first index of Alpha
let ialpha = szGreekLetters.IndexOf '\u0391'
// The last index of Omega
let iomega = szGreekLetters.LastIndexOf '\u03A9'

printfn $"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)

4. példa: Mutató használata karaktertömbhöz

Az alábbi példa bemutatja, hogyan hozhat létre új String objektumot egy mutatóból egy karaktertömbbe. A C#-példát a /unsafe fordítókapcsolóval kell lefordítani.

using System;

public class Example4
{
   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!

#nowarn "9"
open System

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' ' 
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

let value =
    use charPtr = fixed characters
    String charPtr

printfn $"{value}"
// The example displays the following output:
//        Hello world!

5. példa: Sztring példányosítása egy mutatóból és egy tömb tartományából

Az alábbi példa megvizsgálja a karaktertömb elemeit, hogy tartalmaznak-e pontot vagy felkiáltójelet. Ha talál egy írásjelet, sztringet hoz létre a tömbben az írásjelet megelőző karakterekből. Ha nem, létrehoz egy karakterláncot, amely tartalmazza a tömb összes elemét. A C# példát a /unsafe fordítókapcsolóval kell lefordítani.

using System;

public class Example1
{
   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

#nowarn "9"
open System
open FSharp.NativeInterop

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' '
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

[<EntryPoint>]
let main _ =
    use charPtr = fixed characters
    let mutable length = 0
    let mutable iterator = charPtr
    let mutable broken = false
    while not broken && NativePtr.read iterator <> '\u0000' do
        if NativePtr.read iterator = '!' || NativePtr.read iterator = '.' then
            broken <- true
        else
            iterator <- NativePtr.add iterator 1
            length <- length + 1
    String(charPtr, 0, length)
    |> printfn "%s"
    0
// The example displays the following output:
//      Hello World

6. példa: Sztring létrehozása egy mutatóból, amely aláírt bájttömbre mutat

Az alábbi példa bemutatja, hogyan hozhat létre egy példányt az String osztályból a String(SByte*) konstruktorral.

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") );
}

// Null terminated ASCII characters in an sbyte array
let szAsciiUpper =
    let sbArr1 = [| 0x41y; 0x42y; 0x43y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiUpper = fixed sbArr1
    String pAsciiUpper

let szAsciiLower =
    let sbArr2 = [| 0x61y; 0x62y; 0x63y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiLower = fixed sbArr2 
    String(pAsciiLower, 0, sbArr2.Length)

// Prints "ABC abc"
printfn $"{szAsciiUpper} {szAsciiLower}"

// Compare Strings - the result is true
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper()) = 0}"

// This is the effective equivalent of another Compare method, which ignores case
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper, szAsciiLower, true) = 0}"

String(Char*)

Forrás:

String.cs

Fontos

Ez az API nem CLS-kompatibilis.

Inicializálja az String osztály új példányát a megadott mutató által jelzett értékre Unicode-karakterek tömbje felé.

public:
 String(char* value);

[System.CLSCompliant(false)]
public String(char* value);

[<System.CLSCompliant(false)>]
new string : nativeptr<char> -> string

Paraméterek

value

Char*

Nullával lezárt Unicode karakterek tömbjének mutatója.

Attribútumok

CLSCompliantAttribute

Kivételek

ArgumentOutOfRangeException

Az aktuális folyamat nem rendelkezik olvasási hozzáféréssel az összes címzett karakterhez.

ArgumentException

value érvénytelen Unicode-karaktert tartalmazó tömböt határoz meg, vagy value 64000-nél kisebb címet ad meg.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.

String(Char[])

Forrás:

String.cs

Inicializálja az String osztály új példányát a megadott karaktertömbben megjelölt Unicode-karakterekre.

public:
 String(cli::array <char> ^ value);

public String(char[]? value);

new string : char[] -> string

Public Sub New (value As Char())

Paraméterek

value

Char[]

Unicode-karakterek tömbje.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.

String(ReadOnlySpan<Char>)

Forrás:

String.cs

Inicializálja az String osztály új példányát a megadott írásvédett időtartamban megadott Unicode-karakterekre.

public:
 String(ReadOnlySpan<char> value);

public String(ReadOnlySpan<char> value);

new string : ReadOnlySpan<char> -> string

Public Sub New (value As ReadOnlySpan(Of Char))

Paraméterek

value

ReadOnlySpan<Char>

Unicode-karakterek írásvédett terjedése.

String(SByte*)

Forrás:

String.cs

Fontos

Ez az API nem CLS-kompatibilis.

Inicializálja az String osztály új példányát a 8 bites aláírt egész számok tömbjének mutatója által jelzett értékre.

public:
 String(System::SByte* value);

[System.CLSCompliant(false)]
public String(sbyte* value);

[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> -> string

Paraméterek

value

SByte*

Mutató egy 8 bites aláírt egész számokat tartalmazó null értékű tömbre. Az egész számokat a rendszer az aktuális rendszerkódlap-kódolással értelmezi a Windows (más néven CP_ACP) és UTF-8 kódolással a nem Windows.

Attribútumok

CLSCompliantAttribute

Kivételek

ArgumentNullException

value az null.

ArgumentException

Nem sikerült inicializálni egy új példányt Stringvalueaz ANSI-ben való kódolást feltételezve value .

ArgumentOutOfRangeException

Az inicializálandó új sztring hossza, amelyet a null végződés karakter valuehatároz meg, túl nagy a lefoglaláshoz.

AccessViolationException

value érvénytelen címet ad meg.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.

String(Char, Int32)

Forrás:

String.cs

Inicializálja az String osztály új példányát egy megadott Unicode-karakter által jelzett értékre, amely többször ismétlődik.

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)

Paraméterek

c

Char

Unicode-karakter.

count

Int32

Az előfordulások c száma.

Kivételek

ArgumentOutOfRangeException

count kisebb, mint nulla.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.

String(Char*, Int32, Int32)

Forrás:

String.cs

Fontos

Ez az API nem CLS-kompatibilis.

Inicializálja az String osztály új példányát egy megadott Unicode-karakterekből álló tömbre mutató által jelzett értékre, a tömbön belüli kezdő karakterpozícióra és a hosszra.

public:
 String(char* value, int startIndex, int length);

[System.CLSCompliant(false)]
public String(char* value, int startIndex, int length);

[<System.CLSCompliant(false)>]
new string : nativeptr<char> * int * int -> string

Paraméterek

value

Char*

Unicode-karakterek tömbjének mutatója.

startIndex

Int32

A kezdő pozíció a következőn belül value: .

length

Int32

A használandó karakterek value száma.

Attribútumok

CLSCompliantAttribute

Kivételek

ArgumentOutOfRangeException

startIndex vagy length kisebb, mint nulla, value + startIndex túlcsordulást okoz, vagy az aktuális folyamat nem rendelkezik olvasási hozzáféréssel az összes címzett karakterhez.

ArgumentException

value érvénytelen Unicode-karaktert tartalmazó tömböt határoz meg, vagy value + startIndex 64000-nél kisebb címet ad meg.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.

String(Char[], Int32, Int32)

Forrás:

String.cs

Inicializálja az String osztály új példányát a Unicode-karakterek tömbje által jelzett értékre, a tömbön belüli kezdő karakterpozícióra és a hosszra.

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)

Paraméterek

value

Char[]

Unicode-karakterek tömbje.

startIndex

Int32

A kezdő pozíció a következőn belül value: .

length

Int32

A használandó karakterek value száma.

Kivételek

ArgumentNullException

value az null.

ArgumentOutOfRangeException

startIndex vagy length kisebb, mint nulla.

-vagy-

startIndex és length összege nagyobb, mint a value elemeinek száma.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.

String(SByte*, Int32, Int32)

Forrás:

String.cs

Fontos

Ez az API nem CLS-kompatibilis.

Inicializálja az String osztály új példányát a megadott mutató által jelzett értékre egy 8 bites aláírt egész számokat tartalmazó tömbre, a tömbön belüli kezdőpozícióra és egy hosszra.

public:
 String(System::SByte* value, int startIndex, int length);

[System.CLSCompliant(false)]
public String(sbyte* value, int startIndex, int length);

[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> * int * int -> string

Paraméterek

value

SByte*

Mutató egy 8 bites aláírt egész számokból álló tömbre. Az egész számokat a rendszer az aktuális rendszerkódlap-kódolással értelmezi a Windows (más néven CP_ACP) és UTF-8 kódolással a nem Windows.

startIndex

Int32

A kezdő pozíció a következőn belül value: .

length

Int32

A használandó bájtok value száma.

Attribútumok

CLSCompliantAttribute

Kivételek

ArgumentNullException

value az null.

ArgumentOutOfRangeException

startIndex vagy length kisebb, mint nulla.

-vagy-

A megadott value + startIndex cím túl nagy az aktuális platformhoz, vagyis a cím kiszámítása túlcsordult.

-vagy-

Az inicializálandó új sztring hossza túl nagy a lefoglaláshoz.

ArgumentException

A megadott value + startIndex cím kisebb, mint 64K.

-vagy-

Nem sikerült inicializálni egy új példányt Stringvalueaz ANSI-ben való kódolást feltételezve value .

AccessViolationException

value, startIndexés length együttesen adjon meg egy érvénytelen címet.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.

String(SByte*, Int32, Int32, Encoding)

Forrás:

String.cs

Fontos

Ez az API nem CLS-kompatibilis.

Inicializálja az String osztály új példányát a megadott mutató által jelzett értékre egy 8 bites aláírt egész számokat tartalmazó tömbre, a tömbön belüli kezdőpozícióra, egy hosszra és egy objektumra Encoding .

public:
 String(System::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)>]
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

Paraméterek

value

SByte*

Mutató egy 8 bites aláírt egész számokból álló tömbre.

startIndex

Int32

A kezdő pozíció a következőn belül value: .

length

Int32

A használandó bájtok value száma.

enc

Encoding

Egy objektum, amely meghatározza, hogy a hivatkozott value tömb hogyan van kódolva. Ha enc igen, a nullfüggvény ANSI-kódolást feltételez.

Attribútumok

CLSCompliantAttribute

Kivételek

ArgumentNullException

value az null.

ArgumentOutOfRangeException

startIndex vagy length kisebb, mint nulla.

-vagy-

A megadott value + startIndex cím túl nagy az aktuális platformhoz, vagyis a cím kiszámítása túlcsordult.

-vagy-

Az inicializálandó új sztring hossza túl nagy a lefoglaláshoz.

ArgumentException

A megadott value + startIndex cím kisebb, mint 64K.

-vagy-

Egy új példány String nem inicializálható a használatával value, feltéve, hogy value a kód a megadott módon encvan kódolva.

AccessViolationException

value, startIndexés length együttesen adjon meg egy érvénytelen címet.

Megjegyzések

Note

Példák és átfogó használati információk erről és más String konstruktorok túlterheléséről, tekintse meg a String konstruktor összegzését.