Skapa nya strängar i .NET

.NET tillåter att strängar skapas med enkel tilldelning och överbelastar även en klasskonstruktor för att stödja skapandet av strängar med hjälp av ett antal olika parametrar. .NET innehåller också flera metoder i System.String klassen som skapar nya strängobjekt genom att kombinera flera strängar, matriser med strängar eller objekt.

Skapa strängar med hjälp av tilldelning

Det enklaste sättet att skapa ett nytt String objekt är helt enkelt att tilldela en strängliteral till ett String objekt.

Skapa strängar med hjälp av en klasskonstruktor

Du kan använda överlagringar av String klasskonstruktorn för att skapa strängar från teckenmatriser. Du kan också skapa en ny sträng genom att duplicera ett visst tecken ett angivet antal gånger. Konstruktorns String(ReadOnlySpan<Char>) överlagring accepterar en ReadOnlySpan<T> eller en stackallokerad Span<T> av tecken och undviker tilldelning av en intermediär teckenmatris på den hanterade heapen när du skapar små strängar av en känd storlek. Dock allokeras den resulterande stränginstansen fortfarande på den hanterade heapen.

Metoder som returnerar strängar

I följande tabell visas flera användbara metoder som returnerar nya strängobjekt.

String.Format

Du kan använda metoden String.Format för att skapa formaterade strängar och sammanfoga strängar som representerar flera objekt. Den här metoden konverterar automatiskt alla skickade objekt till en sträng. Om ditt program till exempel måste visa ett Int32 värde och ett DateTime värde för användaren kan du enkelt skapa en sträng för att representera dessa värden med hjälp av Format metoden. Information om formateringskonventioner som används med den här metoden finns i avsnittet om sammansatt formatering.

I följande exempel används Format metoden för att skapa en sträng som använder en heltalsvariabel.

int numberOfFleas = 12;
string miscInfo = String.Format("Your dog has {0} fleas. " +
                                "It is time to get a flea collar. " +
                                "The current universal date is: {1:u}.",
                                numberOfFleas, DateTime.Now);
Console.WriteLine(miscInfo);
// The example displays the following output:
//       Your dog has 12 fleas. It is time to get a flea collar.
//       The current universal date is: 2008-03-28 13:31:40Z.

Dim numberOfFleas As Integer = 12
Dim miscInfo As String = String.Format("Your dog has {0} fleas. " & _
                                       "It is time to get a flea collar. " & _
                                       "The current universal date is: {1:u}.", _
                                       numberOfFleas, Date.Now)
Console.WriteLine(miscInfo)
' The example displays the following output:
'       Your dog has 12 fleas. It is time to get a flea collar. 
'       The current universal date is: 2008-03-28 13:31:40Z.

I det här exemplet DateTime.Now visas aktuellt datum och tid på ett sätt som anges av kulturen som är associerad med den aktuella tråden.

String.Concat

Metoden String.Concat kan användas för att enkelt skapa ett nytt strängobjekt från två eller flera befintliga objekt. Det ger ett språkoberoende sätt att sammanfoga strängar. Den här metoden accepterar alla klasser som härleds från System.Object. I följande exempel skapas en sträng från två befintliga strängobjekt och ett avgränsande tecken.

string helloString1 = "Hello";
string helloString2 = "World!";
Console.WriteLine(String.Concat(helloString1, ' ', helloString2));
// The example displays the following output:
//      Hello World!

Dim helloString1 As String = "Hello"
Dim helloString2 As String = "World!"
Console.WriteLine(String.Concat(helloString1, " "c, helloString2))
' The example displays the following output:
'      Hello World!

String.Join

Metoden String.Join skapar en ny sträng från en matris med strängar och en avgränsningssträng. Den här metoden är användbar om du vill sammanfoga flera strängar, vilket gör en lista kanske avgränsad med ett kommatecken.

I följande exempel används ett blanksteg för att binda en strängmatris.

string[] words = {"Hello", "and", "welcome", "to", "my" , "world!"};
Console.WriteLine(String.Join(" ", words));
// The example displays the following output:
//      Hello and welcome to my world!

Dim words() As String = {"Hello", "and", "welcome", "to", "my", "world!"}
Console.WriteLine(String.Join(" ", words))
' The example displays the following output:
'      Hello and welcome to my world!

String.Insert

Metoden String.Insert skapar en ny sträng genom att infoga en sträng i en angiven position i en annan sträng. Den här metoden använder ett nollbaserat index. I följande exempel infogas en sträng i den femte indexpositionen i MyString och skapar en ny sträng med detta värde.

string sentence = "Once a time.";
 Console.WriteLine(sentence.Insert(4, " upon"));
 // The example displays the following output:
 //      Once upon a time.

Dim sentence As String = "Once a time."
Console.WriteLine(sentence.Insert(4, " upon"))
' The example displays the following output:
'      Once upon a time.

String.CopyTo

Metoden String.CopyTo kopierar delar av en sträng till en matris med tecken. Du kan ange både början index för strängen och antalet tecken som ska kopieras. Den här metoden tar källindexet, en matris med tecken, målindexet och antalet tecken som ska kopieras. Alla index är nollbaserade.

I följande exempel används CopyTo metoden för att kopiera tecknen i ordet "Hello" från ett strängobjekt till den första indexpositionen för en matris med tecken.

string greeting = "Hello World!";
char[] charArray = {'W','h','e','r','e'};
Console.WriteLine($"The original character array: {new string(charArray)}");
greeting.CopyTo(0, charArray,0 ,5);
Console.WriteLine($"The new character array: {new string(charArray)}");
// The example displays the following output:
//       The original character array: Where
//       The new character array: Hello

Dim greeting As String = "Hello World!"
Dim charArray() As Char = {"W"c, "h"c, "e"c, "r"c, "e"c}
Console.WriteLine("The original character array: {0}", New String(charArray))
greeting.CopyTo(0, charArray, 0, 5)
Console.WriteLine("The new character array: {0}", New String(charArray))
' The example displays the following output:
'       The original character array: Where
'       The new character array: Hello

String.Create

Med String.Create metoden kan du programmatiskt fylla en ny strängs tecken med hjälp av ett återanrop. Återanropet tar emot en skrivbar Span<T> mängd tecken och ett tillståndsobjekt från anroparen, så att du kan skapa strängens innehåll utan att allokera mellanliggande teckenbuffertar. Återanropet kan fortfarande göra allokeringar, till exempel om det fångar upp lokala variabler eller anropar andra allokeringsintensiva API:er.

I följande exempel används String.Create för att skapa en sträng med fem tecken från på varandra följande alfabettecken:

string result = string.Create(5, 'a', (span, firstChar) =>
{
    for (int i = 0; i < span.Length; i++)
    {
        span[i] = (char)(firstChar + i);
    }
});

Console.WriteLine(result); // abcde

Module Program
    Sub Main()
        Dim result As String = String.Create(5, "a"c, Sub(span, firstChar)
                                                           For i As Integer = 0 To span.Length - 1
                                                               span(i) = ChrW(AscW(firstChar) + i)
                                                           Next
                                                       End Sub)

        Console.WriteLine(result) ' abcde
    End Sub
End Module

String.Create är utformad för prestandakänsliga scenarier där du vet den sista stränglängden i förväg och vill undvika allokering av mellanliggande teckenbuffertar. Körtiden allokerar en ny sträng, skickar dess stödbuffert direkt till återanropet som en Span<char>, och returnerar den oföränderliga strängen när återanropet återkommer. Ingen kopia av datan görs efter att återanropet har slutförts.

String.Create jämfört med new String(Span<char>)

Ett annat alternativ för att skapa strängar effektivt är att allokera en teckenbuffert med stackalloc, fylla den och skicka den till String(ReadOnlySpan<char>) konstruktorn:

static string CreateStringFromSpan()
{
    Span<char> span = stackalloc char[5];
    for (int i = 0; i < 5; i++)
    {
        span[i] = (char)('a' + i);
    }
    return new string(span);
}

Console.WriteLine(CreateStringFromSpan()); // abcde

Båda metoderna allokerar den sista strängen exakt en gång. De viktigaste skillnaderna är:

• stackalloc + new string(span) lägger arbetsbufferten på stacken. Detta är snabbast för små buffertar med fast storlek , men stacken är en begränsad resurs. stora eller djupt kapslade allokeringar kan orsaka en StackOverflowException. Det här exemplet visar C#- stackalloc mönstret. Visual Basic stöder stackallocinte , men det kan fortfarande anropa String(ReadOnlySpan<char>) konstruktorn när du har en ReadOnlySpan<char>.
• String.Create allokerar arbetsbufferten i heap-minnet som en del av själva strängobjektet, så det finns inget stacktryck. Den accepterar också en typad tillståndsparameter som körningen skickar till callback utan boxning, vilket undviker boxningsallokeringar när tillståndet är en referenstyp eller en icke-fångad struct. I allmänhet föredrar du stackalloc + new String(span) små strängar (vanligtvis färre än några hundra tecken) med en känd, begränsad storlek. Använd String.Create när storleken kan vara stor, när du vill undvika stacktryck eller när du skickar tillstånd till återanropet utan boxning.

Se även

• Sammansatt formatering