销售电话: 1-800-867-1380
信息
您所需的主题如下所示。但此主题未包含在此库中。

String 类

表示文本,即一系列 Unicode 字符。

命名空间:  System
程序集:  mscorlib(在 mscorlib.dll 中)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class String : IComparable, 
	ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, 
	IEnumerable, IEquatable<string>

String 类型公开以下成员。

  名称说明
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持String(Char*)String 类的新实例初始化为由指向 Unicode 字符数组的指定指针指示的值。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持String(Char[])String 类的新实例初始化为由 Unicode 字符数组指示的值。
公共方法由 XNA Framework 提供支持String(SByte*)String 类的新实例初始化为由指向 8 位有符号整数数组的指针指示的值。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持String(Char, Int32)String 类的新实例初始化为由重复指定次数的指定 Unicode 字符指示的值。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持String(Char*, Int32, Int32)String 类的新实例初始化为由指向 Unicode 字符数组的指定指针、该数组内的起始字符位置和一个长度指示的值。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持String(Char[], Int32, Int32)String 类的新实例初始化为由 Unicode 字符数组、该数组内的起始字符位置和一个长度指示的值。
公共方法String(SByte*, Int32, Int32)String 类的新实例初始化为由指向 8 位有符号整数数组的指定指针、该数组内的起始位置和一个长度指示的值。
公共方法String(SByte*, Int32, Int32, Encoding)String 类的新实例初始化为由指向 8 位有符号整数数组的指定指针、该数组内的起始位置、长度以及 Encoding 对象指示的值。
页首

  名称说明
公共属性由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Chars获取当前 String 对象中位于指定位置的 Char 对象。
公共属性由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Length获取当前 String 对象中的字符数。
页首

  名称说明
公共方法由 XNA Framework 提供支持Clone返回对此 String 实例的引用。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Compare(String, String)比较两个指定的 String 对象,并返回一个指示二者在排序顺序中的相对位置的整数。
公共方法静态成员由 XNA Framework 提供支持Compare(String, String, Boolean)比较两个指定的 String 对象(其中忽略或考虑其大小写),并返回一个整数,指示二者在排序顺序中的相对位置。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Compare(String, String, StringComparison)使用指定的规则比较两个指定的 String 对象,并返回一个整数,指示二者在排序顺序中的相对位置。
公共方法静态成员由 XNA Framework 提供支持Compare(String, String, Boolean, CultureInfo)比较两个指定的 String 对象(其中忽略或考虑其大小写,并使用区域性特定的信息干预比较),并返回一个整数,指示二者在排序顺序中的相对位置。
公共方法静态成员受 可移植类库 支持Compare(String, String, CultureInfo, CompareOptions)对两个指定的 String 对象进行比较,使用指定的比较选项和区域性特定的信息来影响比较,并返回一个整数,该整数指示这两个字符串在排序顺序中的关系。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Compare(String, Int32, String, Int32, Int32)对两个指定的 String 对象的子字符串进行比较,并返回一个指示二者在排序顺序中的相对位置的整数。
公共方法静态成员由 XNA Framework 提供支持Compare(String, Int32, String, Int32, Int32, Boolean)比较两个指定的 String 对象的子字符串(忽略或考虑其大小写),并返回一个整数,指示二者在排序顺序中的相对位置。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Compare(String, Int32, String, Int32, Int32, StringComparison)使用指定的规则比较两个指定的 String 对象的子字符串,并返回一个整数,指示二者在排序顺序中的相对位置。
公共方法静态成员由 XNA Framework 提供支持Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)比较两个指定的 String 对象的子字符串(其中忽略或考虑其大小写,并使用区域性特定的信息干预比较),并返回一个整数,指示二者在排序顺序中的相对位置。
公共方法静态成员Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)对两个指定 String 对象的子字符串进行比较,使用指定的比较选项和区域性特定的信息来影响比较,并返回一个整数,该整数指示这两个子字符串在排序顺序中的关系。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持CompareOrdinal(String, String)通过计算每个字符串中相应 Char 对象的数值来比较两个指定的 String 对象。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持CompareOrdinal(String, Int32, String, Int32, Int32)通过计算两个指定的 String 对象的每个子字符串中相应 Char 对象的数值比较子字符串。
公共方法由 XNA Framework 提供支持CompareTo(Object)将此实例与指定的 Object 进行比较,并指示此实例在排序顺序中是位于指定的 Object 之前、之后还是与其出现在同一位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持CompareTo(String)将此实例与指定的 String 对象进行比较,并指示此实例在排序顺序中是位于指定的 String 之前、之后还是与其出现在同一位置。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(Object)创建指定对象的字符串表示形式。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(Object[])连接指定 Object 数组中的元素的字符串表示形式。
公共方法静态成员受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(IEnumerable<String>)串联类型为 StringIEnumerable<T> 构造集合的成员。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(String[])连接指定的 String 数组的元素。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(Object, Object)连接两个指定对象的字符串表示形式。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(String, String)连接 String 的两个指定实例。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(Object, Object, Object)连接三个指定对象的字符串表示形式。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(String, String, String)连接 String 的三个指定实例。
公共方法静态成员Concat(Object, Object, Object, Object)将四个指定对象的字符串表示形式与可选变量长度参数列表中指定的任何对象串联起来。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat(String, String, String, String)连接 String 的四个指定实例。
公共方法静态成员受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Concat<T>(IEnumerable<T>)串联 IEnumerable<T> 实现的成员。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Contains返回一个值,该值指示指定的子串是否出现在此字符串中。
公共方法静态成员由 XNA Framework 提供支持Copy创建一个与指定的 String 具有相同值的 String 的新实例。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持CopyTo将指定数目的字符从此实例中的指定位置复制到 Unicode 字符数组中的指定位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持EndsWith(String)确定此字符串实例的结尾是否与指定的字符串匹配。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持EndsWith(String, StringComparison)确定使用指定的比较选项进行比较时此字符串实例的结尾是否与指定的字符串匹配。
公共方法EndsWith(String, Boolean, CultureInfo)确定在使用指定的区域性进行比较时此字符串实例的结尾是否与指定的字符串匹配。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equals(Object)确定此实例是否与指定的对象(也必须是 String 对象)具有相同的值。 (重写 Object.Equals(Object)。)
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equals(String)确定此实例是否与另一个指定的 String 对象具有相同的值。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equals(String, String)确定两个指定的 String 对象是否具有相同的值。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equals(String, StringComparison)确定此字符串是否与指定的 String 对象具有相同的值。 参数指定区域性、大小写以及比较所用的排序规则。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equals(String, String, StringComparison)确定两个指定的 String 对象是否具有相同的值。 参数指定区域性、大小写以及比较所用的排序规则。
公共方法静态成员由 XNA Framework 提供支持Format(String, Object)将指定字符串中的一个或多个格式项替换为指定对象的字符串表示形式。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Format(String, Object[])将指定字符串中的格式项替换为指定数组中相应对象的字符串表示形式。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Format(IFormatProvider, String, Object[])将指定字符串中的格式项替换为指定数组中相应对象的字符串表示形式。 参数提供区域性特定的格式设置信息。
公共方法静态成员由 XNA Framework 提供支持Format(String, Object, Object)将指定字符串中的格式项替换为两个指定对象的字符串表示形式。
公共方法静态成员由 XNA Framework 提供支持Format(String, Object, Object, Object)将指定字符串中的格式项替换为三个指定对象的字符串表示形式。
公共方法由 XNA Framework 提供支持GetEnumerator检索一个可以循环访问此字符串中的每个字符的对象。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持GetHashCode返回该字符串的哈希代码。 (重写 Object.GetHashCode()。)
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持GetType获取当前实例的 Type (继承自 Object。)
公共方法由 XNA Framework 提供支持GetTypeCode返回类 StringTypeCode
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(Char)报告指定 Unicode 字符在此字符串中的第一个匹配项的从零开始的索引。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(String)报告指定字符串在此实例中的第一个匹配项的从零开始的索引。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(Char, Int32)报告指定 Unicode 字符在此字符串中的第一个匹配项的从零开始的索引。 该搜索从指定字符位置开始。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(String, Int32)报告指定字符串在此实例中的第一个匹配项的从零开始的索引。 该搜索从指定字符位置开始。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(String, StringComparison)报告指定的字符串在当前 String 对象中的第一个匹配项的从零开始的索引。 一个参数指定要用于指定字符串的搜索类型。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(Char, Int32, Int32)报告指定字符在此实例中的第一个匹配项的从零开始的索引。 搜索从指定字符位置开始,并检查指定数量的字符位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(String, Int32, Int32)报告指定字符串在此实例中的第一个匹配项的从零开始的索引。 搜索从指定字符位置开始,并检查指定数量的字符位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(String, Int32, StringComparison)报告指定的字符串在当前 String 对象中的第一个匹配项的从零开始的索引。 参数指定当前字符串中的起始搜索位置以及用于指定字符串的搜索类型。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOf(String, Int32, Int32, StringComparison)报告指定的字符串在当前 String 对象中的第一个匹配项的从零开始的索引。 参数指定当前字符串中的起始搜索位置、要搜索的当前字符串中的字符数量,以及要用于指定字符串的搜索类型。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOfAny(Char[])报告指定 Unicode 字符数组中的任意字符在此实例中第一个匹配项的从零开始的索引。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOfAny(Char[], Int32)报告指定 Unicode 字符数组中的任意字符在此实例中第一个匹配项的从零开始的索引。 该搜索从指定字符位置开始。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IndexOfAny(Char[], Int32, Int32)报告指定 Unicode 字符数组中的任意字符在此实例中第一个匹配项的从零开始的索引。 搜索从指定字符位置开始,并检查指定数量的字符位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert返回一个新的字符串,在此实例中的指定的索引位置插入指定的字符串。
公共方法静态成员由 XNA Framework 提供支持Intern检索系统对指定 String 的引用。
公共方法静态成员由 XNA Framework 提供支持IsInterned检索对指定 String 的引用。
公共方法IsNormalized()指示此字符串是否符合 Unicode 范式 C。
公共方法IsNormalized(NormalizationForm)指示此字符串是否符合指定的 Unicode 范式。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IsNullOrEmpty指示指定的字符串是 null 还是 Empty 字符串。
公共方法静态成员受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IsNullOrWhiteSpace指示指定的字符串是 null、空还是仅由空白字符组成。
公共方法静态成员受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Join(String, IEnumerable<String>)串联类型为 StringIEnumerable<T> 构造集合的成员,其中在每个成员之间使用指定的分隔符。
公共方法静态成员受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Join(String, Object[])串联对象数组的各个元素,其中在每个元素之间使用指定的分隔符。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Join(String, String[])串联字符串数组的所有元素,其中在每个元素之间使用指定的分隔符。
公共方法静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Join(String, String[], Int32, Int32)串联字符串数组的指定元素,其中在每个元素之间使用指定的分隔符。
公共方法静态成员受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Join<T>(String, IEnumerable<T>)串联集合的成员,其中在每个成员之间使用指定的分隔符。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(Char)报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(String)报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(Char, Int32)报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(String, Int32)报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(String, StringComparison)报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。 一个参数指定要用于指定字符串的搜索类型。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(Char, Int32, Int32)报告指定的 Unicode 字符在此实例内的子字符串中的最后一个匹配项的从零开始的索引的位置。 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(String, Int32, Int32)报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(String, Int32, StringComparison)报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。 一个参数指定要执行搜索指定字符串的比较类型。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOf(String, Int32, Int32, StringComparison)报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。 搜索在所指定的字符位置的数目的字符串开始时,开始指定字符和其后面的位置。 一个参数指定要执行搜索指定字符串的比较类型。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOfAny(Char[])报告在 Unicode 数组中指定的一个或多个字符在此实例中的最后一个匹配项的从零开始的索引的位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOfAny(Char[], Int32)报告在 Unicode 数组中指定的一个或多个字符在此实例中的最后一个匹配项的从零开始的索引的位置。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持LastIndexOfAny(Char[], Int32, Int32)报告在 Unicode 数组中指定的一个或多个字符在此实例中的最后一个匹配项的从零开始的索引的位置。 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。
公共方法Normalize()返回一个新字符串,其文本值与此字符串相同,但其二进制表示形式符合 Unicode 范式 C。
公共方法Normalize(NormalizationForm)返回一个新字符串,其文本值与此字符串相同,但其二进制表示形式符合指定的 Unicode 范式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持PadLeft(Int32)返回一个新字符串,该字符串通过在此实例中的字符左侧填充空格来达到指定的总长度,从而实现右对齐。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持PadLeft(Int32, Char)返回一个新字符串,该字符串通过在此实例中的字符左侧填充指定的 Unicode 字符来达到指定的总长度,从而使这些字符右对齐。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持PadRight(Int32)返回一个新字符串,该字符串通过在此字符串中的字符右侧填充空格来达到指定的总长度,从而使这些字符左对齐。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持PadRight(Int32, Char)返回一个新字符串,该字符串通过在此字符串中的字符右侧填充指定的 Unicode 字符来达到指定的总长度,从而使这些字符左对齐。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Remove(Int32)返回当前实例中从指定位置到最后位置的所有以删除的字符的新字符串。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Remove(Int32, Int32)返回指定数量字符在当前这个实例起始点在已删除的指定的位置的新字符串。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Replace(Char, Char)返回一个新字符串,其中此实例中出现的所有指定 Unicode 字符都替换为另一个指定的 Unicode 字符。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Replace(String, String)返回一个新字符串,其中当前实例中出现的所有指定字符串都替换为另一个指定的字符串。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Split(Char[])返回的字符串数组包含此实例中的子字符串(由指定 Unicode 字符数组的元素分隔)。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Split(Char[], Int32)返回的字符串数组包含此实例中的子字符串(由指定 Unicode 字符数组的元素分隔)。 参数指定返回的子字符串的最大数量。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Split(Char[], StringSplitOptions)返回的字符串数组包含此字符串中的子字符串(由指定 Unicode 字符数组的元素分隔)。 参数指定是否返回空数组元素。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Split(String[], StringSplitOptions)返回的字符串数组包含此字符串中的子字符串(由指定字符串数组的元素分隔)。 参数指定是否返回空数组元素。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Split(Char[], Int32, StringSplitOptions)返回的字符串数组包含此字符串中的子字符串(由指定 Unicode 字符数组的元素分隔)。 参数指定要返回子字符串的最大数量,以及是否返回空数组元素。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Split(String[], Int32, StringSplitOptions)返回的字符串数组包含此字符串中的子字符串(由指定字符串数组的元素分隔)。 参数指定要返回子字符串的最大数量,以及是否返回空数组元素。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StartsWith(String)确定此字符串实例的开头是否与指定的字符串匹配。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StartsWith(String, StringComparison)确定在使用指定的比较选项进行比较时此字符串实例的开头是否与指定的字符串匹配。
公共方法StartsWith(String, Boolean, CultureInfo)确定在使用指定的区域性进行比较时此字符串实例的开头是否与指定的字符串匹配。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Substring(Int32)从此实例检索子字符串。 子字符串在指定的字符位置开始并一直到该字符串的末尾。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Substring(Int32, Int32)从此实例检索子字符串。 子字符串从指定的字符位置开始且具有指定的长度。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToCharArray()将此实例中的字符复制到 Unicode 字符数组。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToCharArray(Int32, Int32)将此实例中的指定子字符串内的字符复制到 Unicode 字符数组。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToLower()返回此字符串转换为小写形式的副本。
公共方法由 XNA Framework 提供支持ToLower(CultureInfo)根据指定区域性的大小写规则返回此字符串转换为小写形式的副本。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToLowerInvariant返回此 String 对象的转换为小写形式的副本,返回时使用固定区域性的大小写规则。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToString()返回 String 的此实例;不执行实际转换。 (重写 Object.ToString()。)
公共方法由 XNA Framework 提供支持ToString(IFormatProvider)返回 String 的此实例;不执行实际转换。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToUpper()返回此字符串转换为大写形式的副本。
公共方法由 XNA Framework 提供支持ToUpper(CultureInfo)根据指定区域性的大小写规则返回此字符串转换为大写形式的副本。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToUpperInvariant返回此 String 对象的转换为大写形式的副本,返回时使用固定区域性的大小写规则。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Trim()从当前 String 对象移除所有前导空白字符和尾部空白字符。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Trim(Char[])从当前 String 对象移除数组中指定的一组字符的所有前导匹配项和尾部匹配项。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持TrimEnd从当前 String 对象移除数组中指定的一组字符的所有尾部匹配项。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持TrimStart从当前 String 对象移除数组中指定的一组字符的所有前导匹配项。
页首

  名称说明
公共运算符静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equality确定两个指定的字符串是否具有相同的值。
公共运算符静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Inequality确定两个指定的字符串是否具有不同的值。
页首

  名称说明
公共扩展方法由 XNA Framework 提供支持Aggregate<Char>(Func<Char, Char, Char>)已重载。 对序列应用累加器函数。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Aggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)已重载。 对序列应用累加器函数。 将指定的种子值用作累加器初始值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Aggregate<Char, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, Char, TAccumulate>, Func<TAccumulate, TResult>)已重载。 对序列应用累加器函数。 将指定的种子值用作累加器的初始值,并使用指定的函数选择结果值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持All<Char>确定序列中的所有元素是否满足条件。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Any<Char>()已重载。 确定序列是否包含任何元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Any<Char>(Func<Char, Boolean>)已重载。 确定序列中是否存在元素满足条件。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持AsEnumerable<Char>返回类型为 IEnumerable<T> 的输入。 (由 Enumerable 定义。)
公共扩展方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持AsParallel()已重载。 启用查询的并行化。 (由 ParallelEnumerable 定义。)
公共扩展方法AsParallel<Char>()已重载。 启用查询的并行化。 (由 ParallelEnumerable 定义。)
公共扩展方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持AsQueryable()已重载。 IEnumerable 转换为 IQueryable (由 Queryable 定义。)
公共扩展方法AsQueryable<Char>()已重载。 将泛型 IEnumerable<T> 转换为泛型 IQueryable<T> (由 Queryable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Int32>)已重载。 计算 Int32 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Nullable<Int32>>)已重载。 计算可以为 null 的 Int32 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Int64>)已重载。 计算 Int64 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Nullable<Int64>>)已重载。 计算可以为 null 的 Int64 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Single>)已重载。 计算 Single 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Nullable<Single>>)已重载。 计算可以为 null 的 Single 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Double>)已重载。 计算 Double 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Nullable<Double>>)已重载。 计算可以为 null 的 Double 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Decimal>)已重载。 计算 Decimal 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Average<Char>(Func<Char, Nullable<Decimal>>)已重载。 计算可以为 null 的 Decimal 值序列的平均值,该值可通过调用输入序列的每个元素的转换函数获取。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Cast<TResult>IEnumerable 的元素强制转换为指定的类型。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Concat<Char>连接两个序列。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Contains<Char>(Char)已重载。 通过使用默认的相等比较器确定序列是否包含指定的元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Contains<Char>(Char, IEqualityComparer<Char>)已重载。 通过使用指定的 IEqualityComparer<T> 确定序列是否包含指定的元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Count<Char>()已重载。 返回序列中的元素数量。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Count<Char>(Func<Char, Boolean>)已重载。 返回一个数字,表示在指定的序列中满足条件的元素数量。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持DefaultIfEmpty<Char>()已重载。 返回指定序列的元素;如果序列为空,则返回单一实例集合中的类型参数的默认值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持DefaultIfEmpty<Char>(Char)已重载。 返回指定序列中的元素;如果序列为空,则返回单一实例集合中的指定值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Distinct<Char>()已重载。 通过使用默认的相等比较器对值进行比较返回序列中的非重复元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Distinct<Char>(IEqualityComparer<Char>)已重载。 通过使用指定的 IEqualityComparer<T> 对值进行比较返回序列中的非重复元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ElementAt<Char>返回序列中指定索引处的元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ElementAtOrDefault<Char>返回序列中指定索引处的元素;如果索引超出范围,则返回默认值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Except<Char>(IEnumerable<Char>)已重载。 通过使用默认的相等比较器对值进行比较生成两个序列的差集。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Except<Char>(IEnumerable<Char>, IEqualityComparer<Char>)已重载。 通过使用指定的 IEqualityComparer<T> 对值进行比较产生两个序列的差集。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持First<Char>()已重载。 返回序列中的第一个元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持First<Char>(Func<Char, Boolean>)已重载。 返回序列中满足指定条件的第一个元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持FirstOrDefault<Char>()已重载。 返回序列中的第一个元素;如果序列中不包含任何元素,则返回默认值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持FirstOrDefault<Char>(Func<Char, Boolean>)已重载。 返回序列中满足条件的第一个元素;如果未找到这样的元素,则返回默认值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey>(Func<Char, TKey>)已重载。 根据指定的键选择器函数对序列中的元素进行分组。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)已重载。 根据指定的键选择器函数对序列中的元素进行分组,并使用指定的比较器对键进行比较。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)已重载。 根据指定的键选择器函数对序列中的元素进行分组,并且通过使用指定的函数对每个组中的元素进行投影。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>)已重载。 根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)已重载。 根据键选择器函数对序列中的元素进行分组。 通过使用比较器对键进行比较,并且通过使用指定的函数对每个组的元素进行投影。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>, IEqualityComparer<TKey>)已重载。 根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的比较器对键进行比较。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)已重载。 根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的函数对每个组的元素进行投影。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)已重载。 根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的比较器对键值进行比较,并且通过使用指定的函数对每个组的元素进行投影。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)已重载。 基于键相等对两个序列的元素进行关联并对结果进行分组。 使用默认的相等比较器对键进行比较。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持GroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)已重载。 基于键相等对两个序列的元素进行关联并对结果进行分组。 使用指定的 IEqualityComparer<T> 对键进行比较。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Intersect<Char>(IEnumerable<Char>)已重载。 通过使用默认的相等比较器对值进行比较生成两个序列的交集。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Intersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)已重载。 通过使用指定的 IEqualityComparer<T> 对值进行比较以生成两个序列的交集。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Join<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)已重载。 基于匹配键对两个序列的元素进行关联。 使用默认的相等比较器对键进行比较。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Join<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)已重载。 基于匹配键对两个序列的元素进行关联。 使用指定的 IEqualityComparer<T> 对键进行比较。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Last<Char>()已重载。 返回序列的最后一个元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Last<Char>(Func<Char, Boolean>)已重载。 返回序列中满足指定条件的最后一个元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持LastOrDefault<Char>()已重载。 返回序列中的最后一个元素;如果序列中不包含任何元素,则返回默认值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持LastOrDefault<Char>(Func<Char, Boolean>)已重载。 返回序列中满足条件的最后一个元素;如果未找到这样的元素,则返回默认值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持LongCount<Char>()已重载。 返回一个 Int64,表示序列中的元素的总数量。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持LongCount<Char>(Func<Char, Boolean>)已重载。 返回一个 Int64,表示序列中满足条件的元素的数量。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>()已重载。 返回泛型序列中的最大值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Int32>)已重载。 调用序列的每个元素上的转换函数并返回最大 Int32 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Nullable<Int32>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Int32 的最大值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Int64>)已重载。 调用序列的每个元素上的转换函数并返回最大 Int64 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Nullable<Int64>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Int64 的最大值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Single>)已重载。 调用序列的每个元素上的转换函数并返回最大 Single 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Nullable<Single>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Single 的最大值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Double>)已重载。 调用序列的每个元素上的转换函数并返回最大 Double 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Nullable<Double>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Double 的最大值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Decimal>)已重载。 调用序列的每个元素上的转换函数并返回最大 Decimal 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char>(Func<Char, Nullable<Decimal>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Decimal 的最大值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Max<Char, TResult>(Func<Char, TResult>)已重载。 调用泛型序列的每个元素上的转换函数并返回最大结果值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>()已重载。 返回泛型序列中的最小值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Int32>)已重载。 调用序列的每个元素上的转换函数并返回最小 Int32 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Nullable<Int32>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Int32 的最小值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Int64>)已重载。 调用序列的每个元素上的转换函数并返回最小 Int64 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Nullable<Int64>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Int64 的最小值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Single>)已重载。 调用序列的每个元素上的转换函数并返回最小 Single 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Nullable<Single>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Single 的最小值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Double>)已重载。 调用序列的每个元素上的转换函数并返回最小 Double 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Nullable<Double>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Double 的最小值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Decimal>)已重载。 调用序列的每个元素上的转换函数并返回最小 Decimal 值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char>(Func<Char, Nullable<Decimal>>)已重载。 调用序列的每个元素上的转换函数并返回可空 Decimal 的最小值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Min<Char, TResult>(Func<Char, TResult>)已重载。 调用泛型序列的每个元素上的转换函数并返回最小结果值。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持OfType<TResult>根据指定类型筛选 IEnumerable 的元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持OrderBy<Char, TKey>(Func<Char, TKey>)已重载。 根据键按升序对序列的元素排序。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持OrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)已重载。 使用指定的比较器按升序对序列的元素排序。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持OrderByDescending<Char, TKey>(Func<Char, TKey>)已重载。 根据键按降序对序列的元素排序。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持OrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)已重载。 使用指定的比较器按降序对序列的元素排序。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Reverse<Char>反转序列中元素的顺序。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Select<Char, TResult>(Func<Char, TResult>)已重载。 将序列中的每个元素投影到新表中。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Select<Char, TResult>(Func<Char, Int32, TResult>)已重载。 通过合并元素的索引将序列的每个元素投影到新表中。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SelectMany<Char, TResult>(Func<Char, IEnumerable<TResult>>)已重载。 将序列的每个元素投影到 IEnumerable<T> 并将结果序列合并为一个序列。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)已重载。 将序列的每个元素投影到 IEnumerable<T>,并将结果序列合并为一个序列。 每个源元素的索引用于该元素的投影表。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SelectMany<Char, TCollection, TResult>(Func<Char, Int32, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)已重载。 将序列的每个元素投影到 IEnumerable<T>,并将结果序列合并为一个序列,并对其中每个元素调用结果选择器函数。 每个源元素的索引用于该元素的中间投影表。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SelectMany<Char, TCollection, TResult>(Func<Char, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)已重载。 将序列的每个元素投影到 IEnumerable<T>,并将结果序列合并为一个序列,并对其中每个元素调用结果选择器函数。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SequenceEqual<Char>(IEnumerable<Char>)已重载。 通过使用相应类型的默认相等比较器对序列的元素进行比较,以确定两个序列是否相等。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)已重载。 使用指定的 IEqualityComparer<T> 对两个序列的元素进行比较,以确定序列是否相等。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Single<Char>()已重载。 返回序列的唯一元素;如果该序列并非恰好包含一个元素,则会引发异常。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Single<Char>(Func<Char, Boolean>)已重载。 返回序列中满足指定条件的唯一元素;如果有多个这样的元素存在,则会引发异常。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SingleOrDefault<Char>()已重载。 返回序列中的唯一元素;如果该序列为空,则返回默认值;如果该序列包含多个元素,此方法将引发异常。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SingleOrDefault<Char>(Func<Char, Boolean>)已重载。 返回序列中满足指定条件的唯一元素;如果这类元素不存在,则返回默认值;如果有多个元素满足该条件,此方法将引发异常。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Skip<Char>跳过序列中指定数量的元素,然后返回剩余的元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SkipWhile<Char>(Func<Char, Boolean>)已重载。 只要满足指定的条件,就跳过序列中的元素,然后返回剩余元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持SkipWhile<Char>(Func<Char, Int32, Boolean>)已重载。 只要满足指定的条件,就跳过序列中的元素,然后返回剩余元素。 将在谓词函数的逻辑中使用元素的索引。 (由 Enumerable 定义。)
公共扩展方法Subscribe<Char>(IObserver<Char>)已重载。 (由 Observable 定义。)
公共扩展方法Subscribe<Char>(IObserver<Char>, IScheduler)已重载。 (由 Observable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Int32>)已重载。 计算 Int32 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Nullable<Int32>>)已重载。 计算可以为 null 的 Int32 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Int64>)已重载。 计算 Int64 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Nullable<Int64>>)已重载。 计算可以为 null 的 Int64 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Single>)已重载。 计算 Single 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Nullable<Single>>)已重载。 计算可以为 null 的 Single 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Double>)已重载。 计算 Double 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Nullable<Double>>)已重载。 计算可以为 null 的 Double 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Decimal>)已重载。 计算 Decimal 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Sum<Char>(Func<Char, Nullable<Decimal>>)已重载。 计算可以为 null 的 Decimal 值序列的和,这些值是通过对输入序列中的每个元素调用转换函数得来的。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Take<Char>从序列的开头返回指定数量的连续元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持TakeWhile<Char>(Func<Char, Boolean>)已重载。 只要满足指定的条件,就会返回序列的元素。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持TakeWhile<Char>(Func<Char, Int32, Boolean>)已重载。 只要满足指定的条件,就会返回序列的元素。 将在谓词函数的逻辑中使用元素的索引。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToArray<Char>IEnumerable<T> 创建一个数组。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToDictionary<Char, TKey>(Func<Char, TKey>)已重载。 根据指定的键选择器函数,从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)已重载。 根据指定的键选择器函数和键比较器,从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)已重载。 根据指定的键选择器和元素选择器函数,从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)已重载。 根据指定的键选择器函数、比较器和元素选择器函数从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToList<Char>IEnumerable<T> 创建一个 List<T> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToLookup<Char, TKey>(Func<Char, TKey>)已重载。 根据指定的键选择器函数,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)已重载。 根据指定的键选择器函数和键比较器,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)已重载。 根据指定的键选择器和元素选择器函数,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持ToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)已重载。 根据指定的键选择器函数、比较器和元素选择器函数,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 Enumerable 定义。)
公共扩展方法ToObservable<Char>()已重载。 (由 Observable 定义。)
公共扩展方法ToObservable<Char>(IScheduler)已重载。 (由 Observable 定义。)
公共扩展方法由 XNA Framework 提供支持Union<Char>(IEnumerable<Char>)已重载。 通过使用默认的相等比较器生成两个序列的并集。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Union<Char>(IEnumerable<Char>, IEqualityComparer<Char>)已重载。 通过使用指定的 IEqualityComparer<T> 生成两个序列的并集。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Where<Char>(Func<Char, Boolean>)已重载。 基于谓词筛选值序列。 (由 Enumerable 定义。)
公共扩展方法由 XNA Framework 提供支持Where<Char>(Func<Char, Int32, Boolean>)已重载。 基于谓词筛选值序列。 将在谓词函数的逻辑中使用每个元素的索引。 (由 Enumerable 定义。)
公共扩展方法Zip<Char, TSecond, TResult>将指定函数应用于两个序列的对应元素,以生成结果序列。 (由 Enumerable 定义。)
页首

  名称说明
公共字段静态成员由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Empty表示空字符串。 此字段为只读。
页首

  名称说明
显式接口实现私有方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IComparable.CompareTo将当前实例与同一类型的另一个对象进行比较,并返回一个整数,该整数指示当前实例在排序顺序中的位置是位于另一个对象之前、之后还是与其位置相同。
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToBoolean基础结构。有关此成员的说明,请参见 ToBoolean
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToByte基础结构。有关此成员的说明,请参见 ToByte
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToChar基础结构。有关此成员的说明,请参见 ToChar
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToDateTime基础结构。有关此成员的说明,请参见 ToDateTime
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToDecimal基础结构。有关此成员的说明,请参见 ToDecimal
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToDouble基础结构。有关此成员的说明,请参见 ToDouble
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToInt16基础结构。有关此成员的说明,请参见 ToInt16
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToInt32基础结构。有关此成员的说明,请参见 ToInt32
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToInt64基础结构。有关此成员的说明,请参见 ToInt64
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToSByte基础结构。有关此成员的说明,请参见 ToSByte
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToSingle基础结构。有关此成员的说明,请参见 ToSingle
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToType基础结构。有关此成员的说明,请参见 ToType
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToUInt16基础结构。有关此成员的说明,请参见 ToUInt16
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToUInt32基础结构。有关此成员的说明,请参见 ToUInt32
显式接口实现私有方法由 XNA Framework 提供支持IConvertible.ToUInt64基础结构。有关此成员的说明,请参见 ToUInt64
显式接口实现私有方法由 XNA Framework 提供支持IEnumerable<Char>.GetEnumerator返回循环访问当前 String 对象的枚举数。
显式接口实现私有方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持IEnumerable.GetEnumerator返回循环访问当前 String 对象的枚举数。
页首

字符串是 Unicode 字符的有序集合,用于表示文本。 String 对象是 System.Char 对象的有序集合,用于表示字符串。 String 对象的值是该有序集合的内容,并且该值是不可变的(即,为只读)。 有关字符串的不变性的更多信息,请参阅本主题后面的 不变性和 StringBuilder 类 部分。 String 对象在内存中的最大大小的 2 GB 或大约 10 亿个字符。

本节内容:

实例化 String 对象
Char 对象和 Unicode 字符
字符串和嵌入的 Null 字符
字符串和索引
Null 字符串和空字符串
不变性和 StringBuilder 类
序号与区分区域性的操作
正常化
按类别划分的字符串操作

实例化 String 对象

可以通过以下方式实例化 String 对象:

  • 通过把字符串文字分配到 String 变量。 这是用于创建一个字符串最常用的方法。 下面的示例利用赋值创建多个字符串。 请注意,在 C# 中,由于反斜杠 (\) 是个转义字符,所以必须转义字符串中的反斜杠,或者必须给整个字符串加上 @ 前缀。

    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    
    
  • 通过调用 String 类构造函数。 下面的示例通过调用几个类构造函数实例化字符串。 请注意,一些构造函数的参数包括指向字符数组或带符号的字节数组的指针。 Visual Basic 不支持对这些构造函数的调用。 有关 String 构造函数的详细信息,请参阅 String 构造函数的摘要。

    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    
    
  • 通过使用字符串串联运算符(+ 在 C# 中,& 或 + 在 Visual Basic 中)以根据 String 实例和字符串文本的任意组合来创建单个字符串。 下面的示例演示了字符串串联运算符的用法。

    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    
    
  • 通过检索属性或调用返回字符串的方法。 下面的示例使用 String 类的方法以提取来自较大字符串的子字符串。

    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    
    
  • 通过调用格式方法把值或对象转换为字符串表示形式。 下面的示例使用 复合格式 功能将两个对象的字符串表示形式嵌入到字符串。

    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    
    

Char 对象和 Unicode 字符

字符串中的每个字符都是由 Unicode 标量值定义的,Unicode 标量值也称为 Unicode 码位或者 Unicode 字符的序号(数字)值。 每个码位都是使用 UTF-16 编码进行编码的,编码的每个元素的数值都用一个 Char 对象表示。

一个 Char 对象通常表示一个码位,即:Char 的数值等于该码位。 例如,字符“a”的码位为 U+0061。 但是,一个码位可能需要多个编码元素(多个 Char 对象)。 Unicode 标准定义了三种类型的字符,对应多个 Char 对象:字母 、Unicode 补充代码点和辅助平面中的字符。

  • 字素由后跟一个或多个组合字符的基本字符表示。 例如,字符 ä 由码位为 U+0061 的 Char 对象表示,该对象后接码位为 U+0308 的 Char 对象。 具有 U + 00E4 代码点的单个 Char 对象也可以定义此字符。 如下示例所示,平等的区分区域性的比较表明虽然普通的序号比较不是平等的,但这两种表示形式是。 但是,如果这两个字符串均正常化,则序号比较还表示它们相等。(有关标准化字符串的更多信息,请参阅 标准化 部分。)

    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
    
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
    
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    
    
  • Unicode 补充码位(一个代理项对)由 Char 对象表示,该对象的码位为高代理项,其后跟着码位是低代理项的 Char 对象。 高代理项的编码单元的范围是从 U + D800 到 U + DBFF。 低代理项的编码单元的范围是从 U + DC00 到 U + DFFF。 代理项对用于表示 16 Unicode 辅助平面中的字符。 下面的示例创建代理项字符,并将它传递到 Char.IsSurrogatePair(Char, Char) 方法以确定其是否为代理项对。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          string surrogate = "\uD800\uDC03";
          for (int ctr = 0; ctr < surrogate.Length; ctr++) 
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
          Console.WriteLine();
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate[0], surrogate[1]));
       }
    }
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    
    

字符串和嵌入的 Null 字符

在 .NET Framework 中,String 对象可以包含嵌入的 null 字符,这些值将算作字符串长度的一部分。 但是,在某些语言(例如 C 和 C++)中,null 字符指示字符串的结尾;不会将其视为字符串的一部分,并且将不算作字符串长度的一部分。 这意味着当应用于 String 对象时,C 和 C++ 程序员或使用 C 或 C++ 编写的库对字符串作出的下列常规假设不一定有效:

  • strlen wcslen 函数返回的值不一定等于 String.Length

  • strcpy_swcscpy_s 函数创建的字符串不一定与通过 String.Copy 方法创建的字符串相同。

应确保对 String 对象进行实例化的本机 C 和 C++ 代码以及通过平台调用传递 String 对象的代码不假设使用嵌入的 null 字符标记字符串的结尾。

在排序(或比较)字符串时以及搜索字符串时,也将以不同的方式处理嵌入的 null 字符。 在两个字符串之间执行区分区域性的比较时忽略 Null 字符,包括使用固定区域性的比较。 仅在进行序号或不区分大小写的序号比较时考虑它们。 另一方面,在使用 ContainsStartsWithIndexOf 等方法搜索字符串时,始终考虑嵌入的 NULL 字符串。

字符串和索引

索引是 Char 对象在 String 中的位置(而不是 Unicode 字符的位置)。 索引是从零开始、从字符串的起始位置(其索引为零)计起的非负数字。 一些搜索方法,例如 IndexOfLastIndexOf 返回字符串实例中的字符或子字符串的索引。

Chars 属性可让您按其在字符串中的索引位置访问各个 Char 对象。 因为 Chars 属性为(在 Visual Basic 中的)默认属性或索引器(在 C# 中),所以可使用如下代码在字符串中访问单个 Char 对象。 此代码查找字符串中的空白或标点字符,以确定该字符串包含多少字。


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      for (int ctr = 0; ctr < s1.Length; ctr++) {
         if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


如下示例所示,因为 String 类实现 IEnumerable 接口,所以还可以使用 foreach 构造在字符串中通过 Char 对象进行循环访问。


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      foreach (var ch in s1) {
         if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


连续的索引值可能并不与连续的 Unicode 字符相对应,这是因为一个 Unicode 字符可能会编码为多个 Char 对象。 特别是,字符串可能包含由一个或多个组合字符的基字符组成的多字符单元或由代理项组成。 为了使用 Unicode 字符而不是 Char 对象,可使用 System.Globalization.StringInfoTextElementEnumerator 类。 下面的示例演示了使用 Char 对象和使用 Unicode 字符的代码之间的区别。 它比较句子的每个单词中字符或文本元素的数目。 该字符串包括两个基字符序列,后接组合字符。


using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // First sentence of The Mystery of the Yellow Room, by Leroux.
      string opening = "Ce n'est pas sans une certaine émotion que "+
                       "je commence à raconter ici les aventures " +
                       "extraordinaires de Joseph Rouletabille."; 
      // Character counters.
      int nChars = 0;
      // Objects to store word count.
      List<int> chars = new List<int>();
      List<int> elements = new List<int>();

      foreach (var ch in opening) {
         // Skip the ' character.
         if (ch == '\u0027') continue;

         if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
            chars.Add(nChars);
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      TextElementEnumerator te = StringInfo.GetTextElementEnumerator(opening);
      while (te.MoveNext()) {
         string s = te.GetTextElement();   
         // Skip the ' character.
         if (s == "\u0027") continue;
         if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
            elements.Add(nChars);         
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      // Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters"); 
      for (int ctr = 0; ctr < chars.Count; ctr++) 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars[ctr], elements[ctr]); 
   }
}
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12


此示例使用StringInfo.GetTextElementEnumerator 方法和 TextElementEnumerator 类列举字符串中的所有文本项。 您也可以通过调用 StringInfo.ParseCombiningCharacters 方法检索包含每个文本项的开始索引的数组。

有关使用文本单元而非各个 Char 值的详细信息,请参阅 StringInfo 类。

Null 字符串和空字符串

已声明但尚未分配值的字符串为 null 尝试对该字符串调用方法引出 NullReferenceException 空字符串是不同于空的字符串,是其值为“”或 String.Empty 的字符串。 在某些情况下,将 null 字符串或空字符串作为参数传递给方法将引发异常。 例如,把 Null 字符串传递到 Int32.Parse 方法将引出 ArgumentNullException,传递空字符串将引出 FormatException 在其他情况下,方法参数可以为 null 字符串或空字符串。 例如,要提供类的 IFormattable 实现,则需要用常规(“G”)格式指示符使 Null 字符串等同于空字符串。

String 类包括以下两种方便的方法,使您能够测试字符串是否为 null 或为空:

  • IsNullOrEmpty ,指示字符串是否为 null 或等于 String.Empty 该方法消除了使用如下代码的需要:

    
    if (str == null || str.Equals(String.Empty))
    
    
    
  • IsNullOrWhiteSpace ,指示字符串是否为 null,等于 String.Empty,或仅由空白字符组成。 该方法消除了使用如下代码的需要:

    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    
    

下面的示例使用自定义 Temperature 类的 IFormattable.ToString 实现中的 IsNullOrEmpty 方法。 该方法支持"G"、"C"、"F"和"K" 格式字符串。 如将空格式字符串或值为 null 的格式字符串传递到该方法,则其值更改为“G”格式字符串。


public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;

   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}


不变性和 StringBuilder 类

String 对象称为不可变的(只读),因为在创建了该对象之后,就不能修改该对象的值。 看来似乎修改了 String 对象的方法实际上是返回一个包含修改内容的新 String 对象。

因为字符串是不可变的,所以对单个字符串执行重复的添加或删除操作的字符串操作例程会是一种重大性能损失。 例如,以下代码使用随机数字生成器来创建含有在 0x0001 到 0x052F 范围之间的 1000 个字符的字符串。 尽管该代码会出现以使用字符串串联来将新的字符追加到命名为 str 的现有字符串,它实际上会为每个串联操作创建新的 String 对象。


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();

      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}


可使用 StringBuilder 类代替 String 类多次更改字符串值。 不同于 String 类的实例,StringBuilder 对象是可变的;当您串联、 追加或删除字符串中的子字符串,则会对单个字符串执行操作。 完成 StringBuilder 对象的值的修改后,可以调用其 StringBuilder.ToString 方法将其转换为字符串。 下面的示例将替换用在前面示例中的 String 以连接从 0x0001 到 0x052F 范围内并带 StringBuilder 对象的 1000 个随机字符。


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}


序号与区分区域性的操作

String 类的成员对 String 对象执行序号操作或区分区域性(语言)操作。 序号运算是对每个 Char 对象的数值执行的。 区分区域性操作则对考虑了特定于区域性的大小写、排序、格式化和语法分析规则的 String 的值执行。 区分区域性运算在显式声明的区域性或者隐式当前区域性的上下文中执行。 两种操作可以产生非常不同的结果(在相同的字符串上执行它们时)。

安全说明安全说明

如果应用程序进行有关符号标识符(如文件名或命名管道)或持久数据(如 XML 文件中基于文本的数据)的安全决策,则该操作应该使用序号比较而不是区分区域性的比较。 这是因为根据起作用的区域性的不同,区分区域性的比较可产生不同的结果,而序号比较则仅依赖于所比较字符的二进制值。

重要说明重要事项

执行字符串操作的大多数方法都包括带有 StringComparison 类型的参数的重载,这使您可以指定该方法执行序号或区分区域性的操作。 一般情况下,您应该调用此重载让您的方法的意图明确方法调用的目的。 在字符串上使用序号和区分区域性的操作的最佳做法和指南,请参见 在 .NET Framework 中使用字符串的最佳做法

负载分析和格式化比较和排序测试相等性 的操作可能是序号或区分区域性的。 以下各节讨论了操作的每个类别。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif大小写

大小写规则确定如何更改 Unicode 字符的大小写;例如,从小写变为大写。 通常,大小写操作在字符串比较之前执行。 例如,一个字符串可能会转换为大写,以便它可以与其他大写字符串作比较。 可通过调用 ToLowerToLowerInvariant 方法将字符串中的字符转换为小写,还可以通过调用 ToUpperToUpperInvariant 方法将其转换为大写。 此外,您可以使用 TextInfo.ToTitleCase 方法将字符串转换为词首大写的形式。

大小写操作可以基于当前区域性、指定区域性或固定区域性的规则。 由于大小写映射根据使用的区域性而异,负载操作的结果也会因区域性而异。 负载的实际差异是以下三种:

  • 在大小写映射的差异 拉丁文大写字母 I (U+0049),拉丁文小写字母" (U+0069),拉丁文大写字母头上带点的 I (U+0130) 和拉丁文小写字母不带点的 I (U+0131)。 在 tr TR (土耳其语 (土耳其) )和 az-Latn-AZ (阿塞拜疆,拉丁语) 区域性,和 tr、az 和 az-Latn 非特定区域性中,拉丁文大写字母 I 的等效小写是拉丁文小写字母不带点的 I ,拉丁文小写字母 I 的等效大写是拉丁文大写字母头上不带点的 I 。 在其他区域性,包括固定区域性,拉丁文小写字母 I 和拉丁文大写字母 I 等效于小写和大写。

    下面的示例演示了如果字符串比较依赖于区分区域性的大小写比较,则阻止访问文件系统的字符串比较将失败。(应使用固定区域性的大小写约定。)

    
    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
    
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    
    
  • 在固定区域性和其他区域性之间的大小写映射的差异。 在这些情况下,使用固定区域性的大小写规则更改字符为大写或小写时返回相同的字符。 对于其他区域性,它返回一个不同的字符。 某些受影响的字符在下表中列出。

    字符

    如果更改

    返回

    微米符号 (U+00B5)

    大写

    希腊语大写字母 MU (U+-39C)

    拉丁文大写字母顶部带点的 I (U+0130)

    小写

    拉丁文小写字母 I (U+0069)

    拉丁文小写字母不带点的 I (U+0131)

    大写

    拉丁文大写字母 I (U+0049)

    拉丁文小写字母长 S (U+017F)

    大写

    拉丁文大写字母 S (U+0053)

    带有抑扬符 (U+01C5)的拉丁文大写字母 D 和拉丁文小写字母 Z

    小写

    带有抑扬符 (U+01C6) 的拉丁文小写字母 DZ

    结合希腊语 YPOGEGRAMMENI (U+0345)

    大写

    希腊语大写字母 IOTA (U+-39C)

  • 在 ASCII 字符范围内,两个字母的混合大小写的映射的差异。 在大多数区域性中,两个字母的大小写混合对等效于两个字母大写对或小写对。 在下面的区域性中,这不适用于以下两个字母的字母对,因为在每种情况下它们都与二合字母比较:

    • 在 hr-HR (克罗地亚语 (克罗地亚) 区域性中的“lJ”和“nJ”。

    • 在cs-CZ (捷克语 (捷克)) 和 sk-SK (斯洛文尼亚语 (斯洛文尼亚语) 区域性中的“cH” 。

    • 在da-DK (丹麦语 (丹麦)) 区域性中的“aA”。

    • 在hu-HU(匈牙利语 (匈牙利) 区域性中的“cS”,“dZ”,“dZS”,“nY”,“sZ”,“tY”和“zS”。

    • 在es-ES_tradnl (西班牙语 (西班牙,传统排序) 区域性中的“cH”和“lL”。

    • 在 vi VN (越南语 (越南)) 区域性中的“cH”,“US 标记”,“kH”,“nG”nH”,“酸碱度”,“qU“、" Th”和“tR”。

    但是,遇到一个产生问题的区分区域性的比较情况是不寻常的,因为这些对于固定的字符串或标识符来说是少见的。

将字符串转换为大写时,下面的示例演示了不同的区域性之间不同的大小写规则。


using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));

         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 


s1wwdcbf.collapse_all(zh-cn,VS.110).gif分析和格式化

格式化和分析为反向操作。 格式化规则决定如何将值,例如日期和时间或者数字,转换为它的字符串表示形式,而语法分析规则则确定如何将字符串表示形式转换为值。 格式化和分析规则都取决于区域性约定。 解释区域性特定的数据字符串时,下面的示例演示可能引发的多义性。 若未知用于生成日期字符串的区域性约定,则不可能知道 03/01/2011、3/1/2011 及 01/03/2011 是表示 2011 年 1 月 3 日还是表示 2011 年 3 月 1 日。


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011


同样,如以下示例所示,单个字符串可以产生不同的日期,这取决于在分析操作中使用的区域性的约定。


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10


s1wwdcbf.collapse_all(zh-cn,VS.110).gif字符串比较和排序

比较和排序的字符串约定随区域性。 例如,排序顺序可以语音学或基于字符的可视表示形式。 在东亚语言中,按文字的笔画和部首对字符进行排序。 排序也取决于排序语言和区域性使用的字母表。 例如,丹麦语中有“Æ”字符,它在字母表中排在“Z”之后。 此外,比较可以是区分大小写和不区分大小写的,因此,在某些情况下格式的规则。区域性也不同。 当比较和排序字符串时,序号比较,另一方面,在字符串使用单个的 Unicode 字符代码。

排序规则确定 Unicode 字符的字母顺序,以及两个字符串如何互相比较。 例如 String.Compare(String, String, StringComparison) 根据 StringComparison 参数比较两个字符串。 如果参数值为 StringComparison.CurrentCulture,则方法执行使用当前区域性的约定的语义比较;如果参数值为 StringComparison.Ordinal,则方法执行序号比较。 因此,如下面的示例所示,如果当前区域性为美国英语,第一次调用 String.Compare(String, String, StringComparison) 方法 (使用区分区域性的比较) 视为“a”小于“A”,但是,第二次调用同一方法 (使用序号比较) 视为“a”大于“A”。


using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32


.NET Framework 支持单词、字符串和序号排序规则。

  • 单词排序会执行区分区域性的字符串比较,在这种比较中,某些非字母数字 Unicode 字符可能会具有特殊的权重。 例如,连字符(“-”)的权重非常小,因此“coop”和“co-op”在排序列表中是紧挨着出现的。 有关使用单词排序规则比较两个字符串的 String 方法列表,请参阅按类别的字符串操作 部分。

  • 字符串排序同时执行区分区域性的比较。 它与单词排序相似,唯一区别是字符串排序中不存在特殊情况,所有非字母数字符号均排在所有字母数字 Unicode 字符之前。 可通过调用 CompareInfo.Compare 方法过载(其具有 options 参数,该参数为 CompareOptions.StringSort 的提供值)来使用字符串排序规则比较两个字符串。 请注意,这是 .NET Framework 提供的唯一一个使用字符串排序规则比较两个字符串的方法。

  • 序号排序基于字符串中每个 Char 对象的数值对字符串进行比较。 序号比较自动区分大小写,因为字符的小写和大写版本有着不同的码位。 但是,如果大小写并不重要,则可以指定忽略大小写的序号比较。 这相当于使用固定区域性将字符串转换为大写,然后对结果执行序号比较。 有关使用单词排序规则比较两个字符串的 String 方法列表,请参阅按类别的字符串操作 部分。

区分区域性的比较是显式或隐式使用 CultureInfo 对象的任何比较,包括由 CultureInfo.InvariantCulture 属性指定的固定区域性。 隐式区域性为当前区域性,它是由 Thread.CurrentCultureCultureInfo.CurrentCulture 属性指定。 跨区域性的字符的排序顺序的重大更改(即,Char.IsLetter 属性返回 true) 。 可以通过给字符串比较方法提供一个 CultureInfo 对象,例如 Compare(String, String, CultureInfo, CompareOptions),来指定使用特定区域性约定的一个区分区域性的比较。 可以通过提供 StringComparison.CurrentCultureStringComparison.CurrentCultureIgnoreCase,或者 CompareOptions 枚举的任意成员(除了 CompareOptions.Ordinal )或者 CompareOptions.OrdinalIgnoreCase ,指定使用当前区域性约定的区分区域性的比较,选择Compare恰当的重载方法。 区分区域性的比较通常适用于排序,而序号比较则不适合。 序号比较通常适用于确定两个字符串是否相等(即,确定标识),而区分区域性的比较则不适用。

下面的示例演示区域性敏感和序号比较之间的差异。 使用每一个位是默认区域性的 Compare 方法) 时调用的是 da-DK 和 en-US 区域性 (以及,序号比较的约定,示例计算三个字符串,“,“Æble Apple””和“”AEble。 由于丹麦语将字符“Æ”作为单个字母并在的“Z”之后对它在字母表中,字符串“Æble”比“Apple”大于。 但是,“Æble”视为等效于“AEble”,因此,“Æble”比“AEble”还大。en-US 区域性没有字母 Æ,但将它视为等效的“AE”,将“原因 Æble”比“Apple”匹配,但与 AEble 为“小于”。 序号比较,另一方面,比“Æble”,“Æble”ttto 视为“Apple”小于“AEble”大于。


using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";

      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133


使用以下通用原则选择适当的排序或字符串比较方法:

  • 如果希望字符串基于用户区域性排序,则应根据当前区域性的约定进行排序。 如果用户的区域性更改,排序的字符串顺序将相应地发生更改。 例如,同义词库应用程序应始终基于用户区域性进行文字排序。

  • 如果希望字符串基于特定区域性排序,则通过提供表示该区域性比较方法的 CultureInfo 对象对其进行排序。 例如,在指导学生特定语言的应用程序中,您希望字符串按照该语言的某个区域性约定进行排序。

  • 如果希望字符串排序在跨区域时未更改,则根据固定区域性约定或使用序号比较进行排序。 例如,您将使用序号排序组织文件的名称,处理,互斥或命名管道。

  • 对于涉及安全决策的比较 (如用户名是否有效),应通过调用 Equals 方法的重载,执行相等性的顺序测试。

说明说明

区分区域性的排序和用于字符串比较的大小写规则取决于 .NET Framework 的版本。 在运行于 Windows 8 操作系统的 .NET Framework 4.5中,排序,负载,规范化和 Unicode 字符信息符合 Unicode 6.0 标准。 在其他操作系统上,它遵循 Unicode 5.0 标准。

有关单词、字符串和序号排序规则的更多信息,请参见 System.Globalization.CompareOptions 主题。 有关何时使用每个规则的建议,请参阅 在 .NET Framework 中使用字符串的最佳做法

通常,您不要直接调用字符串比较方法(比如 Compare)来确定字符串的排序顺序。 相反,比较方法都是通过排序方法调用的,比如 Array.SortList<T>.Sort 下面的示例执行四个不同顺序操作 (使用当前区域性的字符串排序,使用固定区域性的文字,序号排序顺序和字符串类使用固定区域性),而无需显式调用字符串比较方法,即,但指定排序是使用比较的类型。 请注意,每种排序类型都会在其数组内产生唯一的字符串顺序。


using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative


提示提示

在内部,.NET Framework 使用类键支持区分区域性的字符串比较。 给予字符串中的每个字符若干类排序权重,包括字母、大小写和变音符。 排序关键字,表示由 SortKey 类,提供特定字符串的这些权重的储存库。 如果应用程序对同一组点的大量搜索的顺序的或操作字符串,可通过生成和存储它使用的所有字符串的排序关键字改善其性能。 需要执行排序或比较操作时,请使用类而不是键字符串。 有关更多信息,请参见 SortKey 类。

如果您不指定字符串比较排序约定,例如方法 Array.Sort(Array) 在字符串的一个区域性敏感,区分大小写的排序。 下面的示例演示当前区域性更改如何影响排序的字符串排序数组中。 它创建一个由三个字符串。 首先,将 System.Threading.Thread.CurrentThread.CurrentCulture 属性设置为 en-US,并调用 Array.Sort(Array) 方法。 结果排序顺序基于英语(美国)区域性的排序约定。 接着,该示例设置 System.Threading.Thread.CurrentThread.CurrentCulture 属性设置为 da-DK并再次调用 Array.Sort 方法。 请注意,结果排序顺序与使用 en-US 时的结果是不一样的,因为使用的是Danish(Denmark)的排序约定。


using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble


警告说明警告

如果您比较字符串的主要目的是确定它们是否相等,则应调用 String.Equals 方法。 通常,您应该使用 Equals 执行初始比较。 String.Compare 方法主要用于排序字符串。

字符串搜索方法,比如 String.StartsWithString.IndexOf,也可以执行区分区域性的或序号字符串比较。 下面的示例使用 IndexOf 方法演示了序号和区分区域性比较之间的差异。 区分区域性的搜索,其中当前文化为英语(美国),认为子字符串“oe”要匹配连字“œ”。 由于软连字符 (U+00AD)是一个零宽度字符,搜索将该软连字符视为与 Empty 等同且在字符串开头找到匹配。 另一方面,序号的搜索没有在两种情况中找到匹配。


using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();

      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2


s1wwdcbf.collapse_all(zh-cn,VS.110).gif搜索字符串

字符串搜索方法,如 String.StartsWithString.IndexOf,还确定执行区分区域性的字符串比较或序号字符或子字符是否在指定字符串中。

搜索方法允许为一个字符或一组搜索字符串的字符,或者搜索字符串的子字符搜索。 为单个字符搜索 (例如,IndexOf 方法),一个或一组字符,如 IndexOfAny,方法都执行序号搜索在 String 中搜索方法的类。 若要执行的字符区分区域性的搜索,您必须调用一个 CompareInfo 方法 (如 CompareInfo.IndexOf(String, Char)CompareInfo.LastIndexOf(String, Char) 注释结果搜索使用序号比较与区分区域性的比较的字符可以是截然不同。 例如,一 precomposed Unicode 的字符 (如搜索连字“Æ”(U+00 C6) 可能根据区域性匹配其以正确的顺序的任何组件出现,如“AE”(),U+041U+0045。 当搜索单个字符后,以下示例阐释 String.IndexOf(Char)CompareInfo.IndexOf(String, Char) 方法之间的一些差异。 连字“æ”() U+00E6 在字符串“天线”找到,则使用 en-US 区域性的约定,但没有时,使用 da-DK 区域性,或者执行序号时比较的约定。


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6

      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));

      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0


另一方面,String 搜索字符串而不是字符的类的方法执行区分区域性的搜索,则搜索选项不受类型显式指定 StringComparison参数。 唯一的例外是 Contains,则执行序号搜索。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif相等性测试

使用 String.Compare 方法来确定按排序顺序时两个字符串的关系。 通常,这是区分区域性的操作。 相比之下,调用 String.Equals 方法测试相等性。 因为平等测试通常比较用户输入和一些已知字符串,例如,有效用户名、 密码或文件系统路径,它通常是序号操作。

警告说明警告

通过调用 String.Compare 方法来进行平等性测试并确定返回值是否为零是可能的。 但是,不推荐这种做法。 要确定两个字符串是否相等,应该调用 String.Equals 方法的其中一个过载。 要调用的优选过载为实例 Equals(String, StringComparison) 方法或静态 Equals(String, String, StringComparison) 方法,因为两种方法都包含明确指定比较类型的 System.StringComparison 参数。

当改用一个序号时,下面的示例演示了执行相等区分区域性的比较的危险。 在这种情况下,代码的目的是通过使用字符串“FILE://”对 URL 的开头进行不区分大小写的比较来禁止由“FILE://”或“file://”开始的 URL 访问文件系统。 然而,如果使用“file://”开头的 URL 上的土耳其 (土耳其) 区域性执行区分区域性的比较,则该相等比较失败,这是因为等同于土耳其小写“i”的大写是“İ”,而不是“I”。 其结果是,无意中允许文件系统访问。 另一方面,如果执行序号比较,那么相等性比较会成功,文件系统访问会被拒绝。


using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";

      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);

      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.


正常化

某些 Unicode 字符具有多个表示形式。 例如,以下任意码位可以表示字母“ắ”:

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

如果一个字符存在多种表示形式,会使搜索、排序、匹配和其他字符串操作变得复杂。

Unicode 标准定义了一个称作正常化的过程。对于字符的任何二进制等效表示形式,该过程都可以返回一个 Unicode 字符的二进制表示形式。 正常化可以使用几种算法,这些算法称作正常化形式,它们遵守不同的规则。 目前,.NET Framework 支持 Unicode 正常化形式 C、D、KC 和 KD。 如果字符串被正常化为同一范式,则可以使用序号比较对它们进行比较。

序号比较是每个字符串中相应的 Char 对象的 Unicode 标量值的二进制比较。 String 类包括可执行序号比较的许多方法,如下:

可通过调用 String.IsNormalized() 方法确定是否将字符串正常化为范式 C,也可以调用 String.IsNormalized(NormalizationForm) 方法来确定是否将字符串正常化为指定范式。 还可以调用 String.Normalize() 方法将字符串转换为范式 C,或调用 String.Normalize(NormalizationForm) 方法将字符串转换为指定的范式。 有关规范化和比较字符串的详细步骤信息,请参阅Normalize()Normalize(NormalizationForm) 方法。

下面的简单示例阐释了字符串标准化。 它在三个不同的字符串中用三种不同的方式定义了字母“ố”,并使用相等性序号比较来确定每个字符串与其他两个字符串是不同的。 然后它将每个字符串转换为支持的范式,并再次执行指定范式中的每个字符串的序号比较。 在每种情况下,第二次相等测试表明字符串是相等的。


using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;

   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }

      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 

   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True


有关规范化和范式的详细信息,请参阅System.Text.NormalizationForm,以及 Unicode Standard Annex #15:Unicode 范式规范化常见问题 unicode.org 网站。

按类别划分的字符串操作

String 类提供成员用于比较字符串,测试字符串是否相等,查找字符串中的字符或子字符串,修改字符串,提取字符串的子字符串,组合字符串,格式化值,复制字符串和使字符串规范化。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif比较字符串

通过使用以下 String 方法比较字符串,以确定其在排序顺序中的相对位置:

  • Compare 返回一个指示排序顺序中某个字符串与另一个字符串之间的关系的整数。

  • CompareOrdinal 返回一个指示某个字符串与另一个字符串之间的关系(基于它们的码位的比较)的整数。

  • CompareTo 返回一个指示排序顺序中当前字符串实例与第二个字符串之间的关系的整数。 CompareTo(String) 方法向 String 类提供 IComparableIComparable<T> 实现。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif字符串相等性测试

请调用 Equals 方法以确定两个字符串是否相等。 实例 Equals(String, String, StringComparison) 和静态 Equals(String, StringComparison) 重载允许您指定比较是区分区域性还是序号;事例是考虑还是忽略。 大多数相等性测试都是序号的,并且确定系统资源(例如文件系统对象)的访问权限的相等性比较应始终为序号的。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif查找字符串中的字符

String 类包含两种搜索方法:

警告说明警告

如果要按特定模式搜索字符串而不是一个特定子字符串,则应使用正则表达式。 有关详细信息,请参阅.NET Framework 正则表达式

s1wwdcbf.collapse_all(zh-cn,VS.110).gif修改字符串

String 类包括以下方法,可用于修改字符串的值:

  • Insert 将一个字符串插入到当前的 String 实例中。

  • PadLeft 将指定字符的一个或多个匹配项插入到字符串的开始位置。

  • PadRight 将指定字符的一个或多个匹配项插入到字符串的开始位置。

  • Remove 从当前的 String 实例中删除一个子字符串。

  • Replace 在当前的 String 实例中将一个子字符串替换成另一个子字符串。

  • ToLower ToLowerInvariant 将字符串中的所有字符转换为小写。

  • ToUpper ToUpperInvariant 将字符串中的所有字符转换为大写。

  • Trim 从字符串的开始位置和末尾移除所有空白字符。

  • TrimEnd 从字符串的末尾移除所有空白字符。

  • TrimStart 从字符串的开始位置移除所有空白字符。

重要说明重要事项

所有字符串修改方法都返回新的 String 对象。 它们不修改当前实例的值。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif从字符串中提取子字符串

String.Split 方法将单独字符串分隔成多个字符串。 该方法的重载可以让您指定多个分隔符,以确定该方法提取的子字符串的最大数量,并确定空字符串(当分隔符相邻时发生)是否包括在返回的字符串中。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif组合字符串

以下 String 方法可以用于字符串串联:

  • Concat 将一个或多个子字符串合并为一个字符串。

  • Join 将一个或多个子字符串连接成一个元素,并在每个字符串之间添加分隔符。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif格式化值

String.Format 方法使用复合格式化功能用某些对象或值的字符串表示来替代字符串中一个或多个占位符。 Format 通常用于执行以下操作:

  • 在字符串中嵌入数字值的字符串表示形式。

  • 在字符串中嵌入日期和时间值的字符串表示形式。

  • 将枚举值的字符串表示形式嵌入字符串中。

  • 要在字符串中嵌入支持 IFormattable 接口的某些对象的字符串表示形式。

  • 在较大字符串中向右或向左对齐字段中的子字符串。

有关格式操作和示例的详细信息,请参阅Format 重载摘要。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif复制字符串

可以通过调用以下 String 方法对字符串进行复制:

  • Clone 返回现有 String 对象的引用。

  • Copy 创建现有字符串的副本。

  • CopyTo 将字符串的一部分复制到一个字符数组中。

s1wwdcbf.collapse_all(zh-cn,VS.110).gif规范化字符串

在 Unicode 中,单个字符可以有多个码位。 规范化将这些等效字符转换为相同的二进制表示形式。 String.Normalize 方法执行规范化并且 String.IsNormalized 方法确定一个字符串是否规范化。

.NET Framework

受以下版本支持:4.5.2、4.5.1、4.5、4、3.5、3.0、2.0、1.1、1.0

.NET Framework Client Profile

受以下版本支持:4、3.5 SP1

可移植类库

受以下版本支持:可移植类库

适用于 Windows 应用商店应用的 .NET

受以下版本支持:Windows 8

适用于 Windows Phone 应用的 .NET

受以下版本支持:Windows Phone 8、Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008(不支持服务器核心角色), Windows Server 2008 R2(支持带 SP1 或更高版本的服务器核心角色;不支持 Itanium)

.NET Framework 并不是对每个平台的所有版本都提供支持。有关支持的版本的列表,请参阅.NET Framework 系统要求

此类型是线程安全的。

本文是否对您有所帮助?
(1500 个剩余字符)
感谢您的反馈

社区附加资源

显示:
© 2014 Microsoft