C# karakterláncok

Jótanács

Ez a cikk az Alapismeretek szakasz része azon fejlesztők számára, akik már legalább egy programozási nyelvet ismernek, és c#-t tanulnak. Ha még csak most ismerkedik a programozással, először az Első lépések oktatóanyagokkal kezdje.

Java vagy C++-ból jön? A C# string egy nem módosítható referenciatípus, amelynek alapja a(z) String. Az UTF-16 az Java String-hez hasonló memóriabeli kódolás. A C/C++-szal ellentétben a karakterláncok nincsenek null karakterrel lezárva, és nem alakulnak mutatókká.

A karakterlánc karakterek sorozata. A C#-ban a(z) string a(z) System.String típus nyelvi kulcsszava. Minden írott sztringkonstans létrehoz egy példányt System.String .

string és String

A string kulcsszó és a String típusnév ugyanarra a típusra hivatkozik. Azonos köztes nyelvre (IL) fordítják le őket.

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

Részesítse előnyben a(z) string kulcsszót a saját kódjában. Összhangban van a többi beépített típuskulcsszóval (int, bool, double), és using System; irányelv nélkül is működik.

A sztringek nem módosíthatók

A nem módosítható érték azt jelenti, hogy az érték nem módosítható a létrehozása után. Miután létrehoz egy string-t, nem módosíthatja a karaktereit. Metódusok, például ToUpperInvariant, Replace, Substringés Trim egy új sztringet ad vissza, amely tartalmazza a módosított értéket. Az eredeti példány változatlan marad.

string greeting = "hello";

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

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

Mivel a sztringek nem módosíthatók, biztonságosan megoszthatja őket metódusok és szálak között. Ez a megváltoztathatatlanság megmagyarázza, hogy a string típus miért viselkedik értéktípusként a mindennapi használatban annak ellenére, hogy referenciatípus.

Ha egy ciklusban sok kis darabból épít fel egy karakterláncot, használja a(z) StringBuilder elemet a helyben történő hozzáfűzéshez, így a végén egyetlen karakterláncot kap:

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

Sztringkonstansok

A C# négy literális űrlapot kínál. Minden űrlap különböző tartalomnak felel meg. Gyors útmutatóként:

  • Használjon reguláris literálokat rövid, egyszerű szöveghez, legfeljebb néhány menekülési sorozattal.
  • Használjon verbatim literálokat amikor a fordított perjelek uralják a tartalmat, például Windows elérési utakat vagy regex-mintákat.
  • Használjon nyers sztringkonstansokat többsoros vagy szerkezetileg formázott szövegekhez, például beágyazott JSON-, SQL-, XML- vagy formázott üzenetblokkokhoz.
  • Adjon hozzá egy $ előtagot a fent említett literálok bármelyikéhez, hogy interpolált sztringet kapjon, amikor értékeket kell beágyaznia.
  • Adja hozzá a u8 utótagot egy literálhoz, hogy UTF-8 bájtszekvenciát kapjon (egy ReadOnlySpan<T>byte), bájtorientált API-k számára. Az UTF-8 string literálokról a nyelvi referenciában talál további részleteket.

Reguláris literálok és feloldósorozatok

A hagyományos karakterlánc-literált dupla idézőjelek közé kell írni. A fordított perjel egy menekülési sorozatot indít el:

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

A gyakori feloldási sorozatok közé tartoznak a \n (newline), \t (tab), \" (literális idézőjel), \\ (literál fordított perjel), \0 (null karakter) és Unicode-feloldások (\uXXXX, \UXXXXXXXX).

A C# 13-tól \e kezdődően az ESC vezérlő karaktert (U+001B) jelöli. Ez az ANSI-terminál menekülési sorozatainak kezdő bájtja:

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

Használjon normál literált, ha a szöveg rövid, és csak néhány feloldósorozatot tartalmaz. Miután a feloldások elkezdenek túllépni a látható karakterek számán, váltson szó szerinti vagy nyers literálra.

Szó szerinti literálok

A szó szerinti literált a @ előzi meg. A visszaperjelek szó szerint értelmeződnek, ami hasznos a Windows elérési utak és a reguláriskifejezés-minták esetében:

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

Ha szó szerinti idézőjelet szeretne beágyazni egy szó szerinti sztringbe, duplázza meg: @"She said ""hi"".". A szó szerinti karakterláncok több fizikai soron is átnyúlhatnak.

A szó szerinti literálok a megfelelő választást jelentik, ha a visszaperjelek is a tartalom részét alkotják, de nincs bennük sok beágyazott idézőjel. Többsoros szöveg vagy idézőjeleket tartalmazó tartalom esetén a nyers karakterlánc-literálok általában áttekinthetőbbek.

Nyers szöveges literálok

Minden olyan literál esetében, amely idézőjeleket, fordított perjeleket vagy több sorból álló tartalmat tartalmaz, részesítse előnyben a nyers sztringliterálokat. Teljesen kiküszöbölik a menekülési zajt, ami a legjobban illeszkedik a beágyazott JSON-, SQL-, XML-, regex-mintákhoz és formázott szövegblokkokhoz, ahol a forrásnak a kimenethez hasonlóan kell kinéznie:

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

A nyers sztringliterálok szinte teljesen kiküszöbölik az escape szekvenciákat, és lehetővé tesznek bármilyen formázást és idézőjelezést, amelyre szüksége van. A teljes szabályokat lásd itt: Nyers karakterlánc-literálok.

Interpolált karakterláncok

Az $ előtag a literált interpolált sztringgé teszi. A lyukakban lévő {} kifejezések kiértékelése és az eredmények beszúrása, valamint szabványos formátumkijelölők és igazítás alkalmazása a lyukakon belül. Az interpoláció a többi konstansformmal is kombinálható – $@"..." a szó szerinti literál interpolálására, vagy $"""...""" egy nyers sztringkonstans interpolálására a gazdagon formázott kimenethez:

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

Az interpoláció az ajánlott módszer karakterláncok értékekből történő összeállítására a mindennapi programozásban.

Indexelés és char

Az A string az UTF-16 kódegységek sorozata. Az indexelő egy System.Charolyan értéket ad vissza, amely egyetlen UTF-16 kódegységet jelöl, nem feltétlenül egy teljes Unicode-kódpontot. Length A kódegységek számát adja vissza.

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

Az olyan szövegek esetén, amelyek emojikat vagy az alapsíkon kívüli karaktereket is tartalmazhatnak, iteráljon rune szerint a Rune használatával, vagy gráfémaklaszterek szerint a StringInfo használatával. Az egyszerű char iteráció a legtöbb nyugati szöveghez és ASCII-domináns tartalomhoz használható.

Sztring egyenlősége

A(z) string egyenlőségjel a karaktersorozatokat hasonlítja össze, nem a referenciákat:

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

Azoknak az összehasonlításoknak, amelyeknek területi vagy esetérzékenynek kell lenniük, adjon meg egy explicit StringComparison értéket. Protokollértékekhez, azonosítókhoz és más nem nyelvi szövegekhez használható StringComparison.Ordinal .

Gyakori sztringműveletek

A C#-ban végzett mindennapos sztringműveletek gyors útmutatójaként használja az alábbi táblázatot:

Kategória A témakör a következőket tartalmazza:
Kereső Karakterek vagy alsztringek keresése, előtagok és utótagok tesztelése
Split Karakterlánc felosztása részkarakterláncokra elválasztók mentén
Összefűzés Sztringek egyesítése – +, interpoláció, Concat, Join
Modify Átalakított másolat készítése – Replace, , TrimSubstring
Compare Az egyenlőség és a sorrend tesztelése a megfelelő StringComparison használatával

A referencia dokumentálja a teljes API-felületet – minden túlterhelést, minden metódust String .

Lásd még

  • Last updated on