Ciągi (Przewodnik programowania w języku C#)Strings (C# Programming Guide)

Ciąg jest obiektem typu String , którego wartością jest Text.A string is an object of type String whose value is text. Wewnętrznie tekst jest przechowywany jako sekwencyjna kolekcja Char obiektów tylko do odczytu.Internally, the text is stored as a sequential read-only collection of Char objects. Na końcu C# ciągu nie ma znaku zamykającego wartości null; w związku C# z tym ciąg może zawierać dowolną liczbę osadzonych znaków null (' \ 0 ').There is no null-terminating character at the end of a C# string; therefore a C# string can contain any number of embedded null characters ('\0'). Właściwość ciągu reprezentuje Char liczbę obiektów, które zawiera, a nie liczbę znaków Unicode. LengthThe Length property of a string represents the number of Char objects it contains, not the number of Unicode characters. Aby uzyskać dostęp do poszczególnych punktów kodu Unicode w ciągu, użyj StringInfo obiektu.To access the individual Unicode code points in a string, use the StringInfo object.

ciąg a System.Stringstring vs. System.String

W programie C# Stringsłowo kluczowe jest aliasem dla. stringIn C#, the string keyword is an alias for String. W String związku z string tym i są równoważne i można użyć dowolnej preferowanej konwencji nazewnictwa.Therefore, String and string are equivalent, and you can use whichever naming convention you prefer. String Klasa zawiera wiele metod bezpiecznego tworzenia, manipulowania i porównywania ciągów.The String class provides many methods for safely creating, manipulating, and comparing strings. Ponadto C# język przeciążuje niektórych operatorów, aby uprościć Typowe operacje na ciągach.In addition, the C# language overloads some operators to simplify common string operations. Aby uzyskać więcej informacji na temat słowa kluczowego, zobacz ciąg.For more information about the keyword, see string. Aby uzyskać więcej informacji na temat typu i jego metod, StringZobacz.For more information about the type and its methods, see String.

Deklarowanie i Inicjowanie ciągówDeclaring and Initializing Strings

Można zadeklarować i zainicjować ciągi na różne sposoby, jak pokazano w następującym przykładzie:You can declare and initialize strings in various ways, as shown in the following example:

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

Należy zauważyć, że nie używasz operatora New do tworzenia obiektu String, chyba że podczas inicjowania ciągu z tablicą znaków.Note that you do not use the new operator to create a string object except when initializing the string with an array of chars.

Zainicjuj ciąg z Empty wartością stałą, aby utworzyć nowy String obiekt, którego ciąg ma zerową długość.Initialize a string with the Empty constant value to create a new String object whose string is of zero length. Literał ciągu reprezentujący ciąg o zerowej długości to "".The string literal representation of a zero-length string is "". Inicjując ciągi z Empty wartością zamiast wartości null, można zmniejszyć prawdopodobieństwo NullReferenceException wystąpienia.By initializing strings with the Empty value instead of null, you can reduce the chances of a NullReferenceException occurring. Użyj metody statycznej IsNullOrEmpty(String) , aby zweryfikować wartość ciągu przed próbą uzyskania do niego dostępu.Use the static IsNullOrEmpty(String) method to verify the value of a string before you try to access it.

Niezmienności obiektów StringImmutability of String Objects

Obiekty String są niezmienne: nie można ich zmienić po ich utworzeniu.String objects are immutable: they cannot be changed after they have been created. Wszystkie metody i C# operatory, które pojawiają się w celu zmodyfikowania ciągu faktycznie zwracają wyniki w nowym obiekcie ciągu. StringAll of the String methods and C# operators that appear to modify a string actually return the results in a new string object. W poniższym przykładzie, gdy zawartość s1 i s2 są łączone w celu utworzenia jednego ciągu, dwa oryginalne ciągi nie są modyfikowane.In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. += Operator tworzy nowy ciąg, który zawiera łączną zawartość.The += operator creates a new string that contains the combined contents. Nowy obiekt jest przypisany do zmiennej s1, a oryginalny obiekt, który został przypisany do s1 , jest uwalniany do wyrzucania elementów bezużytecznych, ponieważ żadna inna zmienna nie przechowuje odwołania do niego.That new object is assigned to the variable s1, and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

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.

Ponieważ ciąg "modyfikacja" jest w rzeczywistości nowym ciągiem, należy zachować ostrożność podczas tworzenia odwołań do ciągów.Because a string "modification" is actually a new string creation, you must use caution when you create references to strings. Jeśli utworzysz odwołanie do ciągu, a następnie "modyfikujesz" oryginalny ciąg, odwołanie będzie nadal wskazywało oryginalny obiekt zamiast nowego obiektu, który został utworzony podczas modyfikacji ciągu.If you create a reference to a string, and then "modify" the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified. Poniższy kod ilustruje to zachowanie:The following code illustrates this behavior:

string s1 = "Hello ";
string s2 = s1;
s1 += "World";

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

Aby uzyskać więcej informacji na temat sposobu tworzenia nowych ciągów opartych na modyfikacjach, takich jak wyszukiwanie i zamienianie na oryginalnym ciągu, zobacz How to: Modyfikuj zawartośćciągu.For more information about how to create new strings that are based on modifications such as search and replace operations on the original string, see How to: Modify String Contents.

Zwykłe i Verbatim literały ciąguRegular and Verbatim String Literals

Należy używać zwykłych literałów ciągów, gdy trzeba osadzić znaki ucieczki C#dostarczone przez, jak pokazano w poniższym przykładzie:Use regular string literals when you must embed escape characters provided by C#, as shown in the following example:

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

Używaj ciągów Verbatim, aby wygodnie i lepsza czytelność, gdy tekst ciągu zawiera znaki ukośnika odwrotnego, na przykład w ścieżkach plików.Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. Ponieważ ciągi Verbatim zachowują znaki nowego wiersza w ramach tekstu ciągu, mogą one służyć do inicjowania ciągów wielowierszowych.Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Użyj podwójnych cudzysłowów do osadzenia cudzysłowu wewnątrz ciągu Verbatim.Use double quotation marks to embed a quotation mark inside a verbatim string. W poniższym przykładzie przedstawiono niektóre typowe zastosowania ciągów Verbatim:The following example shows some common uses for verbatim strings:

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."

Sekwencje ucieczki ciągówString Escape Sequences

Sekwencja ucieczkiEscape sequence Nazwa znakuCharacter name Kodowanie UnicodeUnicode encoding
\'\' Pojedynczy cytatSingle quote 0x00270x0027
\"\" Podwójny cudzysłówDouble quote 0x00220x0022
\\ Ukośnik odwrotnyBackslash 0x005C0x005C
\0\0 NullNull 0x00000x0000
\a\a AlertyAlert 0x00070x0007
\b\b BackspaceBackspace 0x00080x0008
\f\f Kanał informacyjny formularzaForm feed 0x000C0x000C
\n\n Nowy wierszNew line 0x000A0x000A
\r\r Znak powrotu karetkiCarriage return 0x000D0x000D
\t\t Tabulator poziomyHorizontal tab 0x00090x0009
\v\v Tabulator pionowyVertical tab 0x000B0x000B
\u\u Sekwencja unikowa Unicode (UTF-16)Unicode escape sequence (UTF-16) \uHHHHzakresu 0000 — FFFF; przykład: \u00E7 = "ç")\uHHHH (range: 0000 - FFFF; example: \u00E7 = "ç")
\U\U Sekwencja unikowa Unicode (UTF-32)Unicode escape sequence (UTF-32) \U00HHHHHHzakresu 000000 — 10FFFF; przykład: \U0001F47D = "👽")\U00HHHHHH (range: 000000 - 10FFFF; example: \U0001F47D = "👽")
\x\x Sekwencja unikowa Unicode podobna do "\u" z wyjątkiem zmiennej długościUnicode escape sequence similar to "\u" except with variable length \xH[H][H][H]zakresu 0 — FFFF; przykład: \x00E7 or \x0E7 lub \xE7 = "ç")\xH[H][H][H] (range: 0 - FFFF; example: \x00E7 or \x0E7 or \xE7 = "ç")

Ostrzeżenie

Przy użyciu \x sekwencji unikowej i określania mniej niż 4 cyfry szesnastkowe, jeśli znaki, które bezpośrednio podążają za sekwencją ucieczki, są prawidłowymi cyframi szesnastkowymi (tj. 0-9, a-f i a-f), będą interpretowane jako część sekwencji ucieczki.When using the \x escape sequence and specifying less than 4 hex digits, if the characters that immediately follow the escape sequence are valid hex digits (i.e. 0-9, A-F, and a-f), they will be interpreted as being part of the escape sequence. Na przykład \xA1 tworzy "¡", który jest punktem kodu U + 00A1.For example, \xA1 produces "¡", which is code point U+00A1. Jeśli jednak następny znak to "a" lub "a", wówczas sekwencja ucieczki będzie interpretowana jako \xA1A "ਚ", która jest punktem kodu U + 0A1A.However, if the next character is "A" or "a", then the escape sequence will instead be interpreted as being \xA1A and produce "ਚ", which is code point U+0A1A. W takich przypadkach, określenie wszystkich 4 cyfr szesnastkowych (np \x00A1 .) uniemożliwi wszelkie możliwe Błędne interpretacje.In such cases, specifying all 4 hex digits (e.g. \x00A1 ) will prevent any possible misinterpretation.

Uwaga

W czasie kompilacji ciągi Verbatim są konwertowane na zwykłe ciągi ze wszystkimi tymi samymi sekwencjami ucieczki.At compile time, verbatim strings are converted to ordinary strings with all the same escape sequences. W związku z tym, jeśli w oknie Czujka debugera zostanie wyświetlony ciąg Verbatim, zobaczysz znaki ucieczki, które zostały dodane przez kompilator, a nie wersję Verbatim z kodu źródłowego.Therefore, if you view a verbatim string in the debugger watch window, you will see the escape characters that were added by the compiler, not the verbatim version from your source code. Na przykład ciąg @"C:\files.txt" Verbatim pojawi się w oknie czujki jako "C:\\files.txt".For example, the verbatim string @"C:\files.txt" will appear in the watch window as "C:\\files.txt".

Ciągi formatująceFormat Strings

Ciąg formatu jest ciągiem, którego zawartość jest określana dynamicznie w czasie wykonywania.A format string is a string whose contents are determined dynamically at runtime. Ciągi formatu są tworzone przez osadzanie wyrażeń interpolowanych lub symboli zastępczych wewnątrz nawiasów klamrowych w ciągu.Format strings are created by embedding interpolated expressions or placeholders inside of braces within a string. Wszystkie elementy wewnątrz nawiasów klamrowych ({...}) zostaną rozpoznane jako ciąg sformatowany w czasie wykonywania.Everything inside the braces ({...}) will be resolved to a value and output as a formatted string at runtime. Istnieją dwie metody tworzenia ciągów formatowania: Interpolacja ciągów i formatowanie złożone.There are two methods to create format strings: string interpolation and composite formatting.

Interpolacja ciągówString Interpolation

Dostępne w C# 6,0 i nowszych, interpolowane ciągi$ identyfikowane przez znak specjalny i zawierają interpolowane wyrażenia w nawiasach klamrowych.Available in C# 6.0 and later, interpolated strings are identified by the $ special character and include interpolated expressions in braces. Jeśli dopiero zaczynasz interpolację ciągów, zobacz Interpolacja ciągów — C# Interaktywny samouczek , aby zapoznać się z krótkim omówieniem.If you are new to string interpolation, see the String interpolation - C# interactive tutorial for a quick overview.

Używaj interpolacji ciągów, aby zwiększyć czytelność i łatwość utrzymania kodu.Use string interpolation to improve the readability and maintainability of your code. Interpolacja ciągów osiąga te same wyniki co String.Format Metoda, ale poprawia łatwość użycia i inline.String interpolation achieves the same results as the String.Format method, but improves ease of use and inline clarity.

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. 

Złożone formatowanieComposite Formatting

Symbole String.Format zastępcze wykorzystują w nawiasach klamrowych, aby utworzyć ciąg formatu.The String.Format utilizes placeholders in braces to create a format string. Ten przykład skutkuje podobnym wyjściem do metody interpolacji ciągów użytej powyżej.This example results in similar output to the string interpolation method used above.

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.

Aby uzyskać więcej informacji na temat formatowania typów .NET, zobacz Typy formatowania na platformie .NET.For more information on formatting .NET types see Formatting Types in .NET.

PodciągówSubstrings

Podciąg to dowolna sekwencja znaków, która jest zawarta w ciągu.A substring is any sequence of characters that is contained in a string. Użyj metody Substring , aby utworzyć nowy ciąg z części oryginalnego ciągu.Use the Substring method to create a new string from a part of the original string. Można wyszukać jedno lub więcej wystąpień podciągu przy użyciu IndexOf metody.You can search for one or more occurrences of a substring by using the IndexOf method. Użyj metody Replace , aby zastąpić wszystkie wystąpienia określonego podciągu nowym ciągiem.Use the Replace method to replace all occurrences of a specified substring with a new string. Podobnie jak Replace Metoda, faktycznie zwraca nowy ciąg i nie modyfikuje pierwotnego ciągu. SubstringLike the Substring method, Replace actually returns a new string and does not modify the original string. Aby uzyskać więcej informacji, zobacz How to: Search String and How to: Modyfikuj zawartośćciągu.For more information, see How to: search strings and How to: Modify String Contents.

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

Uzyskiwanie dostępu do pojedynczych znakówAccessing Individual Characters

Można użyć notacji Array z wartością indeksu, aby uzyskać dostęp tylko do odczytu do poszczególnych znaków, jak w poniższym przykładzie:You can use array notation with an index value to acquire read-only access to individual characters, as in the following example:

string s5 = "Printing backwards";

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

Jeśli metody nie zapewniają funkcjonalności, która musi być modyfikowana przez poszczególne znaki w ciągu, można StringBuilder użyć obiektu do modyfikacji pojedynczych znaków "w miejscu", a następnie utworzyć nowy ciąg do przechowywania wyników przy użyciu String StringBuilder metody.If the String methods do not provide the functionality that you must have to modify individual characters in a string, you can use a StringBuilder object to modify the individual chars "in-place", and then create a new string to store the results by using the StringBuilder methods. W poniższym przykładzie Załóżmy, że należy zmodyfikować oryginalny ciąg w określony sposób, a następnie zapisać wyniki do użycia w przyszłości:In the following example, assume that you must modify the original string in a particular way and then store the results for future use:

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?            

Ciągi o wartości null i puste ciągiNull Strings and Empty Strings

Pusty ciąg jest wystąpieniem System.String obiektu, który zawiera znaki zerowe.An empty string is an instance of a System.String object that contains zero characters. Puste ciągi są często używane w różnych scenariuszach programistycznych do reprezentowania pustego pola tekstowego.Empty strings are used often in various programming scenarios to represent a blank text field. Możesz wywoływać metody dla pustych ciągów, ponieważ są System.String one prawidłowymi obiektami.You can call methods on empty strings because they are valid System.String objects. Puste ciągi są inicjowane w następujący sposób:Empty strings are initialized as follows:

string s = String.Empty;  

Z kolei ciąg o wartości null nie odwołuje się do wystąpienia System.String obiektu, a jakakolwiek próba wywołania metody dla ciągu o wartości null NullReferenceExceptionpowoduje.By contrast, a null string does not refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. Można jednak używać ciągów o wartości null w operacjach łączenia i porównywania z innymi ciągami.However, you can use null strings in concatenation and comparison operations with other strings. Poniższe przykłady ilustrują niektóre przypadki, w których odwołanie do ciągu o wartości null i nie powoduje zgłoszenia wyjątku:The following examples illustrate some cases in which a reference to a null string does and does not cause an exception to be thrown:

static void Main()
{
    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);
}

Używanie elementu StringBuilder do szybkiego tworzenia ciągówUsing StringBuilder for Fast String Creation

Operacje na ciągach w programie .NET są wysoce zoptymalizowane i w większości przypadków nie mają znaczącego wpływu na wydajność.String operations in .NET are highly optimized and in most cases do not significantly impact performance. Jednak w niektórych scenariuszach, takich jak ścisłe pętle wykonujące wiele setek lub tysięcy razy, operacje na ciągach mogą mieć wpływ na wydajność.However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. StringBuilder Klasa tworzy bufor ciągów, który zapewnia lepszą wydajność, jeśli program wykonuje wiele operacji manipulowania ciągami.The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. Ten StringBuilder ciąg umożliwia również ponowne przypisanie pojedynczych znaków, co nie jest obsługiwane w przypadku typu danych, który jest wbudowany.The StringBuilder string also enables you to reassign individual characters, something the built-in string data type does not support. Ten kod, na przykład, zmienia zawartość ciągu bez tworzenia nowego ciągu:This code, for example, changes the content of a string without creating a new string:

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

//Outputs Cat: the ideal pet

W tym przykładzie StringBuilder obiekt jest używany do tworzenia ciągu z zestawu typów liczbowych:In this example, a StringBuilder object is used to create a string from a set of numeric types:

using System;
using System.Text;

namespace CSRefStrings
{
    class TestStringBuilder
    {
        static void Main()
        {
            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
            Console.WriteLine();
        }
    }
}

Ciągi, metody rozszerzające i LINQStrings, Extension Methods and LINQ

Ponieważ typ implementuje IEnumerable<T>, można użyć metod Enumerable rozszerzających zdefiniowanych w klasie w ciągach. StringBecause the String type implements IEnumerable<T>, you can use the extension methods defined in the Enumerable class on strings. Aby uniknąć bałaganu wizualnego, te metody są wykluczone z String IntelliSense dla typu, ale są one dostępne.To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they are available nevertheless. Można również użyć LINQLINQ wyrażeń zapytania dla ciągów.You can also use LINQLINQ query expressions on strings. Aby uzyskać więcej informacji, zobacz LINQ i ciągi.For more information, see LINQ and Strings.

TematTopic OpisDescription
Instrukcje: Modyfikuj zawartość ciąguHow to: Modify String Contents Ilustruje techniki przekształcania ciągów i modyfikowania zawartości ciągów.Illustrates techniques to transform strings and modify the contents of strings.
Instrukcje: Porównaj ciągiHow to: Compare Strings Pokazuje, w jaki sposób wykonywać porównania ciągów liczbowych i kulturowych.Shows how to perform ordinal and culture specific comparisons of strings.
Instrukcje: Łączenie wielu ciągówHow to: Concatenate Multiple Strings Ilustruje różne sposoby sprzęgania wielu ciągów w jeden.Demonstrates various ways to join multiple strings into one.
Instrukcje: Analizowanie ciągów za pomocą ciągu. SplitHow to: Parse Strings Using String.Split Zawiera przykłady kodu, które ilustrują sposób użycia String.Split metody do analizowania ciągów.Contains code examples that illustrate how to use the String.Split method to parse strings.
Instrukcje: Ciągi wyszukiwaniaHow to: Search Strings Wyjaśnia, jak używać wyszukiwania określonego tekstu lub wzorców w ciągach.Explains how to use search for specific text or patterns in strings.
Instrukcje: Określanie, czy ciąg reprezentuje wartość liczbowąHow to: Determine Whether a String Represents a Numeric Value Pokazuje, jak bezpiecznie analizować ciąg, aby sprawdzić, czy ma prawidłową wartość liczbową.Shows how to safely parse a string to see whether it has a valid numeric value.
Interpolacja ciągówString interpolation Opisuje funkcję interpolacji ciągów, która zapewnia wygodną składnię do formatowania ciągów.Describes the string interpolation feature that provides a convenient syntax to format strings.
Podstawowe operacje na ciągachBasic String Operations Zawiera łącza do tematów, które System.String używają System.Text.StringBuilder metod i do wykonywania podstawowych operacji na ciągach.Provides links to topics that use System.String and System.Text.StringBuilder methods to perform basic string operations.
Analizowanie ciągówParsing Strings W tym artykule opisano sposób konwertowania reprezentacji ciągów typów podstawowych na wystąpienia odpowiednich typów.Describes how to convert string representations of .NET base types to instances of the corresponding types.
Analizowanie ciągów daty i godziny w programie .NETParsing Date and Time Strings in .NET Pokazuje, jak przekonwertować ciąg, taki jak "01/24/2008", na System.DateTime obiekt.Shows how to convert a string such as "01/24/2008" to a System.DateTime object.
Porównywanie ciągówComparing Strings Zawiera informacje o sposobach porównywania ciągów i zawiera przykłady C# w i Visual Basic.Includes information about how to compare strings and provides examples in C# and Visual Basic.
Używanie klasy StringBuilderUsing the StringBuilder Class Opisuje sposób tworzenia i modyfikowania dynamicznych obiektów ciągów przy użyciu StringBuilder klasy.Describes how to create and modify dynamic string objects by using the StringBuilder class.
LINQ i ciągiLINQ and Strings Zawiera informacje o sposobach wykonywania różnych operacji na ciągach przy użyciu zapytań LINQ.Provides information about how to perform various string operations by using LINQ queries.
Przewodnik programowania w języku C#C# Programming Guide Zawiera łącza do tematów, które wyjaśniają konstrukcje C#programistyczne w programie.Provides links to topics that explain programming constructs in C#.