System.String-konstruktor

Syntax för överlagrade konstruktorer

Strängkonstruktorer delas in i två kategorier: de utan pekarparametrar och de med pekarparametrar. Konstruktorerna som använder pekare är inte CLS-kompatibla. Dessutom stöder Visual Basic inte användning av pekare, och C# kräver kod som använder pekare för att köras i en osäker kontext. Mer information finns i osäkert.

Mer information om hur du väljer en överlagring finns i Vilken metod anropar jag?.

String(Char[] value)
Initierar den nya instansen till det värde som anges av en matris med Unicode-tecken. Den här konstruktorn kopierar Unicode-tecken (exempel 2: Använd en teckenmatris).

String(Char[] value, Int32 startIndex, Int32 length)
Initierar den nya instansen till det värde som anges av en matris med Unicode-tecken, en startteckenposition inom matrisen och en längd (Exempel 3: Använd en del av en teckenmatris och upprepa ett enda tecken).

String(Char c, Int32 count)
Initierar den nya instansen till det värde som anges av ett angivet Unicode-tecken som upprepas ett angivet antal gånger (exempel 3: Använd en del av en teckenmatris och upprepa ett enda tecken).

String(char* value)
(Inte CLS-kompatibel) Initierar den nya instansen till det värde som anges av en pekare till en matris med Unicode-tecken som avslutas med ett null-tecken (U+0000 eller \0). (Exempel 4: Använd en pekare till en teckenmatris).

Behörighet: SecurityCriticalAttribute, kräver fullständigt förtroende för den omedelbara anroparen. Den här medlemmen kan inte användas av delvis betrodd eller transparent kod.

String(char* value, Int32 startIndex, Int32 length)
(Inte CLS-kompatibel) Initierar den nya instansen till det värde som anges av en pekare till en matris med Unicode-tecken, en startteckenposition inom matrisen och en längd. Konstruktorn kopierar Unicode-tecknen från value att börja vid index startIndex och sluta vid index startIndex + length- 1 (Exempel 5: Instansiera en sträng från en pekare och ett intervall av en matris).

Behörighet: SecurityCriticalAttribute, kräver fullständigt förtroende för den omedelbara anroparen. Den här medlemmen kan inte användas av delvis betrodd eller transparent kod.

String(SByte* value)
(Inte CLS-kompatibel) Initierar den nya instansen till det värde som anges av en pekare till en matris med 8-bitars signerade heltal. Matrisen antas representera en sträng som kodas med hjälp av den aktuella systemkodsidan (d.s. den kodning som anges av Encoding.Default). Konstruktorn bearbetar tecken från value platsen som pekaren anger tills ett null-tecken (0x00) har nåtts (Exempel 6: Instansiera en sträng från en pekare till en signerad byte-array).

Behörighet: SecurityCriticalAttribute, kräver fullständigt förtroende för den omedelbara anroparen. Den här medlemmen kan inte användas av delvis betrodd eller transparent kod.

String(SByte* value, Int32 startIndex, Int32 length)
(Inte CLS-kompatibel) Initierar den nya instansen till det värde som anges av en pekare till en matris med 8-bitars signerade heltal, en startposition inom matrisen och en längd. Matrisen antas representera en sträng som kodas med hjälp av den aktuella systemkodsidan (d.s. den kodning som anges av Encoding.Default). Konstruktorn bearbetar tecken från värde som börjar vid startIndex och slutar vid startIndex + length- 1 (Exempel 6: Instansiera en sträng från en pekare till en signerad bytematris).

Behörighet: SecurityCriticalAttribute, kräver fullständigt förtroende för den omedelbara anroparen. Den här medlemmen kan inte användas av delvis betrodd eller transparent kod.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Inte CLS-kompatibel) Initierar den nya instansen till det värde som anges av en pekare till en matris med 8-bitars signerade heltal, en startposition inom matrisen, en längd och ett Encoding objekt.

Behörighet: SecurityCriticalAttribute, kräver fullständigt förtroende för den omedelbara anroparen. Den här medlemmen kan inte användas av delvis betrodd eller transparent kod.

Parametrar

Här är en fullständig lista över parametrar som används av String konstruktorer som inte innehåller en pekarparameter. De parametrar som används av varje överlagring finns i överlagringssyntaxen ovan.

Här är en fullständig lista över parametrar som används av String konstruktorer som innehåller en pekarparameter. De parametrar som används av varje överlagring finns i överlagringssyntaxen ovan.

Undantag

Här är en lista över undantag som genereras av konstruktorer som inte innehåller pekarparametrar.

Här är en lista över undantag som genereras av konstruktorer som innehåller pekarparametrar.

Vilken metod anropar jag?

Skapa strängar

Den vanligaste tekniken för att skapa strängar programmatiskt är enkel tilldelning, vilket visas i exempel 1. Klassen String innehåller också fyra typer av konstruktoröverlagringar som gör att du kan skapa strängar från följande värden:

• Från en teckenmatris (en matris med UTF-16-kodade tecken). Du kan skapa ett nytt String objekt från tecknen i hela matrisen eller en del av det. Konstruktorn String(Char[]) kopierar alla tecken i matrisen till den nya strängen. Konstruktorn String(Char[], Int32, Int32) kopierar tecknen från index startIndex till index startIndex + length – 1 till den nya strängen. Om length är noll är String.Emptyvärdet för den nya strängen .

  Om koden upprepade gånger instansierar strängar som har samma värde kan du förbättra programmets prestanda med hjälp av ett alternativt sätt att skapa strängar. Mer information finns i Hantera repetitiva strängar.

• Från ett enda tecken som dupliceras noll, en eller flera gånger genom att använda konstruktorn String(Char, Int32). Om count är noll är String.Emptyvärdet för den nya strängen .

• Från en pekare till en null-terminerad teckenmatris, med hjälp av String(Char*) eller String(Char*, Int32, Int32)-konstruktorn. Antingen kan hela matrisen eller ett angivet intervall användas för att initiera strängen. Konstruktorn kopierar en sekvens med Unicode-tecken från den angivna pekaren eller från den angivna pekaren plus startIndex och fortsätter till slutet av matrisen eller för length tecken. Om value är en null-pekare eller length är noll skapar konstruktorn en sträng vars värde är String.Empty. Om kopieringsåtgärden fortsätter till slutet av matrisen och matrisen inte är null-avslutad är konstruktorns beteende systemberoende. Ett sådant villkor kan orsaka en åtkomstöverträdelse.

  Om matrisen innehåller inbäddade null-tecken (U+0000 eller \0) och överlagringen String(Char*, Int32, Int32) anropas innehåller length stränginstansen tecken inklusive inbäddade null-värden. I följande exempel visas vad som händer när en pekare till en matris med 10 element som innehåller två null-tecken skickas till String(Char*, Int32, Int32) metoden. Eftersom adressen är början på matrisen och alla element i matrisen ska läggas till i strängen instansierar konstruktorn en sträng med tio tecken, inklusive två inbäddade null-värden. Om samma matris å andra sidan skickas till String(Char*) konstruktorn är resultatet en sträng med fyra tecken som inte innehåller det första null-tecknet.

  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
  

  Matrisen måste innehålla Unicode-tecken. I C++innebär det att teckenmatrisen måste definieras antingen som den hanterade Char[] typen eller den ohanteradewchar_t[]-typen.

  Om överlagringen String(Char*) anropas och matrisen inte är null-avslutad, eller om överlagringen String(Char*, Int32, Int32) anropas och startIndex + length-1 innehåller ett intervall som ligger utanför det minne som allokerats för teckensekvensen, är konstruktorns beteende systemberoende och en åtkomstöverträdelse kan inträffa.

• Från en pekare till en signerad bytematris. Antingen kan hela matrisen eller ett angivet intervall användas för att initiera strängen. Sekvensen med byte kan tolkas med hjälp av standardkodningstabellen, eller så kan en kodning anges i konstruktoranropet. Om konstruktorn försöker instansiera en sträng från en hel matris som inte är null-avslutad, eller om matrisintervallet från value + startIndex tillvalue + startIndex + length -1 ligger utanför det minne som allokerats för matrisen, är konstruktorns beteende systemberoende och en åtkomstöverträdelse kan inträffa.

  De tre konstruktorerna som innehåller en signerad bytematris som en parameter är främst utformade för att konvertera en C++- char matris till en sträng, enligt följande exempel:

  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
  

  Om arrayen innehåller några nulltecken ('\0') eller bytes med värdet 0 och överlagringen String(SByte*, Int32, Int32) anropas, innehåller stränginstansen length tecken, inklusive inbäddade nollor. I följande exempel visas vad som händer när en pekare till en matris med 10 element som innehåller två null-tecken skickas till String(SByte*, Int32, Int32) metoden. Eftersom adressen är början på matrisen och alla element i matrisen ska läggas till i strängen instansierar konstruktorn en sträng med tio tecken, inklusive två inbäddade null-värden. Om samma matris å andra sidan skickas till String(SByte*) konstruktorn är resultatet en sträng med fyra tecken som inte innehåller det första null-tecknet.

  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
  

  Eftersom konstruktorerna String(SByte*) och String(SByte*, Int32, Int32) tolkar value med hjälp av standard-ANSI-kodsidan kan anrop av dessa konstruktorer med identiska bytematriser skapa strängar som har olika värden på olika system.

Hantera repetitiva strängar

Appar som parsar eller avkodar textströmmar använder String(Char[], Int32, Int32) ofta konstruktorn eller StringBuilder.Append(Char[], Int32, Int32) metoden för att konvertera teckensekvenser till en sträng. Att upprepade gånger skapa nya strängar med samma värde i stället för att skapa och återanvända en sträng slösar minne. Om du förmodligen skapar samma strängvärde upprepade gånger genom att anropa String(Char[], Int32, Int32) konstruktorn, även om du inte i förväg vet vilka dessa identiska strängvärden kan vara, kan du använda en uppslagstabell i stället.

Anta till exempel att du läser och parsar en dataström med tecken från en fil som innehåller XML-taggar och attribut. När du parsar strömmen stöter du upprepade gånger på vissa token (det vill säga sekvenser med tecken som har en symbolisk betydelse). Token som motsvarar strängarna "0", "1", "true" och "false" kommer sannolikt att förekomma ofta i en XML-ström.

I stället för att konvertera varje token till en ny sträng kan du skapa ett System.Xml.NameTable objekt som ska innehålla vanliga strängar. Objektet NameTable förbättrar prestandan eftersom det hämtar lagrade strängar utan att allokera tillfälligt minne. När du stöter på en token använder du NameTable.Get(Char[], Int32, Int32) metoden för att hämta token från tabellen. Om token finns returnerar metoden motsvarande sträng. Om token inte finns använder du NameTable.Add(Char[], Int32, Int32) metoden för att infoga token i tabellen och hämta motsvarande sträng.

Exempel 1: Använd strängtilldelning

I följande exempel skapas en ny sträng genom att tilldela den en strängliteral. Den skapar en andra sträng genom att tilldela värdet för den första strängen till den. Det här är de två vanligaste sätten att instansiera ett nytt String objekt.

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.

Exempel 2: Använd en teckenmatris

I följande exempel visas hur du skapar ett nytt String objekt från en teckenmatris.

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

Exempel 3: Använd en del av en teckenmatris och upprepa ett enda tecken

I följande exempel visas hur du skapar ett nytt String objekt från en del av en teckenmatris och hur du skapar ett nytt String objekt som innehåller flera förekomster av ett enda tecken.

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

Exempel 4: Använd en pekare till en teckenmatris

I följande exempel visas hur du skapar ett nytt String objekt från en pekare till en matris med tecken. C#-exemplet måste kompileras med hjälp /unsafe av kompilatorväxeln.

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!

Exempel 5: Instansiera en sträng från en pekare och ett intervall för en matris

I följande exempel undersöks elementen i en teckenmatris för antingen en punkt eller ett utropstecken. Om en hittas instansierar den en sträng från tecknen i matrisen som föregår skiljeteckensymbolen. Annars instansierar den en sträng med hela innehållet i matrisen. C#-exemplet måste kompileras med hjälp av /unsafe kompilatorväxeln.

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

Exempel 6: Instansiera en sträng från en pekare till en signerad bytematris

I följande exempel visas hur du kan skapa en instans av String klassen med String(SByte*) konstruktorn.

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