Sztringek és sztringkonstansok

  • Cikk

A sztring olyan típusú String objektum, amelynek értéke szöveg. A szöveg belsőleg szekvenciális írásvédett objektumgyűjteményként Char van tárolva. A C#-sztring végén nincs null-végződésű karakter; ezért egy C#-sztring tetszőleges számú beágyazott null karaktert (\0) tartalmazhat. A Length sztring tulajdonsága a benne található objektumok számát Char jelöli, nem a Unicode-karakterek számát. A sztring egyes Unicode-kódpontjainak eléréséhez használja az StringInfo objektumot.

sztring és System.String

A C#-ban a string kulcsszó a következő aliasa String: . Ezért, String és string egyenértékű, függetlenül attól, hogy javasoljuk, hogy használja a megadott alias string , mivel működik még nélkül using System;. Az String osztály számos módszert kínál a sztringek biztonságos létrehozására, manipulálására és összehasonlítására. Emellett a C# nyelv túlterhel néhány operátort a gyakori sztringműveletek egyszerűsítése érdekében. A kulcsszóval kapcsolatos további információkért lásd a sztringet. A típussal és a metódusokkal kapcsolatos további információkért lásd: String.

Sztringek deklarálása és inicializálása

A sztringeket többféleképpen deklarálhatja és inicializálhatja az alábbi példában látható módon:

// Declare without initializing.
string message1;

// Initialize to null.
string message2 = null;

// Initialize as an empty string.
// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

// Initialize with a regular string literal.
string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.
string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.
System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)
// you can use implicit typing.
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from
// being used to store another string value.
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating
// a string from a char*, char[], or sbyte*. See
// System.String documentation for details.
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

Az új operátor nem használ sztringobjektumot, csak akkor, ha karaktertömbbel inicializálja a sztringet.

Inicializáljon egy állandó értékkel rendelkező Empty sztringet egy olyan új String objektum létrehozásához, amelynek a sztringje nulla hosszúságú. A nulla hosszúságú sztring literális ábrázolása "". A null érték helyett a Empty sztringek inicializálásával csökkentheti az előfordulások esélyét.NullReferenceException A statikus IsNullOrEmpty(String) metódussal ellenőrizze egy sztring értékét, mielőtt megpróbálná elérni.

Sztringek nem módosíthatók

A sztringobjektumok nem módosíthatók: létrehozásuk után nem módosíthatók. String Az összes olyan metódus és C#-operátor, amely úgy tűnik, hogy módosít egy sztringet, valójában egy új sztringobjektumban adja vissza az eredményeket. A következő példában, amikor a két eredeti sztring tartalma s1 egyetlen sztringet alkot, és s2 összefűzve van összefűzve, a rendszer nem módosítja a két eredeti sztringet. Az += operátor létrehoz egy új sztringet, amely tartalmazza a kombinált tartalmat. Az új objektum hozzá van rendelve a változóhoz s1, és a hozzárendelt s1 eredeti objektumot a rendszer felszabadítja a szemétgyűjtéshez, mert más változó nem tartalmaz rá mutató hivatkozást.

string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.

Mivel a sztring módosítása valójában egy új sztring létrehozása, körültekintően kell eljárnia, amikor sztringekre mutató hivatkozásokat hoz létre. Ha létrehoz egy sztringre mutató hivatkozást, majd "módosítja" az eredeti sztringet, a hivatkozás továbbra is az eredeti objektumra fog mutatni a sztring módosításakor létrehozott új objektum helyett. A következő kód ezt a viselkedést szemlélteti:

string str1 = "Hello ";
string str2 = str1;
str1 += "World";

System.Console.WriteLine(str2);
//Output: Hello

További információ arról, hogyan hozhat létre olyan új sztringeket, amelyek olyan módosításokon alapulnak, mint a keresési és csereműveletek az eredeti sztringen, olvassa el a Sztring tartalmának módosítása című témakört.

Idézett sztringkonstansok

Az idézőjeles sztringkonstansok egyetlen dupla idézőjel karakterrel (") kezdődnek és végződnek ugyanazon a sorban. Az idézőjeles sztringkonstansok olyan sztringekhez ideálisak, amelyek egyetlen sorra illeszkednek, és nem tartalmaznak feloldósorozatokat. Az idézőjeles sztringkonstansnak feloldó karaktereket kell beágyaznia az alábbi példában látható módon:

string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1        Column 2        Column 3

string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
    Row 1
    Row 2
    Row 3
*/

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Verbatim sztringkonstansok

A verbatim sztringkonstansok kényelmesebbek többsoros sztringekhez, fordított perjel karaktereket tartalmazó sztringekhez vagy beágyazott dupla idézőjelekhez. A verbatim sztringek megőrzik az új sorkarakterek a sztringszöveg részeként. Idézőjelek használatával idézőjelet ágyazhat be egy szó szerinti sztringbe. Az alábbi példa a verbatim sztringek néhány gyakori használatát mutatja be:

string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\

string text = @"My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...
*/

string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Nyers sztringkonstansok

A C# 11-től kezdve nyers sztringkonstansokkal egyszerűbben hozhat létre többsoros sztringeket, vagy használhat bármilyen feloldósorozatot igénylő karaktert. A nyers sztringkonstansok nem igénylik a feloldósorozatok használatát. Megírhatja a sztringet, beleértve a térbeli formázást is, hogy hogyan jelenjen meg a kimenetben. Nyers sztringkonstans:

  • Legalább három dupla idézőjel (""") karaktersorozattal kezdődik és végződik. Háromnál több egymást követő karakter is elindíthatja és befejezheti a sorozatot, hogy támogassa a három (vagy több) ismétlődő idézőjelet tartalmazó sztringkonstansokat.
  • Az egysoros nyers sztringkonstansok nyitó és záró idézőjelkarakterekre van szükség ugyanazon a sorban.
  • A többsoros nyers sztringkonstansokhoz nyitó és záró idézőjelek is szükségesek a saját sorukban.
  • A többsoros nyers sztringkonstansokban a záró idézőjelek bal oldalán lévő térközök el lesznek távolítva.

Az alábbi példák ezeket a szabályokat mutatják be:

string singleLine = """Friends say "hello" as they pass by.""";
string multiLine = """
    "Hello World!" is typically the first program someone writes.
    """;
string embeddedXML = """
       <element attr = "content">
           <body style="normal">
               Here is the main text
           </body>
           <footer>
               Excerpts from "An amazing story"
           </footer>
       </element >
       """;
// The line "<element attr = "content">" starts in the first column.
// All whitespace left of that column is removed from the string.

string rawStringLiteralDelimiter = """"
    Raw string literals are delimited 
    by a string of at least three double quotes,
    like this: """
    """";

Az alábbi példák az alábbi szabályok alapján jelentett fordítói hibákat mutatják be:

// CS8997: Unterminated raw string literal.
var multiLineStart = """This
    is the beginning of a string 
    """;

// CS9000: Raw string literal delimiter must be on its own line.
var multiLineEnd = """
    This is the beginning of a string """;

// CS8999: Line does not start with the same whitespace as the closing line
// of the raw string literal
var noOutdenting = """
    A line of text.
Trying to outdent the second line.
    """;

Az első két példa érvénytelen, mert a többsoros nyers sztringkonstansokhoz a nyitó és a záró idézőjel-sorozatra van szükség a saját sorában. A harmadik példa érvénytelen, mert a szöveg ki van zárva a záró idézőjel-sorozatból.

Nyers sztringkonstansokat akkor érdemes megfontolni, ha olyan szöveget hoz létre, amely olyan karaktereket tartalmaz, amelyek feloldósorozatokat igényelnek idézőjeles sztringkonstansok vagy szó szerinti sztringkonstansok használatakor. A nyers sztringkonstansok könnyebben olvashatók lesznek Ön és mások számára, mert jobban hasonlítanak a kimeneti szövegre. Vegyük például a következő kódot, amely formázott JSON-sztringet tartalmaz:

string jsonString = """
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "TemperatureRanges": {
    "Cold": {
      "High": 20,
      "Low": -10
    },
    "Hot": {
      "High": 60,
      "Low": 20
    }
            },
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}
""";

Hasonlítsa össze ezt a szöveget a JSON-szerializálási példában szereplő szöveggel, amely nem használja ezt az új funkciót.

Sztringek feloldósorozatai

Escape-sorozat Karakternév Unicode-kódolás
\' Szimpla idézőjel 0x0027
\" Dupla idézőjel 0x0022
\\ Fordított perjel 0x005C
\0 Null 0x0000
\a Riasztás 0x0007
\b Backspace 0x0008
\f Űrlapcsatorna 0x000C
\n Új sor 0x000A
\r Kocsivissza 0x000D
\t Vízszintes lap 0x0009
\v Függőleges lap 0x000B
\u Unicode feloldósorozat (UTF-16) \uHHHH (tartomány: 0000 - FFFF; példa: \u00E7 = "ç")
\U Unicode feloldósorozat (UTF-32) \U00HHHHHH (tartomány: 0000000 - 10FFFF; példa: \U0001F47D = "👽")
\x A "\u" karakterhez hasonló Unicode feloldókaraktere a változó hosszúságú kivételével \xH[H][H][H] (tartomány: 0 - FFFF; példa: \x00E7 vagy \x0E7\xE7 = "ç")

Figyelmeztetés

A feloldókarakterek használatakor \x és a 4 hexadecimálisnál kisebb számjegyek megadásakor, ha a feloldósorozatot közvetlenül követő karakterek érvényes hexadecimális számjegyek (pl. 0-9, A-F és a-f), a feloldókarakterek részét képezik. Például a következőt állítja elő: \xA1 "¬, amely az U+00A1 kódpont. Ha azonban a következő karakter az "A" vagy az "a", akkor a feloldókarakter-sorozatot a rendszer inkább "ਚ" karakterként \xA1A értelmezi és hozza létre, amely az U+0A1A kódpont. Ilyen esetekben a 4 hexadecimális számjegy (pl. \x00A1 ) megadása megakadályozza az esetleges félreértelmezést.

Megjegyzés

A fordításkor a verbatim sztringek normál sztringekké alakulnak, ugyanazokkal a feloldósorozatokkal. Ezért ha egy verbatim sztringet tekint meg a hibakereső óraablakában, a fordító által hozzáadott feloldókarakterek jelennek meg, nem pedig a forráskódból származó verbatim verzió. A verbatim sztring @"C:\files.txt" például "C:\\files.txt" formában jelenik meg a figyelőablakban.

Sztringek formázása

A formátumsztring olyan sztring, amelynek tartalma futásidőben dinamikusan van meghatározva. A formázó sztringek interpolált kifejezések vagy helyőrzők beágyazásával hozhatók létre a sztringben lévő kapcsos zárójelek közé. A kapcsos zárójelek ({...}) minden elemét a rendszer futásidőben formázott sztringként oldja fel egy értékre és kimenetre. A formátumsztringek létrehozásának két módja van: sztringinterpoláció és összetett formázás.

Sztringinterpoláció

A C# 6.0-s és újabb verzióiban elérhető interpolált sztringeket a $ speciális karakter azonosítja, és interpolált kifejezéseket tartalmaz kapcsos zárójelekbe. Ha most ismerkedik a sztringinterpolációval, tekintse meg a Sztringinterpoláció – C# interaktív oktatóanyagot a gyors áttekintéshez.

Sztringinterpolációval javíthatja a kód olvashatóságát és karbantarthatóságát. A sztringinterpoláció ugyanazt az eredményt éri el, mint a metódus, de javítja a String.Format könnyű használatot és a beágyazott átláthatóságot.

var jh = (firstName: "Jupiter", lastName: "Hammon", born: 1711, published: 1761);
Console.WriteLine($"{jh.firstName} {jh.lastName} was an African American poet born in {jh.born}.");
Console.WriteLine($"He was first published in {jh.published} at the age of {jh.published - jh.born}.");
Console.WriteLine($"He'd be over {Math.Round((2018d - jh.born) / 100d) * 100d} years old today.");

// Output:
// Jupiter Hammon was an African American poet born in 1711.
// He was first published in 1761 at the age of 50.
// He'd be over 300 years old today.

A C# 10-től kezdve sztringinterpolációval inicializálhat egy állandó sztringet, ha a helyőrzőkhöz használt kifejezések szintén állandó sztringek.

A C# 11-től kezdve a nyers sztringkonstansokat sztringinterpolációkkal kombinálhatja. A formázási sztringet három vagy több egymást követő dupla idézőjellel kezdi és fejezi be. Ha a kimeneti sztringnek tartalmaznia kell a { karaktert, } további $ karakterek használatával megadhatja, hogy hány { karakter induljon el és } fejezze be az interpolációt. A kimenet tartalmazza a kevesebb { vagy } karakterből álló sorozatot. Az alábbi példa bemutatja, hogyan jelenítheti meg a pont távolságát a forrástól, és hogyan helyezheti a pontot kapcsos zárójelek közé:

int X = 2;
int Y = 3;

var pointMessage = $$"""The point {{{X}}, {{Y}}} is {{Math.Sqrt(X * X + Y * Y)}} from the origin.""";

Console.WriteLine(pointMessage);
// Output:
// The point {2, 3} is 3.605551275463989 from the origin.

Összetett formázás

A String.Format formátumsztring létrehozásához helyőrzőket használ a kapcsos zárójelekben. Ez a példa a fent használt sztringinterpolációs módszerhez hasonló kimenetet eredményez.

var pw = (firstName: "Phillis", lastName: "Wheatley", born: 1753, published: 1773);
Console.WriteLine("{0} {1} was an African American poet born in {2}.", pw.firstName, pw.lastName, pw.born);
Console.WriteLine("She was first published in {0} at the age of {1}.", pw.published, pw.published - pw.born);
Console.WriteLine("She'd be over {0} years old today.", Math.Round((2018d - pw.born) / 100d) * 100d);

// Output:
// Phillis Wheatley was an African American poet born in 1753.
// She was first published in 1773 at the age of 20.
// She'd be over 300 years old today.

A .NET-típusok formázásáról további információt a .NET formázási típusait ismertető cikkben talál.

Részkarakterláncok

A részkarakterlánc bármilyen karaktersorozat, amely egy sztringben található. Substring A metódussal új sztringet hozhat létre az eredeti sztring egy részéből. A metódussal megkeresheti a karakterláncrészek egy vagy több előfordulását IndexOf . A metódussal Replace lecserélheti egy adott karakterláncrész összes előfordulását egy új sztringre. A metódushoz Substring hasonlóan valójában egy új sztringet ad vissza, Replace és nem módosítja az eredeti sztringet. További információ: Sztringek keresése és a sztring tartalmának módosítása.

string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based
int index = s3.IndexOf("C");
// index = 7

Az egyes karakterek elérése

A tömb jelölését indexértékkel használva írásvédett hozzáférést szerezhet az egyes karakterekhez, ahogy az alábbi példában látható:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"

Ha a String metódusok nem biztosítják a sztring egyes karaktereinek módosításához szükséges funkciókat, egy objektummal StringBuilder módosíthatja az egyes karaktereket a helyben, majd létrehozhat egy új sztringet az eredmények tárolásához a StringBuilder metódusok használatával. A következő példában feltételezzük, hogy az eredeti sztringet egy adott módon kell módosítania, majd az eredményeket későbbi használatra kell tárolnia:

string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)
{
    if (System.Char.IsLower(sb[j]) == true)
        sb[j] = System.Char.ToUpper(sb[j]);
    else if (System.Char.IsUpper(sb[j]) == true)
        sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?

Null értékű sztringek és üres sztringek

Az üres sztring egy System.String nulla karaktert tartalmazó objektumpéldány. Az üres sztringeket gyakran használják különböző programozási forgatókönyvekben egy üres szövegmező ábrázolására. A metódusokat meghívhatja üres sztringeken, mert azok érvényes System.String objektumok. Az üres sztringek inicializálása a következőképpen történik:

string s = String.Empty;

Ezzel szemben a null sztring nem hivatkozik egy System.String objektumpéldányra, és a metódus null sztringen NullReferenceExceptiontörténő meghívására tett kísérlet egy . Null sztringeket azonban használhat összefűzési és összehasonlítási műveletekhez más sztringekkel. Az alábbi példák néhány olyan esetet mutatnak be, amikor egy null értékű sztringre mutató hivatkozás nem eredményez kivételt:

string str = "hello";
string nullStr = null;
string emptyStr = String.Empty;

string tempStr = str + nullStr;
// Output of the following line: hello
Console.WriteLine(tempStr);

bool b = (emptyStr == nullStr);
// Output of the following line: False
Console.WriteLine(b);

// The following line creates a new empty string.
string newStr = emptyStr + nullStr;

// Null strings and empty strings behave differently. The following
// two lines display 0.
Console.WriteLine(emptyStr.Length);
Console.WriteLine(newStr.Length);
// The following line raises a NullReferenceException.
//Console.WriteLine(nullStr.Length);

// The null character can be displayed and counted, like other chars.
string s1 = "\x0" + "abc";
string s2 = "abc" + "\x0";
// Output of the following line: * abc*
Console.WriteLine("*" + s1 + "*");
// Output of the following line: *abc *
Console.WriteLine("*" + s2 + "*");
// Output of the following line: 4
Console.WriteLine(s2.Length);

StringBuilder használata a sztring gyors létrehozásához

A .NET sztringműveletei nagymértékben optimalizáltak, és a legtöbb esetben nem befolyásolják jelentősen a teljesítményt. Bizonyos forgatókönyvekben, például a sok száz vagy ezer alkalommal végrehajtó szoros hurkok esetében azonban a sztringműveletek hatással lehetnek a teljesítményre. Az StringBuilder osztály létrehoz egy sztringpuffert, amely jobb teljesítményt nyújt, ha a program számos sztringmódosítást hajt végre. A StringBuilder sztring lehetővé teszi az egyes karakterek újbóli hozzárendelését is, amit a beépített sztring adattípus nem támogat. Ez a kód például anélkül módosítja egy sztring tartalmát, hogy új sztringet hoz létre:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
//Outputs Cat: the ideal pet

Ebben a példában egy StringBuilder objektummal hozunk létre sztringet numerikus típusok halmazából:

var sb = new StringBuilder();

// Create a string composed of numbers 0 - 9
for (int i = 0; i < 10; i++)
{
    sb.Append(i.ToString());
}
Console.WriteLine(sb);  // displays 0123456789

// Copy one character of the string (not possible with a System.String)
sb[0] = sb[9];

Console.WriteLine(sb);  // displays 9123456789

Sztringek, bővítménymeta és LINQ

Mivel a String típus implementálva IEnumerable<T>van, használhatja a sztringeken az Enumerable osztályban definiált bővítménymetszeteket. A vizuális zsúfoltság elkerülése érdekében ezek a metódusok ki vannak zárva az IntelliSense-ből a String típus esetében, de mégis elérhetők. A LINQ lekérdezési kifejezéseket sztringeken is használhatja. További információ: LINQ és Strings.