ZetCode

C# 字符串

最后修改时间 2025 年 5 月 1 日

在本文中，我们将展示如何在 C# 中使用字符串。

理解 C# 字符串

C# 中的字符串表示使用 UTF-16 编码的字符序列。它是一种基本数据类型，根据特定的字符编码存储一系列字符。当字符串直接出现在源代码中时，它被称为字符串字面量。

在 C# 中，字符串是对象，并且有两个主要的类可用于处理它们

System.String 类提供不可变字符串，这意味着一旦创建，其内容就无法更改。另一方面，System.Text.StringBuilder 类专为可变字符串设计，可以进行高效的修改，例如附加或替换字符。

在 C# 中，string 关键字是 System.String 的别名。虽然 string 专门用于 C# 语言，但 System.String 属于 .NET 框架，并且两者可以互换使用。

注意：本文重点介绍基本的 ASCII 字符串。处理其他字母表中的字符串（例如具有复杂编码的字符串）通常涉及更高级的操作。

C# 字符串初始化

有多种创建字符串的方法，包括不可变和可变。我们展示其中一些。

Program.cs 
using System.Text;

char[] cdb = ['M', 'y', 'S', 'q', 'l'];

string lang = "C#";
string ide = "NetBeans";
string db = new(cdb);

Console.WriteLine(lang);
Console.WriteLine(ide);
Console.WriteLine(db);

var sb1 = new StringBuilder(lang);
var sb2 = new StringBuilder();

sb2.Append("Fields");
sb2.Append(" of ");
sb2.Append("glory");

Console.WriteLine(sb1);
Console.WriteLine(sb2);

该示例展示了几种创建 System.String 和 System.Text.StringBuilder 对象的方法。

using System.Text;

此语句可以无需限定即可使用 System.Text.StringBuilder 类型。

string lang = "C#";
string ide = "NetBeans";

最常见的方法是从字符串字面量创建字符串对象。

string db = new(cdb);

在这里，我们从字符数组创建一个字符串对象。 string 是 System.String 的别名。

var sb1 = new StringBuilder(lang);

从 String 创建 StringBuilder 对象。

var sb2 = new StringBuilder();

sb2.Append("Fields");
sb2.Append(" of ");
sb2.Append("glory");

我们创建一个空的 StringBuilder 对象。我们将三个字符串附加到该对象中。

$ dotnet run
C#
NetBeans
MySql
C#
Fields of glory

C# 字符串插值

$ 特殊字符前缀将字符串字面量标识为内插字符串。 内插字符串是可能包含内插表达式的字符串字面量。

字符串格式化是类似于字符串内插的功能；本章稍后会介绍它。

Program.cs 
int age = 23;
string name = "Peter";

DateTime now = DateTime.Now;

Console.WriteLine($"{name} is {age} years old");
Console.WriteLine($"Hello, {name}! Today is {now.DayOfWeek}, it's {now:HH:mm} now");

该示例展示了 C# 字符串内插。

Console.WriteLine($"{name} is {age} years old");

内插变量放在 {} 括号之间。

Console.WriteLine($"Hello, {name}! Today is {now.DayOfWeek}, it's {now:HH:mm} now");

内插语法可以接收表达式或格式说明符。

$ dotnet run
Peter is 23 years old
Hello, Peter! Today is Friday, it's 12:23 now

C# 常规字符串

常规字符串可以包含转义序列，例如换行符或制表符，这些序列会被解释。常规字符串放在一对双引号之间。

Program.cs 
string s1 = "deep \t forest";
string s2 = "deep \n forest";

Console.WriteLine(s1);
Console.WriteLine(s2);

Console.WriteLine("C:\\Users\\Admin\\Documents");

该示例打印包含 \t 和 \n 转义序列的两个字符串。

Console.WriteLine("C:\\Users\\Admin\\Documents");

在使用例如路径时，必须转义斜杠。

$ dotnet run
deep     forest
deep
    forest
C:\Users\Admin\Documents

C# 逐字字符串

逐字字符串不解释转义序列。逐字字符串以 @ 字符开头。逐字字符串可用于处理多行字符串。

Program.cs 
Console.WriteLine(@"deep \t forest");
Console.WriteLine(@"C:\Users\Admin\Documents");

var text = @"
    Not marble, nor the gilded monuments
Of princes, shall outlive this powerful rhyme;
But you shall shine more bright in these contents
Than unswept stone, besmeared with sluttish time.";

Console.WriteLine(text);

在此代码示例中，我们使用逐字字符串。

Console.WriteLine(@"deep \t forest");

\t 特殊字符未被解释；它只会被打印到控制台。

Console.WriteLine(@"C:\Users\Admin\Documents");

当我们处理路径时，逐字字符串很方便；不必转义斜杠。

var text = @"
    Not marble, nor the gilded monuments
Of princes, shall outlive this powerful rhyme;
But you shall shine more bright in these contents
Than unswept stone, besmeared with sluttish time.";

逐字字符串允许我们创建多行字符串。

$ dotnet run
deep \t forest
C:\Users\Admin\Documents

    Not marble, nor the gilded monuments
Of princes, shall outlive this powerful rhyme;
But you shall shine more bright in these contents
Than unswept stone, besmeared with sluttish time.

C# 字符串是对象

字符串是对象。 它们是引用类型。 字符串是 System.String 或 System.Text.StringBuilder 类的实例。 由于它们是对象，因此它们具有多种可用于执行各种工作的方法。

Program.cs 
string lang = "Java";
string bclass = lang.GetType().Name;
Console.WriteLine(bclass);

string parclass = lang.GetType().BaseType!.Name;
Console.WriteLine(parclass);

if (lang.Equals(string.Empty))
{
    Console.WriteLine("The string is empty");
}
else
{
    Console.WriteLine("The string is not empty");
}

int len = lang.Length;
Console.WriteLine($"The string has {len} characters");

在此程序中，我们演示字符串是对象。 对象必须具有类名、父类，并且还必须具有我们可以调用的一些方法或可以访问的属性。

string lang = "Java";

创建 System.String 类型的对象。

string bclass = lang.GetType().Name;
Console.WriteLine(bclass);

我们确定 lang 变量引用的对象的类名。

string parclass = lang.GetType().BaseType!.Name;
Console.WriteLine(parclass);

收到我们对象的父类。 所有对象至少有一个父类——Object。

if (lang.Equals(string.Empty))
{
    Console.WriteLine("The string is empty");
} else
{
    Console.WriteLine("The string is not empty");
}

对象有多种方法。 使用 Equals 方法，我们检查字符串是否为空。

int len = lang.Length;
Console.WriteLine($"The string has {len} characters");

Length 属性返回字符串的大小。

$ dotnet run
String
Object
The string is not empty
The string has 4 characters

C# 可变 & 不可变字符串

String 是不可变字符序列，而 StringBuilder 是可变字符序列。 下一个示例显示了差异。

Program.cs 
using System.Text;

string name = "Jane";
string name2 = name.Replace('J', 'K');
string name3 = name2.Replace('n', 't');

Console.WriteLine(name);
Console.WriteLine(name3);

var sb = new StringBuilder("Jane");
Console.WriteLine(sb);

sb.Replace('J', 'K', 0, 1);
sb.Replace('n', 't', 2, 1);

Console.WriteLine(sb);

这两个对象都有替换字符串中字符的方法。

string name = "Jane";
string name2 = name.Replace('J', 'K');
string name3 = name2.Replace('n', 't');

对字符串调用 Replace 方法会导致返回一个新的修改后的字符串。 原始字符串不会更改。

sb.Replace('J', 'K', 0, 1);
sb.Replace('n', 't', 2, 1);

StringBuilder 的 Replace 方法将给定索引处的字符替换为新字符。 原始字符串被修改。

$ dotnet run
Jane
Kate
Jane
Kate

C# 字符串连接

可以使用 + 运算符或 Concat 方法添加不可变字符串。 它们形成一个新字符串，该字符串是所有连接字符串的链。 可变字符串具有 Append 方法，该方法从任意数量的其他字符串构建字符串。

也可以使用字符串格式化和内插来连接字符串。

Program.cs 
using System.Text;

Console.WriteLine("Return" + " of " + "the king.");
Console.WriteLine(string.Concat(string.Concat("Return", " of "), "the king."));

var sb = new StringBuilder();
sb.Append("Return");
sb.Append(" of ");
sb.Append("the king.");

Console.WriteLine(sb);

string s1 = "Return";
string s2 = "of";
string s3 = "the king.";

Console.WriteLine("{0} {1} {2}", s1, s2, s3);
Console.WriteLine($"{s1} {s2} {s3}");

该示例通过连接字符串创建五个句子。

Console.WriteLine("Return" + " of " + "the king.");

使用 + 运算符形成一个新字符串。

Console.WriteLine(string.Concat(string.Concat("Return", " of "), "the king."));

Concat 方法连接两个字符串。 该方法是 System.String 类的静态方法。

var sb = new StringBuilder();
sb.Append("Return");
sb.Append(" of ");
sb.Append("the king.");

通过三次调用 Append 方法来创建 StringBuilder 类型的可变对象。

Console.WriteLine("{0} {1} {2}", s1, s2, s3);

使用字符串格式化形成字符串。

Console.WriteLine($"{s1} {s2} {s3}");

最后，使用内插语法添加字符串。

$ dotnet run
Return of the king.
Return of the king.
Return of the king.
Return of the king.
Return of the king.

C# 使用引号

当我们想要显示引号时，例如在直接引语中，必须转义内部引号。

Program.cs 
Console.WriteLine("There are many stars.");
Console.WriteLine("He said, \"Which one is your favourite?\"");

Console.WriteLine(@"
Lao Tzu has said:
""If you do not change direction, you may end up
where you are heading.""
");

此示例打印直接引语。

Console.WriteLine("He said, \"Which one is your favourite?\"");

在常规字符串中，字符使用 \ 转义。

Console.WriteLine(@"
Lao Tzu has said:
""If you do not change direction, you may end up
where you are heading.""
");

在逐字字符串中，引号前面加上另一个引号。

$ dotnet run
There are many stars.
He said, "Which one is your favourite?"

Lao Tzu has said:
"If you do not change direction, you may end up
where you are heading."

C# 比较字符串

我们可以使用 == 运算符比较两个字符串。

Program.cs 
Console.WriteLine("12" == "12");
Console.WriteLine("17" == "9");
Console.WriteLine("aa" == "ab");

在示例程序中，我们比较字符串。

$ dotnet run
True
False
False

string.Compare 方法比较两个指定的字符串，并返回一个整数，指示它们在排序顺序中的相对位置。 如果返回值小于零，则第一个字符串小于第二个字符串。 如果它返回零，则两个字符串相等。 最后，如果返回值大于零，则第一个字符串大于第二个字符串。

Program.cs 
string str1 = "ZetCode";
string str2 = "zetcode";

Console.WriteLine(string.Compare(str1, str2, true));
Console.WriteLine(string.Compare(str1, str2, false));

有一个可选的第三个 ignoreCase 参数。 它确定是否应考虑大小写。

Console.WriteLine(string.Compare(str1, str2, true));

比较两个字符串并忽略大小写。 此行将 0 打印到控制台。

C# 字符串元素

字符串是字符序列。 字符是字符串的基本元素。

Program.cs 
char[] crs = ['Z', 'e', 't', 'C', 'o', 'd', 'e'];
string s = new(crs);

char c1 = s[0];
char c2 = s[^1];

Console.WriteLine(c1);
Console.WriteLine(c2);

int i1 = s.IndexOf('e');
int i2 = s.LastIndexOf('e');

Console.WriteLine("The first index of character e is " + i1);
Console.WriteLine("The last index of character e is " + i2);

Console.WriteLine(s.Contains('t'));
Console.WriteLine(s.Contains('f'));

char[] elements = s.ToCharArray();

foreach (char e in elements)
{
    Console.WriteLine(e);
}

在第一个示例中，我们使用不可变字符串。

char[] crs = ['Z', 'e', 't', 'C', 'o', 'd', 'e'];
string s = new(crs);

从字符数组形成一个新的不可变字符串。

char c1 = s[0];
char c2 = s[^1];

使用数组访问表示法，我们获取字符串的第一个和最后一个字符值。

int i1 = s.IndexOf('e');
int i2 = s.LastIndexOf('e');

使用上述方法，我们获得字符“e”的第一次和最后一次出现。

Console.WriteLine(s.Contains('t'));
Console.WriteLine(s.Contains('f'));

使用 Contains 方法，我们检查字符串是否包含“t”字符。 该方法返回一个布尔值。

char[] elements = s.ToCharArray();

foreach (char e in elements)
{
    Console.WriteLine(e);
}

ToCharArray 方法从字符串创建字符数组。 我们遍历数组并打印每个字符。

$ dotnet run
Z
e
The first index of character e is 1
The last index of character e is 6
True
False
Z
e
t
C
o
d
e

在第二个示例中，我们使用可变字符串的元素。

Program.cs 
using System.Text;

var sb = new StringBuilder("Misty mountains");
Console.WriteLine(sb);

sb.Remove(sb.Length-1, 1);
Console.WriteLine(sb);

sb.Append('s');
Console.WriteLine(sb);

sb.Insert(0, 'T');
sb.Insert(1, 'h');
sb.Insert(2, 'e');
sb.Insert(3, ' ');
Console.WriteLine(sb);

sb.Replace('M', 'm', 4, 1);
Console.WriteLine(sb);

形成一个可变字符串。 我们通过删除、附加、插入和替换字符来修改字符串的内容。

sb.Remove(sb.Length-1, 1);

此行删除最后一个字符。

sb.Append('s');

删除的字符被附加回字符串。

sb.Insert(0, 'T');
sb.Insert(1, 'h');
sb.Insert(2, 'e');
sb.Insert(3, ' ');

我们在字符串的开头插入四个字符。

sb.Replace('M', 'm', 4, 1);

最后，我们替换索引 4 处的字符。

$ dotnet run
Misty mountains
Misty mountain
Misty mountains
The Misty mountains
The misty mountains

C# 字符串 Join 和 Split

Join 连接字符串，Split 分割字符串。

Program.cs 
string[] items = ["C#", "Visual Basic", "Java", "Perl"];

var langs = string.Join(",", items);
Console.WriteLine(langs);

string[] langs2 = langs.Split(',');

foreach (string lang in langs2)
{
    Console.WriteLine(lang);
}

在程序中，我们连接和分割字符串。

string[] items = ["C#", "Visual Basic", "Java", "Perl"];

这是一个字符串数组。 这些字符串将被连接。

string langs = string.Join(",", items);

连接数组中的所有单词。 我们从中构建一个字符串。 每两个单词之间将有一个逗号字符。

string[] langs2 = langs.Split(',');

作为反向操作，我们分割 langs 字符串。 Split 方法返回一个由字符分隔的单词数组。 在我们的例子中，它是一个逗号字符。

foreach (string lang in langs2)
{
    Console.WriteLine(lang);
}

我们遍历数组并打印其元素。

$ dotnet run
C#,Visual Basic,Java,Perl
C#
Visual Basic
Java
Perl

C# 字符串 StartsWith

StartsWith 方法确定此字符串实例是否以指定的字符开头。

Program.cs 
var words = "club\nsky\nblue\ncup\ncoin\nnew\ncent\nowl\nfalcon\nwar\nice";

using var sr = new StringReader(words);

string? line;

while ((line = sr.ReadLine()) != null)
{
    if (line.StartsWith('c')) 
    {
        Console.WriteLine(line);
    }
}

我们在一个字符串中有几个单词。 我们打印所有以字母 c 开头的单词。

$ dotnet run
club
cup
coin
cent

C# 字符串 EndsWith

EndsWith 确定此字符串实例的结尾是否与指定的字符串匹配。

Program.cs 
var words = "club\nsky\nblue\ncup\ncoin\nnew\ncent\nowl\nfalcon\nwar\nice";

using var sr = new StringReader(words);

string? line;

while ((line = sr.ReadLine()) != null)
{
    if (line.EndsWith('y') || line.EndsWith('n')) 
    {
        Console.WriteLine(line);
    }
}

在此示例中，我们打印所有以 n 或 y 结尾的单词。

$ dotnet run
sky
coin
falcon

C# 字符串 ToUpper/ToLower

ToUpper 方法将字符串的所有字符转换为大写。 ToLower 方法将字符串的所有字符转换为小写。

Program.cs 
var word1 = "Cherry";

var u_word1 = word1.ToUpper();
var l_word1 = u_word1.ToLower();

Console.WriteLine(u_word1);
Console.WriteLine(l_word1);

var word2 = "Čerešňa";

var u_word2 = word2.ToUpper();
var l_word2 = u_word2.ToLower();

Console.WriteLine(u_word2);
Console.WriteLine(l_word2);

我们修改两个单词的大小写。

$ dotnet run
CHERRY
cherry
ČEREŠŇA
čerešňa

使用 C# Runes

C# 中的 EnumerateRunes 方法允许您迭代字符串中的各个 Unicode 字符或“runes”。 Rune 由 System.Text.Rune 类型表示，该类型对应于单个 Unicode 标量值，从而可以高效地处理包含来自各种字母表、符号或表情符号的文本。

Program.cs 
var text = "🐄🦙🐘🐫🐑🦝🦍🐯";
var runes = text.EnumerateRunes();

foreach (var rune in runes) 
{
    Console.WriteLine(rune);
}

在此示例中，我们使用 EnumerateRunes 方法来迭代一系列表情符号。 这种方法确保可以准确地处理多字节 Unicode 字符，从而保留它们的完整性和正确的表示形式。

$ dotnet run
🐄
🦙
🐘
🐫
🐑
🦝
🦍
🐯

C# 字符串 Remove

Remove 方法返回一个新字符串，其中删除了当前字符串中指定数量的字符。

Program.cs 
var text = "Did you go there? We did, but we had a \"great\" service there.";

string[] parts = text.Split(" ");

foreach (var part in parts)
{
    var word = removeChars(part);
    Console.WriteLine(word);
}

string removeChars(string part)
{
    var word = part;

    if (part.EndsWith('.') || part.EndsWith('?') || 
        part.EndsWith(',') || part.EndsWith('\"'))
    {
        word = part.Remove(part.Length - 1, 1);
    }

    if (word.StartsWith('\"'))
    {
        word = word.Remove(0, 1);
    }

    return word;
}

该示例将字符串拆分为单词，并删除潜在的逗号、点、问号或双引号。

if (part.EndsWith('.') || part.EndsWith('?') || 
    part.EndsWith(',') || part.EndsWith('\"'))
{
    word = part.Remove(part.Length - 1, 1);
}

如果当前单词以任何字符结尾，我们将使用 Remove 删除它。

if (word.StartsWith('\"'))
{
    word = word.Remove(0, 1);
}

此外，如果双引号位于字符串之前，我们将删除双引号字符。

$ dotnet run
Did
you
go
there
We
did
but
we
had
a
great
service
there

C# 子字符串

Substring 方法从字符串中检索子字符串。

Program.cs 
var word = "bookcase";

Console.WriteLine(word.Substring(0, 4));
Console.WriteLine(word.Substring(4, 4));
Console.WriteLine(word.Substring(4));

该示例使用 substring 方法创建两个子字符串。

Console.WriteLine(word.Substring(0, 4));

我们从字符串中获取第一个单词。 第一个参数是起始索引，第二个参数是子字符串的长度。

Console.WriteLine(word.Substring(4, 4));

我们得到第二个单词。

Console.WriteLine(word.Substring(4));

此重载方法从指定的索引开始，并继续到字符串的结尾。

$ dotnet run
book
case
case

C# 字符串回文

回文是指一个单词、数字、短语或其他字符序列，正着读和反着读都一样，例如 madam 或 racecar。有很多方法可以检查一个字符串是否是回文。以下示例是可能的解决方案之一。

Program.cs 
Console.WriteLine(isPalindrome("radar"));
Console.WriteLine(isPalindrome("kayak"));
Console.WriteLine(isPalindrome("forest"));

bool isPalindrome(string original)
{
    char[] data = original.ToCharArray();

    int i = 0;
    int j = data.Length - 1;

    while (j > i)
    {

        if (data[i] != data[j])
        {
            return false;
        }

        i++;
        j--;
    }

    return true;
}

我们有一个 isPalindrome 方法的实现。

char[] data = original.ToCharArray();

我们将字符串转换为字符数组。

int i = 0;
int j = data.Length - 1;

while (j > i)
{
    if (data[i] != data[j])
    {
        return false;
    }

    i++;
    j--;
}

return true;

我们遍历数组并将左侧字符与右侧对应的字符进行比较。 如果所有匹配，则返回 true，否则返回 false。

$ dotnet run
True
True
False

C# 字符串 Copy vs Clone

我们描述了两种方法之间的区别：Copy 和 Clone。 Copy 方法创建一个新的字符串实例，该实例的值与指定的字符串相同。 Clone 方法返回对正在克隆的字符串的引用。 它不是堆上字符串的独立副本。 它是对同一字符串的另一个引用。

Program.cs 
string str = "ZetCode";

string cloned = (string) str.Clone();
string copied = string.Copy(str);

Console.WriteLine(str.Equals(cloned)); // prints True
Console.WriteLine(str.Equals(copied)); // prints True

Console.WriteLine(ReferenceEquals(str, cloned)); // prints True
Console.WriteLine(ReferenceEquals(str, copied)); // prints False

我们的示例演示了这两种方法之间的区别。

string cloned = (string) str.Clone();
string copied = string.Copy(str);

字符串值被克隆和复制。

Console.WriteLine(str.Equals(cloned)); // prints True
Console.WriteLine(str.Equals(copied)); // prints True

Equals 方法确定两个字符串对象是否具有相同的值。 所有三个字符串的内容都相同。

Console.WriteLine(ReferenceEquals(str, cloned)); // prints True
Console.WriteLine(ReferenceEquals(str, copied)); // prints False

ReferenceEquals 方法比较两个引用对象。 因此，将复制的字符串与原始字符串进行比较会返回 false。 因为它们是两个不同的对象。

C# 字符串格式

在接下来的示例中，我们格式化字符串。 更深入的报道在 C# 字符串格式 文章中介绍。

.NET 平台具有一个称为复合格式化的功能。 Format 和 WriteLine 方法支持它。 该方法将对象列表和一个复合格式字符串作为输入。 格式字符串由固定字符串和一些格式项组成。 这些格式项是索引占位符，与列表中的对象相对应。

格式项具有以下语法

{index[,length][:formatString]}

index 组件是强制性的。 它是从 0 开始的数字，指的是对象列表中的一个项目。 多个项目可以引用对象列表的同一元素。 如果某个对象未被格式项引用，则该对象将被忽略。 如果我们引用到对象列表的边界之外，则会抛出运行时异常。

length 组件是可选的。 它是参数的字符串表示形式中的最小字符数。 如果为正数，则参数右对齐；如果为负数，则参数左对齐。 如果指定了该值，则必须有一个冒号分隔索引和长度。

formatString 是可选的。 它是一个以特定方式格式化值的字符串。 它可以用于格式化日期、时间、数字或枚举。

Program.cs 
int oranges = 2;
int apples = 4;
int bananas = 3;

string str1 = "There are {0} oranges, {1} apples and {2} bananas";
string str2 = "There are {1} oranges, {2} bananas and {0} apples";

Console.WriteLine(str1, oranges, apples, bananas);
Console.WriteLine(str2, apples, oranges, bananas);

我们将一条简单的消息打印到控制台。 我们仅使用格式项的 index 组件。

string str1 = "There are {0} oranges, {1} apples and {2} bananas";

{0}、{1} 和 {2} 是格式项。 我们指定 index 组件。 其他组件是可选的。

Console.WriteLine(str1, oranges, apples, bananas);

现在我们将复合格式放在一起。 我们有字符串和对象列表（橙子、苹果、香蕉）。 {0} 格式项引用橙子。 WriteLine 方法将 {0} 格式项替换为橙子变量的内容。

string str2 = "There are {1} oranges, {2} bananas and {0} apples";

引用对象的格式项的顺序不是必需的。

$ dotnet run
There are 2 oranges, 4 apples and 3 bananas
There are 2 oranges, 3 bananas and 4 apples

下一个示例格式化数字数据。

Program.cs 
Console.WriteLine("{0}  {1, 12}", "Decimal", "Hexadecimal");

Console.WriteLine("{0:D}  {1,8:X}", 502, 546);
Console.WriteLine("{0:D}  {1,8:X}", 345, 765);
Console.WriteLine("{0:D}  {1,8:X}", 320, 654);
Console.WriteLine("{0:D}  {1,8:X}", 120, 834);
Console.WriteLine("{0:D}  {1,8:X}", 620, 454);

我们以十进制和十六进制格式打印数字。 我们还使用 length 组件对齐数字。

Console.WriteLine("{0:D}  {1,8:X}", 502, 546);;

{0:D} 格式项指定将从提供的对象列表中获取第一个项目并以十进制格式格式化。 {1,8:X} 格式项采用第二个项目。 以十六进制格式 :X 格式化它。 并且字符串长度将为 8 个字符 8 。 因为该数字只有三个字符，所以它是右对齐的并用空字符串填充。

$ dotnet run
Decimal   Hexadecimal
502       222
345       2FD
320       28E
120       342
620       1C6

最后两个示例格式化数字和日期数据。

Program.cs 
Console.WriteLine(string.Format("Number: {0:N}", 126));
Console.WriteLine(string.Format("Scientific: {0:E}", 126));
Console.WriteLine(string.Format("Currency: {0:C}", 126));
Console.WriteLine(string.Format("Percent: {0:P}", 126));
Console.WriteLine(string.Format("Hexadecimal: {0:X}", 126));

该示例演示了数字的标准格式说明符。 数字 126 以五种不同的格式打印：常规、科学、货币、百分比和十六进制。

$ dotnet run
Number: 126.00
Scientific: 1.260000E+002
Currency: $126.00
Percent: 12,600.00%
Hexadecimal: 7E

最后，我们格式化日期和时间数据。

Program.cs 
DateTime today = DateTime.Now;

Console.WriteLine(string.Format("Short date: {0:d}", today));
Console.WriteLine(string.Format("Long date: {0:D}", today));
Console.WriteLine(string.Format("Short time: {0:t}", today));
Console.WriteLine(string.Format("Long time: {0:T}", today));
Console.WriteLine(string.Format("Month: {0:M}", today));
Console.WriteLine(string.Format("Year: {0:Y}", today));

代码示例显示了当前日期的六种不同格式。

$ dotnet run
Short date: 5/1/2025
Long date: Thursday, May 1, 2025
Short time: 5:13 PM
Long time: 5:13:30 PM
Month: May 1
Year: May 2025

修剪空格

Trim、TrimStart 和 TrimEnd 方法用于从字符串的开头和/或结尾删除空格字符。 Trim 方法从两端删除空格，而 TrimStart 从开头删除空格，TrimEnd 从结尾删除空格。 这些方法返回一个删除了指定字符的新字符串，使原始字符串保持不变。

Program.cs 
string input = "   hello there   ";

Console.WriteLine($"Original: '{input}'");
Console.WriteLine($"Trim: '{input.Trim()}'");
Console.WriteLine($"TrimStart: '{input.TrimStart()}'");
Console.WriteLine($"TrimEnd: '{input.TrimEnd()}'");

此示例演示如何使用 Trim、TrimStart 和 TrimEnd 从字符串的开头和/或结尾删除空格。

使用区域性和区分大小写进行字符串比较

String.Compare 方法用于使用不同的 StringComparison 选项比较两个字符串。 StringComparison 枚举提供了区分区域性和区分大小写的比较选项。 StringComparison.Ordinal 选项执行区分大小写的序号比较，而 StringComparison.InvariantCultureIgnoreCase 使用固定区域性执行不区分大小写的比较。

这对于以不受系统当前区域设置影响的方式比较字符串非常有用。 String.Compare 方法返回一个整数，指示两个字符串在排序顺序中的相对位置。 负值表示第一个字符串在第二个字符串之前，零表示它们相等，正值表示第一个字符串在第二个字符串之后。

Program.cs 
string a = "straße";
string b = "STRASSE";

Console.WriteLine(string.Compare(a, b, StringComparison.Ordinal));
Console.WriteLine(string.Compare(a, b, StringComparison.InvariantCultureIgnoreCase));

此示例演示了使用不同的 StringComparison 选项比较字符串，展示了区域性和区分大小写的影响。

替换和删除子字符串

Replace 方法用于将字符串中所有出现的指定子字符串替换为另一个子字符串。 Remove 方法用于从字符串中删除指定数量的字符，从指定的索引开始。 这两个方法都会返回一个应用了修改的新字符串，而原始字符串保持不变。

Replace 方法对于更改字符串的特定部分非常有用，而 Remove 方法对于删除不需要的字符或子字符串非常有用。 Remove 方法接受两个参数：起始索引和要删除的字符数。 Replace 方法接受两个参数：要替换的子字符串和要插入的新子字符串。 这两个方法都会返回一个应用了指定修改的新字符串，而原始字符串保持不变。

Program.cs 
string text = "The quick brown fox jumps over the lazy dog.";
string replaced = text.Replace("fox", "cat");
string removed = text.Remove(16, 4); // removes 'fox '

Console.WriteLine(replaced);
Console.WriteLine(removed);

此示例演示了如何通过索引和长度替换子字符串和删除字符串的一部分。

使用 PadLeft 和 PadRight 进行格式化

PadLeft 和 PadRight 方法用于在字符串的左侧或右侧分别用指定的字符进行填充。 PadLeft 方法将填充字符添加到字符串的左侧，直到其达到指定的总宽度，而 PadRight 方法将填充字符添加到字符串的右侧。

这两个方法都会返回一个应用了填充的新字符串，而原始字符串保持不变。 填充字符可以指定为一个参数，总宽度也可以指定。 如果原始字符串已经等于或大于指定的宽度，则不会添加任何填充。 这些方法对于格式化字符串以进行显示非常有用，例如在表格中对齐文本或确保输出的宽度一致。

Program.cs 
string word = "42";

Console.WriteLine(word.PadLeft(5, '0'));
Console.WriteLine(word.PadRight(8, '-'));

此示例演示了如何使用 PadLeft 和 PadRight 对齐或填充字符串。

使用 IndexOf 和 LastIndexOf 进行高效的字符串搜索

IndexOf 和 LastIndexOf 方法用于查找字符串中指定字符或子字符串的位置。 IndexOf 方法返回指定字符或子字符串的第一个出现的基于零的索引，而 LastIndexOf 方法返回最后一个出现的基于零的索引。 如果未找到指定的字符或子字符串，则这两个方法都返回 -1。

这些方法对于在较大的字符串中搜索特定字符或子字符串非常有用，允许您确定第一次或最后一次出现的位置。 默认情况下，搜索区分大小写，但您可以指定一个 StringComparison 选项来控制搜索的大小写敏感性。 IndexOf 和 LastIndexOf 方法还可以采用额外的参数来指定起始索引和要在其中搜索的字符数。

Program.cs 
string phrase = "abracadabra";
int first = phrase.IndexOf('a');
int last = phrase.LastIndexOf('a');

Console.WriteLine($"First 'a': {first}");
Console.WriteLine($"Last 'a': {last}");

此示例使用 IndexOf 和 LastIndexOf 来查找字符串中字符的位置。

来源

字符串和字符串字面量

在本文中，我们探讨了 C# 字符串的基础知识，包括它们的定义、关键类和实际用法。 通过理解字符串在 C# 中的工作方式，您可以有效地处理和操作应用程序中的文本，无论您是使用不可变对象还是动态字符串生成器。

作者

我叫 Jan Bodnar，是一位充满热情的程序员，拥有丰富的编程经验。 自 2007 年以来，我一直在撰写编程文章。 迄今为止，我已经撰写了超过 1,400 篇文章和 8 本电子书。 我在编程教学方面拥有超过十年的经验。

列出所有 C# 教程。