Nieuwe tekenreeksen maken in .NET

Met .NET kunnen tekenreeksen worden gemaakt met behulp van eenvoudige toewijzing en wordt ook een klasseconstructor overbelast om het maken van tekenreeksen te ondersteunen met behulp van een aantal verschillende parameters. .NET biedt ook verschillende methoden in de System.String klasse waarmee nieuwe tekenreeksobjecten worden gemaakt door verschillende tekenreeksen, matrices van tekenreeksen of objecten te combineren.

Strings maken door toewijzing

De eenvoudigste manier om een nieuw String object te maken, is door een letterlijke tekenreeks toe te wijzen aan een String object.

Maak tekenreeksen met een klasseconstructor

U kunt overloads van de String klasseconstructor gebruiken om tekenreeksen te maken op basis van karakterarrays. U kunt ook een nieuwe tekenreeks maken door een bepaald teken een bepaald aantal keren te dupliceren. De String(ReadOnlySpan<Char>) constructor-overload accepteert een ReadOnlySpan<T> of een stack-gealloceerde Span<T> karakters en vermijdt het toewijzen van een tussenliggende tekenreeks-array op de beheerde heap wanneer u kleine tekenreeksen van een bekende grootte maakt, hoewel het resulterende tekenreeksexemplaar nog steeds wordt toegewezen op de beheerde heap.

Methoden die tekenreeksen retourneren

De volgende tabel bevat verschillende nuttige methoden die nieuwe tekenreeksobjecten retourneren.

String.Format

U kunt de String.Format methode gebruiken om opgemaakte tekenreeksen te maken en tekenreeksen samen te voegen die meerdere objecten vertegenwoordigen. Met deze methode worden alle doorgegeven objecten automatisch geconverteerd naar een tekenreeks. Als uw toepassing bijvoorbeeld een Int32 waarde en een DateTime waarde voor de gebruiker moet weergeven, kunt u eenvoudig een tekenreeks maken om deze waarden weer te geven met behulp van de Format methode. Zie de sectie over samengestelde opmaak voor informatie over opmaakconventies die met deze methode worden gebruikt.

In het volgende voorbeeld wordt de Format-methode gebruikt om een tekenreeks te maken die gebruikmaakt van een variabele voor een geheel getal.

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.

In dit voorbeeld DateTime.Now wordt de huidige datum en tijd weergegeven op een manier die is opgegeven door de cultuur die is gekoppeld aan de huidige thread.

String.Concat

De String.Concat methode kan worden gebruikt om eenvoudig een nieuw tekenreeksobject te maken op basis van twee of meer bestaande objecten. Het biedt een taalonafhankelijke manier om tekenreeksen samen te voegen. Deze methode accepteert elke klasse die is afgeleid van System.Object. In het volgende voorbeeld wordt een tekenreeks gemaakt van twee bestaande tekenreeksobjecten en een scheidingsteken.

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

Met de String.Join methode wordt een nieuwe tekenreeks gemaakt op basis van een matrix met tekenreeksen en een scheidingstekenreeks. Deze methode is handig als u meerdere tekenreeksen wilt samenvoegen, waardoor een lijst mogelijk wordt gescheiden door een komma.

In het volgende voorbeeld wordt een spatie gebruikt om een tekenreeksmatrix te binden.

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

Met de String.Insert methode wordt een nieuwe tekenreeks gemaakt door een tekenreeks in te voegen in een opgegeven positie in een andere tekenreeks. Deze methode maakt gebruik van een op nul gebaseerde index. In het volgende voorbeeld wordt een tekenreeks ingevoegd in de vijfde indexpositie van MyString en wordt een nieuwe tekenreeks met deze waarde gemaakt.

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

Met de String.CopyTo methode worden delen van een tekenreeks gekopieerd naar een matrix met tekens. U kunt zowel de beginindex van de tekenreeks als het aantal tekens opgeven dat moet worden gekopieerd. Deze methode gebruikt de bronindex, een matrix met tekens, de doelindex en het aantal tekens dat moet worden gekopieerd. Alle indexen zijn gebaseerd op nul.

In het volgende voorbeeld wordt de CopyTo methode gebruikt om de tekens van het woord 'Hallo' van een tekenreeksobject naar de eerste indexpositie van een matrix met tekens te kopiëren.

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

Met de String.Create methode kunt u programmatisch de tekens van een nieuwe tekenreeks vullen met behulp van een callback. De callback ontvangt een schrijfbare reeks Span<T> tekens en een door de aanroeper opgegeven statusobject, zodat u de inhoud van de tekenreeks kunt maken zonder tussenliggende tekenbuffers toe te wijzen. De callback zelf kan nog steeds leiden tot allocaties, bijvoorbeeld als er lokale variabelen worden opgeslagen of wanneer andere API's worden aangeroepen die veel middelen vereisen.

In het volgende voorbeeld wordt een String.Create tekenreeks van vijf tekens gemaakt op basis van opeenvolgende alfabettekens:

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 is ontworpen voor prestatiegevoelige scenario's waarbij u de uiteindelijke tekenreekslengte van tevoren kent en wilt voorkomen dat tussenliggende tekenbuffers worden toegekend. De runtime wijst een nieuwe tekenreeks toe, geeft de backingbuffer rechtstreeks door aan uw callback als een Span<char>en retourneert de onveranderbare tekenreeks zodra de callback wordt geretourneerd. Er vindt geen kopie van de gegevens plaats nadat de callback is voltooid.

String.Create versus new String(Span<char>)

Een andere optie voor het efficiënt opbouwen van tekenreeksen is het toewijzen van een tekenbuffer met stackalloc, deze vullen en overdragen aan de String(ReadOnlySpan<char>) constructor.

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

Beide benaderingen wijzen de uiteindelijke tekenreeks precies één keer toe. De belangrijkste verschillen zijn:

• stackalloc + new string(span) plaatst de werkbuffer op de stapel. Dit is het snelst voor kleine buffers met vaste grootte, maar de stack is een beperkte bron; grote of diep geneste allocaties kunnen een StackOverflowException. In dit voorbeeld ziet u het C# stackalloc-patroon; Visual Basic biedt geen ondersteuning voor stackalloc, maar kan echter nog steeds de String(ReadOnlySpan<char>)-constructor aanroepen wanneer u een ReadOnlySpan<char> heeft.
• String.Create wijst de werkbuffer aan op de heap als integraal onderdeel van het string-object zelf, waardoor er geen belasting op de stack plaatsvindt. Het accepteert ook een getypeerde statusparameter die de runtime doorgeeft aan uw callback zonder boxing, waardoor boxing-allocaties worden voorkomen wanneer de status een referentietype of een niet-vastgelegde structuur is. Over het algemeen geeft u de voorkeur aan stackalloc + new String(span) kleine tekenreeksen (meestal minder dan een paar honderd tekens) met een bekende, gebonden grootte. Gebruik String.Create deze functie wanneer de grootte groot kan zijn, wanneer u stapeldruk wilt voorkomen of wanneer u de status doorgeeft aan de callback zonder boksen.

Zie ook

• samengestelde opmaak