Megosztás a következőn keresztül:

Sztringek és sztringkonstansok

A sztring olyan String típusú objektum, amelynek értéke szöveg. Belsőleg a szöveg Char objektumok szekvenciális, írásvédett gyűjteményeként van tárolva. Egy sztring Length tulajdonsága a benne található Char objektumok számát jelöli, nem a Unicode-karakterek számát. A karakterlánc egyes Unicode-kódpontjainak eléréséhez használja a StringInfo objektumot.

string és System.String

A C#-ban a string kulcsszó a Stringaliasa; ezért String és string egyenértékűek. Használja a megadott aliast string, mivel using System;nélkül is működik. A 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 szöveget. 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 különböző módokon deklarálhatja és inicializálhatja, ahogyan az alábbi példában látható:

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

A új operátorral nem hozhat létre sztringobjektumot, kivéve, ha a sztringet karaktertömbbel inicializálja.

Inicializáljon egy sztringet a Empty állandó értékkel egy új String objektum létrehozásához, amelynek sztringje nulla hosszúságú. A nulla hosszúságú karakterlánc literális ábrázolása "". A Empty helyett a értékkel rendelkező sztringek inicializálásával csökkentheti a NullReferenceException előfordulásának esélyét. A statikus IsNullOrEmpty(String) metódussal ellenőrizze egy karakterlánc é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. Az összes olyan String 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. Az alábbi példában, amikor a s1 és a s2 tartalmát összefűzik, hogy egyetlen karakterláncot alkossanak, a két eredeti karakterlánc érintetlen marad. A += operátor létrehoz egy új sztringet, amely tartalmazza a kombinált tartalmat. Ez az új objektum hozzá van rendelve a változóhoz s1, és az eredeti hozzárendelt s1 objektum szemétgyűjtéshez lesz felszabadítva, 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 egy karakterlánc "módosítása" valójában egy új karakterlánc létrehozása, odafigyeléssel kell eljárnia, amikor karakterláncokra mutató hivatkozásokat hoz létre. Ha egy sztringre mutató hivatkozást hoz létre, majd "módosítja" az eredeti sztringet, a hivatkozás továbbra is az eredeti objektumra mutat. Az eredeti objektum nem tükrözi a sztring módosításakor létrehozott új objektumot. 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

Ha további információt szeretne 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ásacímű témakört.

Idézett karakterlánc literálok

Idézőjeles sztringkonstansok egy dupla idézőjel karakterrel (") kezdődnek és végződnek ugyanazon a soron. Az idézett literálok olyan sztringekhez ideálisak, amelyek egyetlen sorban elférnek, és nem tartalmaznak escape szekvenciákat. Az idézett karakterlánc-literálnak escape karaktereket kell beágyaznia, ahogy az a következő példában is látható.

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

Szó szerinti karakterlánc-konstansok

A verbatim karakterlánc-literelek kényelmesebbek többsoros karakterláncokhoz, fordított perjeleket tartalmazó karakterláncokhoz vagy beágyazott dupla idézőjelekhez. A verbatim sztringek megőrzik az új vonal karaktereket a sztringszöveg részeként. Kettős idézőjelek használatával idézőjelet ágyazhat be egy szó szerinti sztringbe. Az alábbi példa a szó szerinti karakterláncok néhány gyakori használatát mutatja be.

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

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 szöveges literálok

A nyers sztringkonstansokkal egyszerűbben hozhat létre többsoros sztringeket, vagy használhat bármilyen olyan karaktert, amely menekülési sorozatokat igényel. nyers sztringkonstansok megszüntetik a menekülési sorozatok használatának szükségességét. Megírhatja a karakterláncot, beleértve az üres hely formázást, úgy, ahogy szeretné, hogy megjelenjen a kimenetben. Egy nyers karakterlánc:

  • Legalább három dupla idézőjelből (""") álló sorozattal kezdődik és végződik. Több mint három egymást követő karakter használatával kezdheti és fejezheti be a karaktersorozatot a három (vagy több) ismétlődő idézőjelet tartalmazó karakterláncok támogatásához.
  • Az egysoros nyers szövegkonstansok nyitó és záró idézőjeleit ugyanazon a sorban kell megadni.
  • A többsoros nyers sztringkonstansok esetében a nyitó és záró idézőjeleknek is saját sorban kell lenniük.
  • Többsoros nyers sztringkonstansokban a záró idézőjelek bal oldalán lévő szóközök el lesznek távolítva a nyers sztringkonstans összes sorából.
  • Többsoros nyers sztringkonstansokban a rendszer figyelmen kívül hagyja az ugyanazon a sorban lévő nyitó idézőjel utáni szóközöket.
  • Többsoros nyers szöveges literálokban a csak szóközöket tartalmazó sorok is benne vannak a literálban a nyitó idézőjel után.

Az alábbi példák a következő 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ó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 karaktersorozatok esetében a nyitó és záró idézőjeleknek külön sorban kell állniuk. A harmadik példa érvénytelen, mert a szöveg ki van zárva a záró idézőjelsorozatból.

Nyers sztringliterálokat érdemes figyelembe venni, ha olyan szöveget hoz létre, amely olyan karaktereket tartalmaz, amelyek esetén escape szekvenciákat kell használni idézett sztringliterálok vagy szó szerinti sztringliterálok esetén. A nyers sztringkonstansok számodra és mások számára könnyebben olvashatók, 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"
  ]
}
""";

Jótanács

A Visual Studio és a C#Dev Kit érvényesítési és szintaxiskiemelést biztosít, ha a nyers sztringkonstansok JSON-adatokat vagy reguláris kifejezéseket tartalmaznak.

Az eszközök elemzik a szöveget. Ha az eszközök biztosak abban, hogy a szöveg JSON-t vagy reguláris kifejezést jelöl, a szerkesztő szintaxisszínezést biztosít.

Ezt a felhasználói élményt úgy javíthatja, ha a formátumot jelző deklaráció fölé fűz egy megjegyzést:

  • // lang=json A nyers sztringkonstans JSON-adatokat jelöl.
  • // lang=regex azt jelzi, hogy a nyers karakterlánc egy reguláris kifejezést jelöl.

Amikor egy nyers sztring literált használunk argumentumként, ahol a paraméter a formátum jelzésére a System.Diagnostics.CodeAnalysis.StringSyntaxAttribute szimbólumot alkalmazza, ezek az eszközök bizonyos formátumtípusok esetében ellenőrzik a nyers sztring literált. A JSON és a regex is támogatott.

Bizonyos formátumok esetében a megjegyzés vagy az attribútum lehetővé teszi a kódjavaslatok által a formátumon alapuló sztringkonstansok javítását.

Sztringek feloldási sorozatai

Menekülési sorozat Karakter neve Unicode-kódolás
\' Egy idézőjel 0x0027
\" Dupla idézőjel 0x0022
\\ Fordított perjel 0x005C
\0 Nulla 0x0000
\a Riasztás 0x0007
\b Visszalépés 0x0008
\e Menekülés 0x001B
\f Lapváltás 0x000C
\n Új sor 0x000A
\r Kocsivisszatérítés 0x000D
\t Vízszintes lap 0x0009
\v Függőleges lap 0x000B
\u Unicode-feloldási 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 Unicode escape szekvencia, amely hasonló a "\u" szekvenciához, de változó hosszúságú. \xH[H][H][H] (tartomány: 0 – FFFF; például: \x00E7 vagy \x0E7 vagy \xE7 = "ç")

Figyelmeztetés

Ha a \x feloldósorozatot használja, és kevesebb mint 4 hexa számjegyet ad meg, ha a feloldósorozatot közvetlenül követő karakterek érvényes hexa számjegyek (például 0-9, A-F és a-f), akkor a rendszer a menekülési sorozat részeként értelmezi őket. Például a \xA1 a "¡" jelet hozza létre, amely az U+00A1 kódpont. Ha azonban a következő karakter "A" vagy "a", akkor a feloldósorozatot a rendszer ehelyett \xA1A ként értelmezi, és létrehozza a "ਚ" karaktert, amely az U+0A1A kódpont. Ilyen esetekben a 4 hexa számjegy (például \x00A1) megadása megakadályozza az esetleges félreértelmezést.

Megjegyzés:

Fordításkor a verbatim és nyers sztringek normál sztringekké konvertálódnak, ugyanazokkal az escape szekvenciákkal. Ezért ha egy szó szerinti vagy nyers sztringet tekint meg a hibakereső óraablakban, a fordító által hozzáadott feloldó karaktereket látja, nem pedig a forráskódból származó szó szerinti vagy nyers verziót. A verbatim sztring @"C:\files.txt" például a figyelőablakban "C:\\files.txt" formában jelenik meg.

Sztringek formázása

A formátumsztring olyan sztring, amelynek tartalma futásidőben dinamikusan van meghatározva. A formázási karakterláncok a interpolált kifejezések vagy helyőrzők kapcsos zárójelben történő beágyazásával hozhatók létre egy karakterláncon belül. A kapcsos zárójelek ({...}) minden benne lévő elemet egy értékre old, és az eredmény formázott sztringként jelenik meg futtatáskor. A formátumsztringek létrehozásához két módszer létezik: a sztringek interpolációja és az összetett formázás.

Sztring interpolációja

Az interpolált sztringeket a $ speciális karakterrel deklarálja. Az interpolált szövegek interpolált kifejezéseket tartalmaznak kapcsos zárójelekben. Ha még nem ismerkedik a sztringinterpolációval, tekintse meg a Sztring interpoláció – C# oktatóanyagot , amely több példát is tartalmaz.

Sztringinterpolációval javíthatja a kód olvashatóságát és karbantarthatóságát. A sztringinterpoláció ugyanazokat az eredményeket éri el, mint a String.Format metódus, de könnyebben használható, és javítja az á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.

Sztringinterpolációval inicializálhat egy állandó sztringet, ha a helyőrzőkhöz használt kifejezések is állandó sztringek.

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 indíthatja el és fejezheti be. Ha a kimeneti sztringnek tartalmaznia kell a { vagy } karaktert, további $ karakterekkel megadhatja, hogy hány { és } karakter kezdődjön és fejezze be az interpolációt. A kimenet bármely, kevesebb, mint { vagy } karakterből álló sorozatot tartalmaz. Az alábbi példa bemutatja, hogyan jelenítheti meg a pont távolságát a forrástól, és hogyan helyezheti el a pontot a kapcsos zárójelek között:

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.

Karakterlánc interpoláció szó szerint

A C# lehetővé teszi a szó szerinti szöveg interpolációját, például több sorban, a $@ vagy @$ szintaxis használatával.

A feloldósorozatok szó szerinti értelmezéséhez használjon szó szerinti sztringkonstanst. Az interpolált verbatim sztring a $ karakterrel kezdődik, majd a @ karakterrel. A $ és @ tokeneket tetszőleges sorrendben használhatja: $@"..." és @$"..." egyaránt érvényes, interpolált szövegek.

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}.");

// Output:
// Jupiter Hammon
//     was an African American poet born in 1711.
// He was first published in 1761
// at the age of 50.

Összetett formázás

A String.Format a kapcsos zárójelek alkalmazásával használ helyőrzőket egy formátumsztring létrehozásához. Ez a példa az előző mintában használt sztring interpolációs módszeréhez 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.

További információ: Összetett formázás a .NET-ben.

Részszöveg

Az alsztring a karakterláncban található karakterek bármilyen részsorozata. A Substring metódussal új sztringet hozhat létre az eredeti sztring egy részéből. A IndexOf metódussal megkeresheti egy vagy több alsztring előfordulását. A Replace metódussal lecserélheti egy adott sztring összes előfordulását egy új sztringre. A Substring metódushoz hasonlóan Replace egy új sztringet ad vissza, é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

Egyéni karakterek elérése

Az indexértékkel rendelkező tömb segítségével csak olvasható hozzáférést nyerhet az egyes karakterekhez, ahogyan az alábbi példában is 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"

A sztringek kiterjedtebb kezeléséhez használhat egy StringBuilder objektumot az egyes karakterek 'helyben' módosítására. Ezután a StringBuilder metódusok használatával hozzon létre egy új sztringet az eredmények tárolására. Az alábbi példában tegyük fel, 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?

Az indexekről további információt az Indexek és tartományok felfedezése című cikkben talál.

Null karakterláncok és üres karakterláncok

Az üres sztring egy olyan System.String objektum példánya, amely nulla karaktert tartalmaz. Az üres sztringeket gyakran használják különböző programozási forgatókönyvekben üres szövegmezők ábrázolására. A metódusokat üres sztringeken is meghívhatja, mert azok érvényesek System.String objektumokra. Az üres sztringek inicializálása az alábbiak szerint történik:

string s = String.Empty;

Ezzel szemben a null sztringek nem hivatkoznak egy System.String objektum példányára, és a metódus meghívására tett kísérletek egy null sztringen NullReferenceExceptionokoznak. A null sztringeket azonban összefűzési és összehasonlítási műveletekhez használhatja más sztringekkel. Az alábbi példák olyan eseteket mutatnak be, amikor egy null értékre mutató hivatkozás kivételt okoz, illetve nem okoz.

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 gyors sztringek létrehozásához

A .NET-ben a sztringműveletek nagymértékben optimalizálva vannak, és a legtöbb esetben nem befolyásolják jelentősen a teljesítményt. Bizonyos esetekben azonban, például amikor szoros hurkokat hajtanak végre több száz vagy akár több ezer alkalommal, a sztringműveletek hatással lehetnek a teljesítményre. A StringBuilder osztály egy sztringpuffert hoz létre, amely jobb teljesítményt nyújt, ha a program számos sztringmanipulációt 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 új sztring létrehozása nélkül módosítja a sztring tartalmát:

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 objektumot használnak arra, hogy szöveget hozzanak létre 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énymetszetek és LINQ

Mivel a String típus implementálja a IEnumerable<T>, a karakterláncoknál használhatók a Enumerable osztályban definiált bővítési módszerek. A vizualizációk zsúfoltságának elkerülése érdekében ezek a metódusok nem tartoznak az IntelliSense String típushoz, de mégis elérhetők. A LINQ lekérdezési kifejezéseket sztringeken is használhatja. További információ: LINQ és karakterláncok.

  • Last updated on