C#-tekenreeksen

Tip

Dit artikel maakt deel uit van de sectie Grondbeginselen voor ontwikkelaars die al ten minste één programmeertaal kennen en C# leren. Als u nieuw bent in programmeren, begint u eerst met de Aan de slag-handleidingen.

Afkomstig van Java of C++? Een C# string is een onveranderbaar referentietype dat wordt ondersteund door String. UTF-16 is de codering in het geheugen, vergelijkbaar met de String van Java. In tegenstelling tot C/C++ worden strings niet met een nulteken afgesloten en worden ze niet automatisch omgezet naar pointers.

Een tekenreeks is een reeks tekens. In C# string is het taalwoord voor het System.String type. Elke stringliteral die u schrijft, levert een System.String instantie op.

string versus String

Het string trefwoord en de String typenaam verwijzen naar hetzelfde type. Ze compileren naar identieke intermediaire taal (IL).

// The 'string' keyword is an alias for System.String. The two are identical.
string a = "hello";
String b = "hello";

Console.WriteLine(a == b);                // True
Console.WriteLine(typeof(string) == typeof(String)); // True

Geef de voorkeur aan het string trefwoord in uw eigen code. Het is in lijn met de andere ingebouwde typezoekwoorden (int, bool, double), en het werkt zonder een using System;-directive.

Tekenreeksen zijn onveranderbaar

Onveranderbaar betekent dat de waarde niet kan worden gewijzigd nadat deze is gemaakt. Zodra u een string hebt gemaakt, kunt u de tekens niet meer wijzigen. Methoden zoals ToUpperInvariant, Replace, Substringen Trim retourneren een nieuwe tekenreeks die de gewijzigde waarde bevat. Het oorspronkelijke exemplaar blijft hetzelfde.

string greeting = "hello";

// ToUpper returns a *new* string. The original is unchanged.
string shouted = greeting.ToUpperInvariant();

Console.WriteLine(greeting);  // hello
Console.WriteLine(shouted);   // HELLO

Omdat tekenreeksen onveranderbaar zijn, kunt u ze veilig delen tussen methoden en threads. Deze onveranderbaarheid verklaart waarom het string type zich gedraagt als een waardetype in dagelijks gebruik, ook al is het een verwijzingstype.

Wanneer u in een lus een tekenreeks opbouwt uit veel kleine stukjes, gebruikt u StringBuilder om deze ter plekke samen te voegen en aan het einde één tekenreeks te produceren:

// For many sequential edits, StringBuilder avoids allocating a new string each time.
var builder = new StringBuilder();
for (int i = 1; i <= 3; i++)
{
    builder.Append("item ").Append(i).Append(';');
}
string result = builder.ToString();
Console.WriteLine(result);    // item 1;item 2;item 3;

Letterlijke tekenreeksen

C# biedt vier letterlijke vormen. Elk formulier past bij verschillende inhoud. Als beknopte handleiding:

  • Gebruik reguliere letterlijke gegevens voor korte, eenvoudige tekst met maximaal een paar escapereeksen.
  • Gebruik woordelijke letterlijke waarden wanneer backslashes de inhoud domineren, zoals bij Windows-paden of regex-patronen.
  • Gebruik letterlijke tekenreeksen voor tekst met meerdere regels of structureel opgemaakte tekst, zoals inline JSON, SQL, XML of opgemaakte berichtblokken.
  • Voeg een $ voorvoegsel toe aan een van de bovenstaande letterlijke waarden om een geïnterpoleerde tekenreeks op te halen wanneer u waarden wilt insluiten.
  • Voeg een u8 achtervoegsel toe aan een letterlijke om een UTF-8 bytereeks (a ReadOnlySpan<T> van byte) te produceren voor bytegeoriënteerde API's. Zie letterlijke UTF-8-tekenreeksen in de taalverwijzing voor meer informatie.

Reguliere letterlijke en escapereeksen

Een gewone letterlijke tekenreeks wordt tussen dubbele aanhalingstekens geplaatst. Backslash start een escapesequentie:

// Common escape sequences inside a regular string literal.
string tabbed   = "name:\tAda";          // \t  tab
string twoLines = "line 1\nline 2";      // \n  newline
string quoted   = "She said \"hi\".";    // \"  literal quote
string path     = "C:\\src\\app";        // \\  literal backslash

Console.WriteLine(tabbed);
Console.WriteLine(twoLines);
Console.WriteLine(quoted);
Console.WriteLine(path);

Veelvoorkomende escapereeksen zijn \n (newline), \t (tab), \" (letterlijke aanhalingsteken), \\ (letterlijke backslash), \0 (null-teken) en Unicode-escapes (\uXXXX, \UXXXXXXXX).

Vanaf C# 13 vertegenwoordigt \e het ESC-besturingsteken (U+001B). Het is de startbyte voor ANSI-terminal-escapesequenties:

// Beginning in C# 13, \e represents the ESC control character (U+001B).
// It's used to start ANSI terminal escape sequences.
string esc = "\e[31mError\e[0m: file missing";

Console.WriteLine(esc);                  // ESC[31mError ESC[0m: file missing
Console.WriteLine((int)'\e');          // 27

Gebruik een gewone literal als de tekst kort is en slechts een handvol escapereeksen bevat. Zodra het aantal escapecodes groter dreigt te worden dan het aantal zichtbare tekens, gebruikt u een verbatim- of raw-stringliteral.

Letterlijke tekst

Een letterlijk citaat wordt voorafgegaan door @. Backslashes worden letterlijk geïnterpreteerd, wat handig is voor Windows-paden en reguliere-expressiepatronen:

// A verbatim string literal (@) treats backslashes literally.
// Useful for Windows paths and regular expressions.
string winPath = @"C:\src\app\readme.md";
string pattern = @"\d{3}-\d{4}";

Console.WriteLine(winPath);
Console.WriteLine(pattern);

Als u een letterlijk aanhalingsteken in een verbatim-tekenreeks wilt opnemen, verdubbel het dan: @"She said ""hi"".". Verbatimtekenreeksen kunnen ook meerdere fysieke regels omvatten.

Verbatim-literals zijn de beste keuze als backslashes onderdeel van de inhoud zijn, maar er niet veel ingesloten aanhalingstekens in voorkomen. Voor tekst met meerdere regels of inhoud met aanhalingstekens zijn letterlijke tekenreeksen meestal duidelijker.

Letterlijke onbewerkte tekenreeksen

Gebruik voor letterlijke elementen die aanhalingstekens, backslashes of meerdere regels bevatten bij voorkeur raw string literals. Ze elimineren volledig escape-ruis, waardoor ze het beste passen bij inline JSON, SQL, XML, regex-patronen en opgemaakte tekstblokken waar de bron eruit moet zien als de uitvoer:

// Raw string literals use three or more quotes and need no escaping.
// The source looks like the output, which is ideal for inline JSON, SQL, XML, and the like.
string json = """
    {
        "name": "Ada",
        "roles": ["admin", "editor"]
    }
    """;

string sql = """
    SELECT Id, Name
    FROM   Users
    WHERE  Name = 'O''Brien'
    """;

Console.WriteLine(json);
Console.WriteLine(sql);

Ruwe tekenreeksliteralen maken escape-sequenties vrijwel overbodig en maken elke gewenste opmaak en aanhaling mogelijk. Zie raw-stringliteralen voor de volledige regels.

Geïnterpoleerde tekenreeksen

Een $ voorvoegsel verandert een letterlijke tekenreeks in een geïnterpoleerde tekenreeks. Expressies in {}-plaatsaanduidingen worden geëvalueerd en de resultaten worden ingevoegd, en u kunt standaard-opmaakspecificaties en uitlijning in die plaatsaanduidingen toepassen. Interpolatie kan ook worden gecombineerd met de andere letteraalvormen: gebruik $@"..." om een letterlijk letteraal te interpoleren, of $"""...""" om een onbewerkte tekenreeksliteraal te interpoleren voor uitgebreid opgemaakte uitvoer:

// The $ prefix evaluates expressions inside { } and inserts their values.
string name = "Ada";
int score = 92;

string greeting = $"Hello, {name}! Your score is {score}.";
// Format specifiers and alignment work inside the holes.
string formatted = $"pi = {Math.PI:F3}, padded = |{name,10}|";

// Combine $ and """ for richly formatted multiline output.
string report = $"""
    Report for {name}
    -----------------
    Score : {score}
    Grade : {(score >= 90 ? "A" : "B")}
    """;

Console.WriteLine(greeting);
Console.WriteLine(formatted);
Console.WriteLine(report);

Interpolatie is de aanbevolen manier om tekenreeksen op te stellen op basis van waarden in dagelijkse code.

Indexeren en char

A string is een reeks UTF-16-code-eenheden. De indexeerfunctie retourneert er een System.Char, die één UTF-16-code-eenheid vertegenwoordigt, niet noodzakelijkerwijs een volledig Unicode-codepunt. Length retourneert het aantal code-eenheden.

// A string is a sequence of UTF-16 code units. s[i] returns one char.
string word = "café";

Console.WriteLine(word.Length);          // 4
Console.WriteLine(word[0]);              // c

foreach (char c in word)
{
    Console.Write($"{c} ");              // c a f é
}
Console.WriteLine();

Voor tekst die emoji of tekens buiten het Basic Multilingual Plane kan bevatten, kunt u per rune itereren met Rune of per grafeemcluster met StringInfo. Gewone iteratie char werkt voor de meeste westerse tekst en inhoud die voornamelijk uit ASCII bestaat.

Gelijkheid van tekenreeksen

Gelijkheid van string vergelijkt de tekenreeksen, niet de verwijzingen:

// String equality compares character sequences, not references.
string left  = "hello";
string right = string.Concat("hel", "lo");

Console.WriteLine(left == right);                                      // True
Console.WriteLine(left.Equals(right, StringComparison.Ordinal));       // True

Geef een expliciete StringComparison waarde door voor vergelijkingen die landbewust of hoofdletterbewust moeten zijn. Gebruiken StringComparison.Ordinal voor protocolwaarden, id's en andere niet-taalkundige tekst.

Algemene tekenreeksbewerkingen

Gebruik de volgende tabel als een snelle handleiding voor dagelijkse tekenreeksbewerkingen in C#:

Categorie Wat het omvat
Search Tekens of subtekenreeksen zoeken, voorvoegsels en achtervoegsels testen
Split Een tekenreeks opsplitsen in substrings op basis van scheidingstekens
Samenvoegen Tekenreeksen combineren — +, interpolatie, , ConcatJoin
Modify Een getransformeerde kopie produceren — Replace, TrimSubstring
Vergelijken Test gelijkheid en sortering met de juiste StringComparison

Het volledige API-oppervlak ( elke overbelasting, elke methode) wordt beschreven in de String verwijzing.

Zie ook

  • Last updated on