本文由机器翻译。若要查看英语原文,请勾选“英语”复选框。 也可将鼠标指针移到文本上,在弹出窗口中显示英语原文。
翻译
英语

String 类

 

将文本表示为 UTF-16 代码单元的序列。

若要浏览此类型的.NET Framework 源代码,请参阅 Reference Source

命名空间:   System
程序集:  mscorlib(位于 mscorlib.dll)


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

名称说明
System_CAPS_pubmethodString(Char*)

String 类的新实例初始化为由指向 Unicode 字符数组的指定指针指示的值。

System_CAPS_pubmethodString(Char*, Int32, Int32)

String 类的新实例初始化为由指向 Unicode 字符数组的指定指针指示的值、该数组内的起始字符位置和一个长度指示的值。

System_CAPS_pubmethodString(Char, Int32)

String 类的新实例初始化为由重复指定次数的指定 Unicode 字符指示的值。

System_CAPS_pubmethodString(Char[])

String 类的新实例初始化为由 Unicode 字符数组指示的值。

System_CAPS_pubmethodString(Char[], Int32, Int32)

String 类的新实例初始化为由 Unicode 字符数组、该数组内的起始字符位置和一个长度指示的值。

System_CAPS_pubmethodString(SByte*)

String 类的新实例初始化为由指向 8 位有符号整数数组的指针指示的值。

System_CAPS_pubmethodString(SByte*, Int32, Int32)

String 类的新实例初始化为由指向 8 位有符号整数数组的指定指针、该数组内的起始位置和一个长度指示的值。

System_CAPS_pubmethodString(SByte*, Int32, Int32, Encoding)

String 的新实例初始化为由指向 8 位有符号整数数组的指定指针、该数组内的起始位置、长度以及 Encoding 对象指示的值。

名称说明
System_CAPS_pubpropertyChars[Int32]

获取当前 Char 对象中位于指定位置的 String 对象。

System_CAPS_pubpropertyLength

获取当前 String 对象中的字符数。

名称说明
System_CAPS_pubmethodClone()

返回对此 String 实例的引用。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32)

比较两个指定的 String 对象的子字符串,并返回一个指示二者在排序顺序中的相对位置的整数。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, Boolean)

比较两个指定的 String 对象的子字符串(忽略或考虑其大小写),并返回一个整数,指示二者在排序顺序中的相对位置。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

比较两个指定的 String 对象(其中忽略或考虑其大小写,并使用区域性特定的信息干预比较),并返回一个整数,指示二者在排序顺序中的相对位置。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

对两个指定 String 对象的子字符串进行比较,使用指定的比较选项和区域性特定的信息来影响比较,并返回一个整数,该整数指示这两个子字符串在排序顺序中的关系。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, StringComparison)

使用指定的规则比较两个指定的 String 对象的子字符串,并返回一个整数,指示二者在排序顺序中的相对位置。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String)

比较两个指定的 String 对象,并返回一个指示二者在排序顺序中的相对位置的整数。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, Boolean)

比较两个指定的 String 对象(其中忽略或考虑其大小写),并返回一个整数,指示二者在排序顺序中的相对位置。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, Boolean, CultureInfo)

比较两个指定的 String 对象(其中忽略或考虑其大小写,并使用区域性特定的信息干预比较),并返回一个整数,指示二者在排序顺序中的相对位置。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, CultureInfo, CompareOptions)

对两个指定的 String 对象进行比较,使用指定的比较选项和区域性特定的信息来影响比较,并返回一个整数,该整数指示这两个字符串在排序顺序中的关系。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, StringComparison)

使用指定的规则比较两个指定的 String 对象,并返回一个整数,指示二者在排序顺序中的相对位置。

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(String, Int32, String, Int32, Int32)

通过计算每个子字符串中相应 String 对象的数值来比较两个指定的 Char 对象的子字符串。

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(String, String)

通过计算每个字符串中相应 String 对象的数值来比较两个指定的 Char 对象。

System_CAPS_pubmethodCompareTo(Object)

将此实例与指定的 Object 进行比较,并指示此实例在排序顺序中是位于指定的 Object 之前、之后还是与其出现在同一位置。

System_CAPS_pubmethodCompareTo(String)

将此实例与指定的 String 对象进行比较,并指示此实例在排序顺序中是位于指定的字符串之前、之后还是与其出现在同一位置。

System_CAPS_pubmethodSystem_CAPS_staticConcat(IEnumerable<String>)

串联类型为 IEnumerable<T>String 构造集合的成员。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object)

创建指定对象的字符串表示形式。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object)

连接两个指定对象的字符串表示形式。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object, Object)

连接三个指定对象的字符串表示形式。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object, Object, Object)

将四个指定对象的字符串表示形式与可选变量长度参数列表中指定的任何对象串联起来。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object[])

连接指定 Object 数组中的元素的字符串表示形式。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String)

连接 String 的两个指定实例。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String)

连接 String 的三个指定实例。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String, String)

连接 String 的四个指定实例。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String[])

连接指定的 String 数组的元素。

System_CAPS_pubmethodSystem_CAPS_staticConcat<T>(IEnumerable<T>)

串联 IEnumerable<T> 实现的成员。

System_CAPS_pubmethodContains(String)

返回一个值,该值指示指定的子串是否出现在此字符串中。

System_CAPS_pubmethodSystem_CAPS_staticCopy(String)

创建一个与指定的 String 具有相同值的 String 的新实例。

System_CAPS_pubmethodCopyTo(Int32, Char[], Int32, Int32)

将指定数目的字符从此实例中的指定位置复制到 Unicode 字符数组中的指定位置。

System_CAPS_pubmethodEndsWith(String)

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

System_CAPS_pubmethodEndsWith(String, Boolean, CultureInfo)

确定在使用指定的区域性进行比较时此字符串实例的结尾是否与指定的字符串匹配。

System_CAPS_pubmethodEndsWith(String, StringComparison)

确定使用指定的比较选项进行比较时此字符串实例的结尾是否与指定的字符串匹配。

System_CAPS_pubmethodEquals(Object)

确定此实例是否与指定的对象(也必须是 String 对象)具有相同的值。(覆盖 Object.Equals(Object)。)

System_CAPS_pubmethodEquals(String)

确定此实例是否与另一个指定的 String 对象具有相同的值。

System_CAPS_pubmethodSystem_CAPS_staticEquals(String, String)

确定两个指定的 String 对象是否具有相同的值。

System_CAPS_pubmethodSystem_CAPS_staticEquals(String, String, StringComparison)

确定两个指定的 String 对象是否具有相同的值。 参数指定区域性、大小写以及比较所用的排序规则。

System_CAPS_pubmethodEquals(String, StringComparison)

确定此字符串是否与另一个指定的 String 对象具有相同的值。 参数指定区域性、大小写以及比较所用的排序规则。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

将指定字符串中的一个或多个格式项替换为对应对象的字符串表示形式。 参数提供区域性特定的格式设置信息。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

将指定字符串中的格式项替换为两个指定对象的字符串表示形式。 参数提供区域性特定的格式设置信息。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object, Object)

将指定字符串中的格式项替换为三个指定对象的字符串表示形式。 参数提供区域性特定的格式设置信息。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

将指定字符串中的格式项替换为指定数组中相应对象的字符串表示形式。 参数提供区域性特定的格式设置信息。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

将指定字符串中的一个或多个格式项替换为指定对象的字符串表示形式。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

将指定字符串中的格式项替换为两个指定对象的字符串表示形式。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

将指定字符串中的格式项替换为三个指定对象的字符串表示形式。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object[])

将指定字符串中的格式项替换为指定数组中相应对象的字符串表示形式。

System_CAPS_pubmethodGetEnumerator()

检索一个可以循环访问此字符串中的每个字符的对象。

System_CAPS_pubmethodGetHashCode()

返回该字符串的哈希代码。(覆盖 Object.GetHashCode()。)

System_CAPS_pubmethodGetType()

获取当前实例的 Type(继承自 Object。)

System_CAPS_pubmethodGetTypeCode()

返回类 TypeCodeString

System_CAPS_pubmethodIndexOf(Char)

报告指定 Unicode 字符在此字符串中的第一个匹配项的从零开始的索引。

System_CAPS_pubmethodIndexOf(Char, Int32)

报告指定 Unicode 字符在此字符串中的第一个匹配项的从零开始的索引。 该搜索从指定字符位置开始。

System_CAPS_pubmethodIndexOf(Char, Int32, Int32)

报告指定字符在此实例中的第一个匹配项的从零开始的索引。 搜索从指定字符位置开始,并检查指定数量的字符位置。

System_CAPS_pubmethodIndexOf(String)

报告指定字符串在此实例中的第一个匹配项的从零开始的索引。

System_CAPS_pubmethodIndexOf(String, Int32)

报告指定字符串在此实例中的第一个匹配项的从零开始的索引。 该搜索从指定字符位置开始。

System_CAPS_pubmethodIndexOf(String, Int32, Int32)

报告指定字符串在此实例中的第一个匹配项的从零开始的索引。 搜索从指定字符位置开始,并检查指定数量的字符位置。

System_CAPS_pubmethodIndexOf(String, Int32, Int32, StringComparison)

报告指定的字符串在当前 String 对象中的第一个匹配项的从零开始的索引。 参数指定当前字符串中的起始搜索位置、要搜索的当前字符串中的字符数量,以及要用于指定字符串的搜索类型。

System_CAPS_pubmethodIndexOf(String, Int32, StringComparison)

报告指定的字符串在当前 String 对象中的第一个匹配项的从零开始的索引。 参数指定当前字符串中的起始搜索位置以及用于指定字符串的搜索类型。

System_CAPS_pubmethodIndexOf(String, StringComparison)

报告指定的字符串在当前 String 对象中的第一个匹配项的从零开始的索引。 一个参数指定要用于指定字符串的搜索类型。

System_CAPS_pubmethodIndexOfAny(Char[])

报告指定 Unicode 字符数组中的任意字符在此实例中第一个匹配项的从零开始的索引。

System_CAPS_pubmethodIndexOfAny(Char[], Int32)

报告指定 Unicode 字符数组中的任意字符在此实例中第一个匹配项的从零开始的索引。 该搜索从指定字符位置开始。

System_CAPS_pubmethodIndexOfAny(Char[], Int32, Int32)

报告指定 Unicode 字符数组中的任意字符在此实例中第一个匹配项的从零开始的索引。 搜索从指定字符位置开始,并检查指定数量的字符位置。

System_CAPS_pubmethodInsert(Int32, String)

返回一个新的字符串,在此实例中的指定的索引位置插入指定的字符串。

System_CAPS_pubmethodSystem_CAPS_staticIntern(String)

检索系统对指定 String 的引用。

System_CAPS_pubmethodSystem_CAPS_staticIsInterned(String)

检索对指定 String 的引用。

System_CAPS_pubmethodIsNormalized()

指示此字符串是否符合 Unicode 范式 C。

System_CAPS_pubmethodIsNormalized(NormalizationForm)

指示此字符串是否符合指定的 Unicode 范式。

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrEmpty(String)

指示指定的字符串是 null 还是 Empty 字符串。

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrWhiteSpace(String)

指示指定的字符串是 null、空还是仅由空白字符组成。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, IEnumerable<String>)

串联类型为 IEnumerable<T>String 构造集合的成员,其中在每个成员之间使用指定的分隔符。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, Object[])

串联对象数组的各个元素,其中在每个元素之间使用指定的分隔符。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, String[])

串联字符串数组的所有元素,其中在每个元素之间使用指定的分隔符。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, String[], Int32, Int32)

串联字符串数组的指定元素,其中在每个元素之间使用指定的分隔符。

System_CAPS_pubmethodSystem_CAPS_staticJoin<T>(String, IEnumerable<T>)

串联集合的成员,其中在每个成员之间使用指定的分隔符。

System_CAPS_pubmethodLastIndexOf(Char)

报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。

System_CAPS_pubmethodLastIndexOf(Char, Int32)

报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。

System_CAPS_pubmethodLastIndexOf(Char, Int32, Int32)

报告指定的 Unicode 字符在此实例内的子字符串中的最后一个匹配项的从零开始的索引的位置。 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。

System_CAPS_pubmethodLastIndexOf(String)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。

System_CAPS_pubmethodLastIndexOf(String, Int32)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。

System_CAPS_pubmethodLastIndexOf(String, Int32, Int32)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。

System_CAPS_pubmethodLastIndexOf(String, Int32, Int32, StringComparison)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。 搜索在所指定的字符位置的数目的字符串开始时,开始指定字符和其后面的位置。 一个参数指定要执行搜索指定字符串的比较类型。

System_CAPS_pubmethodLastIndexOf(String, Int32, StringComparison)

报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。 一个参数指定要执行搜索指定字符串的比较类型。

System_CAPS_pubmethodLastIndexOf(String, StringComparison)

报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。 一个参数指定要用于指定字符串的搜索类型。

System_CAPS_pubmethodLastIndexOfAny(Char[])

报告在 Unicode 数组中指定的一个或多个字符在此实例中的最后一个匹配项的从零开始的索引的位置。

System_CAPS_pubmethodLastIndexOfAny(Char[], Int32)

报告在 Unicode 数组中指定的一个或多个字符在此实例中的最后一个匹配项的从零开始的索引的位置。 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。

System_CAPS_pubmethodLastIndexOfAny(Char[], Int32, Int32)

报告在 Unicode 数组中指定的一个或多个字符在此实例中的最后一个匹配项的从零开始的索引的位置。 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。

System_CAPS_pubmethodNormalize()

返回一个新字符串,其文本值与此字符串相同,但其二进制表示形式符合 Unicode 范式 C。

System_CAPS_pubmethodNormalize(NormalizationForm)

返回一个新字符串,其文本值与此字符串相同,但其二进制表示形式符合指定的 Unicode 范式。

System_CAPS_pubmethodPadLeft(Int32)

返回一个新字符串,该字符串通过在此实例中的字符左侧填充空格来达到指定的总长度,从而实现右对齐。

System_CAPS_pubmethodPadLeft(Int32, Char)

返回一个新字符串,该字符串通过在此实例中的字符左侧填充指定的 Unicode 字符来达到指定的总长度,从而使这些字符右对齐。

System_CAPS_pubmethodPadRight(Int32)

返回一个新字符串,该字符串通过在此字符串中的字符右侧填充空格来达到指定的总长度,从而使这些字符左对齐。

System_CAPS_pubmethodPadRight(Int32, Char)

返回一个新字符串,该字符串通过在此字符串中的字符右侧填充指定的 Unicode 字符来达到指定的总长度,从而使这些字符左对齐。

System_CAPS_pubmethodRemove(Int32)

返回当前实例中从指定位置到最后位置的所有以删除的字符的新字符串。

System_CAPS_pubmethodRemove(Int32, Int32)

返回指定数量字符在当前这个实例起始点在已删除的指定的位置的新字符串。

System_CAPS_pubmethodReplace(Char, Char)

返回一个新字符串,其中此实例中出现的所有指定 Unicode 字符都替换为另一个指定的 Unicode 字符。

System_CAPS_pubmethodReplace(String, String)

返回一个新字符串,其中当前实例中出现的所有指定字符串都替换为另一个指定的字符串。

System_CAPS_pubmethodSplit(Char[])

基于数组中的字符将字符串拆分为多个子字符串。

System_CAPS_pubmethodSplit(Char[], Int32)

基于数组中的字符将一个字符串拆分成最大数量的子字符串。 也可指定要返回的子字符串的最大数量。

System_CAPS_pubmethodSplit(Char[], Int32, StringSplitOptions)

基于数组中的字符将一个字符串拆分成最大数量的子字符串。

System_CAPS_pubmethodSplit(Char[], StringSplitOptions)

基于数组中的字符将字符串拆分为多个子字符串。 可以指定子字符串是否包含空数组元素。

System_CAPS_pubmethodSplit(String[], Int32, StringSplitOptions)

基于数组中的字符串将一个字符串拆分成最大数量的子字符串。 可以指定子字符串是否包含空数组元素。

System_CAPS_pubmethodSplit(String[], StringSplitOptions)

基于数组中的字符串将字符串拆分为多个子字符串。 可以指定子字符串是否包含空数组元素。

System_CAPS_pubmethodStartsWith(String)

确定此字符串实例的开头是否与指定的字符串匹配。

System_CAPS_pubmethodStartsWith(String, Boolean, CultureInfo)

确定在使用指定的区域性进行比较时此字符串实例的开头是否与指定的字符串匹配。

System_CAPS_pubmethodStartsWith(String, StringComparison)

确定在使用指定的比较选项进行比较时此字符串实例的开头是否与指定的字符串匹配。

System_CAPS_pubmethodSubstring(Int32)

从此实例检索子字符串。 子字符串在指定的字符位置开始并一直到该字符串的末尾。

System_CAPS_pubmethodSubstring(Int32, Int32)

从此实例检索子字符串。 子字符串从指定的字符位置开始且具有指定的长度。

System_CAPS_pubmethodToCharArray()

将此实例中的字符复制到 Unicode 字符数组。

System_CAPS_pubmethodToCharArray(Int32, Int32)

将此实例中的指定子字符串内的字符复制到 Unicode 字符数组。

System_CAPS_pubmethodToLower()

返回此字符串转换为小写形式的副本。

System_CAPS_pubmethodToLower(CultureInfo)

根据指定区域性的大小写规则返回此字符串转换为小写形式的副本。

System_CAPS_pubmethodToLowerInvariant()

返回此 String 对象的转换为小写形式的副本,返回时使用固定区域性的大小写规则。

System_CAPS_pubmethodToString()

返回 String 的此实例;不执行实际转换。(覆盖 Object.ToString()。)

System_CAPS_pubmethodToString(IFormatProvider)

返回 String 的此实例;不执行实际转换。

System_CAPS_pubmethodToUpper()

返回此字符串转换为大写形式的副本。

System_CAPS_pubmethodToUpper(CultureInfo)

根据指定区域性的大小写规则返回此字符串转换为大写形式的副本。

System_CAPS_pubmethodToUpperInvariant()

返回此 String 对象的转换为大写形式的副本,返回时使用固定区域性的大小写规则。

System_CAPS_pubmethodTrim()

从当前 String 对象移除所有前导空白字符和尾部空白字符。

System_CAPS_pubmethodTrim(Char[])

从当前 String 对象移除数组中指定的一组字符的所有前导匹配项和尾部匹配项。

System_CAPS_pubmethodTrimEnd(Char[])

从当前 String 对象移除数组中指定的一组字符的所有尾部匹配项。

System_CAPS_pubmethodTrimStart(Char[])

从当前 String 对象移除数组中指定的一组字符的所有前导匹配项。

名称说明
System_CAPS_pubfieldSystem_CAPS_staticEmpty

表示空字符串。 此字段为只读。

名称说明
System_CAPS_puboperatorSystem_CAPS_staticEquality(String, String)

确定两个指定的字符串是否具有相同的值。

System_CAPS_puboperatorSystem_CAPS_staticInequality(String, String)

确定两个指定的字符串是否具有不同的值。

名称说明
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable<Char>.GetEnumerator()

返回循环访问当前 String 对象的枚举数。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

返回循环访问当前 String 对象的枚举数。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToBoolean

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToByte

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToChar

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToDateTime

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToDecimal

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToDouble

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToInt16

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToInt32

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToInt64

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToSByte

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToSingle

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToType

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToUInt16

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToUInt32

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

此 API 支持 产品 基础结构,不应从代码直接使用。 有关此成员的说明,请参阅 ToUInt64

名称说明
System_CAPS_pubmethodAggregate<Char>(Func<Char, Char, Char>)

已重载。对一个序列应用累加器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodAggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)

已重载。对一个序列应用累加器函数。 将指定的种子值用作累加器初始值。(由 Enumerable 定义。)

System_CAPS_pubmethodAggregate<Char, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, Char, TAccumulate>, Func<TAccumulate, TResult>)

已重载。对一个序列应用累加器函数。 将指定的种子值用作累加器的初始值,并使用指定的函数选择结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodAll<Char>(Func<Char, Boolean>)

确定是否对序列中的所有元素都满足条件。(由 Enumerable 定义。)

System_CAPS_pubmethodAny<Char>()

已重载。确定序列是否包含任何元素。(由 Enumerable 定义。)

System_CAPS_pubmethodAny<Char>(Func<Char, Boolean>)

已重载。 确定序列中是否存在元素满足条件。 (由 Enumerable 定义。)

System_CAPS_pubmethodAsEnumerable<Char>()

返回输入类型化为 IEnumerable<T>(由 Enumerable 定义。)

System_CAPS_pubmethodAsParallel()

已重载。启用查询的并行化。(由 ParallelEnumerable 定义。)

System_CAPS_pubmethodAsParallel<Char>()

已重载。启用查询的并行化。(由 ParallelEnumerable 定义。)

System_CAPS_pubmethodAsQueryable()

已重载。将转换 IEnumerableIQueryable(由 Queryable 定义。)

System_CAPS_pubmethodAsQueryable<Char>()

已重载。将转换泛型 IEnumerable<T> 于泛型 IQueryable<T>(由 Queryable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Decimal>)

已重载。计算序列的平均值 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Double>)

已重载。计算序列的平均值 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int32>)

已重载。计算序列的平均值 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int64>)

已重载。计算序列的平均值 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Decimal>>)

已重载。可以为 null 的序列的平均值,计算 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Double>>)

已重载。可以为 null 的序列的平均值,计算 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int32>>)

已重载。可以为 null 的序列的平均值,计算 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int64>>)

已重载。可以为 null 的序列的平均值,计算 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Single>>)

已重载。可以为 null 的序列的平均值,计算 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Single>)

已重载。计算序列的平均值 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodCast<TResult>()

将强制转换的元素 IEnumerable 为指定的类型。(由 Enumerable 定义。)

System_CAPS_pubmethodConcat<Char>(IEnumerable<Char>)

连接两个序列。(由 Enumerable 定义。)

System_CAPS_pubmethodContains<Char>(Char)

已重载。确定序列是否包含指定的元素使用的默认相等比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodContains<Char>(Char, IEqualityComparer<Char>)

已重载。确定序列是否使用指定的包含指定的元素 IEqualityComparer<T>(由 Enumerable 定义。)

System_CAPS_pubmethodCount<Char>()

已重载。返回序列中的元素数。(由 Enumerable 定义。)

System_CAPS_pubmethodCount<Char>(Func<Char, Boolean>)

已重载。返回一个数字来表示多少个元素指定序列中的满足条件。(由 Enumerable 定义。)

System_CAPS_pubmethodDefaultIfEmpty<Char>()

已重载。返回单一实例集合中指定的序列或类型参数的默认值的元素,如果序列为空。(由 Enumerable 定义。)

System_CAPS_pubmethodDefaultIfEmpty<Char>(Char)

已重载。返回单一实例集合中指定的序列或指定的值的元素,如果序列为空。(由 Enumerable 定义。)

System_CAPS_pubmethodDistinct<Char>()

已重载。通过使用的默认相等比较器对值进行比较从序列返回非重复元素。(由 Enumerable 定义。)

System_CAPS_pubmethodDistinct<Char>(IEqualityComparer<Char>)

已重载。返回序列中通过使用指定的非重复元素 IEqualityComparer<T> 对值进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodElementAt<Char>(Int32)

返回序列中的指定索引处的元素。(由 Enumerable 定义。)

System_CAPS_pubmethodElementAtOrDefault<Char>(Int32)

返回序列中指定索引处的元素;如果索引超出范围,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>)

已重载。通过使用默认的相等比较器对值进行比较,生成两个序列的差集。(由 Enumerable 定义。)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

已重载。使用指定的生成两个序列的差集 IEqualityComparer<T> 对值进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodFirst<Char>()

已重载。返回一个序列的第一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodFirst<Char>(Func<Char, Boolean>)

已重载。返回序列中满足指定条件的第一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodFirstOrDefault<Char>()

已重载。返回序列中的第一个元素;如果序列中不包含任何元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodFirstOrDefault<Char>(Func<Char, Boolean>)

已重载。返回序列中满足条件的第一个元素;如果未找到这样的元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey>(Func<Char, TKey>)

已重载。根据指定的键选择器函数对序列的元素进行分组。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

已重载。根据指定的键选择器函数并将进行比较的键使用指定的比较器对序列的元素进行分组。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

已重载。根据指定的键选择器函数和项目的元素的每个组通过使用指定的函数对序列的元素进行分组。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

已重载。根据键选择器函数对序列的元素进行分组。 通过使用比较器对键进行比较,并且通过使用指定的函数对每个组的元素进行投影。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>, IEqualityComparer<TKey>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的比较器对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的函数对每个组的元素进行投影。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的比较器对键值进行比较,并且通过使用指定的函数对每个组的元素进行投影。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)

已重载。基于键相等对两个序列的元素进行关联,并对结果进行分组。 使用默认的相等比较器对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

已重载。基于键相等对两个序列的元素进行关联,并对结果进行分组。 指定 IEqualityComparer<T> 用来对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>)

已重载。通过使用默认的相等比较器对值进行比较,生成两个序列的交集。(由 Enumerable 定义。)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

已重载。使用指定的生成两个序列的交集 IEqualityComparer<T> 对值进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)

已重载。基于匹配键对两个序列的元素关联。 使用默认的相等比较器对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)

已重载。基于匹配键对两个序列的元素关联。 指定 IEqualityComparer<T> 用来对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodLast<Char>()

已重载。返回一个序列的最后一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodLast<Char>(Func<Char, Boolean>)

已重载。返回序列中满足指定条件的最后一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodLastOrDefault<Char>()

已重载。返回序列中的最后一个元素;如果序列中不包含任何元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodLastOrDefault<Char>(Func<Char, Boolean>)

已重载。返回序列中满足条件的最后一个元素;如果未找到这样的元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodLongCount<Char>()

已重载。返回 Int64 ,它表示序列中的元素的总数。(由 Enumerable 定义。)

System_CAPS_pubmethodLongCount<Char>(Func<Char, Boolean>)

已重载。返回 Int64 表示序列中的多少个元素满足条件。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>()

已重载。泛型序列中返回的最大值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Decimal>)

已重载。调用转换函数对序列的每个元素并返回最大 Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Double>)

已重载。调用转换函数对序列的每个元素并返回最大 Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Int32>)

已重载。调用转换函数对序列的每个元素并返回最大 Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Int64>)

已重载。调用转换函数对序列的每个元素并返回最大 Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Decimal>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Double>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int32>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int64>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Single>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char>(Func<Char, Single>)

已重载。调用转换函数对序列的每个元素并返回最大 Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<Char, TResult>(Func<Char, TResult>)

已重载。调用泛型序列的每个元素的转换函数并返回最大结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>()

已重载。泛型序列中返回的最小值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Decimal>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Double>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Int32>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Int64>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Decimal>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Double>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int32>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int64>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Single>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char>(Func<Char, Single>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<Char, TResult>(Func<Char, TResult>)

已重载。调用泛型序列的每个元素的转换函数,并返回最小的结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodOfType<TResult>()

筛选的元素 IEnumerable 根据指定的类型。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderBy<Char, TKey>(Func<Char, TKey>)

已重载。按根据某个键按升序对序列的元素进行排序。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)

已重载。按使用指定的比较器按升序对序列的元素进行排序。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderByDescending<Char, TKey>(Func<Char, TKey>)

已重载。按根据某个键按降序对序列的元素进行排序。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)

已重载。使用指定的比较器按降序对序列的元素排序。(由 Enumerable 定义。)

System_CAPS_pubmethodReverse<Char>()

反转序列中元素的顺序。(由 Enumerable 定义。)

System_CAPS_pubmethodSelect<Char, TResult>(Func<Char, TResult>)

已重载。将序列中的每个元素投影到新表单。(由 Enumerable 定义。)

System_CAPS_pubmethodSelect<Char, TResult>(Func<Char, Int32, TResult>)

已重载。通过合并元素的索引投影到一个新窗体的序列的每个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<Char, TResult>(Func<Char, IEnumerable<TResult>>)

已重载。一个序列的每个元素投影 IEnumerable<T> 并将合并为一个序列将结果序列。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)

已重载。一个序列的每个元素投影 IEnumerable<T>, ,并将合并为一个序列将结果序列。 每个源元素的索引用于该元素的投影表。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<Char, TCollection, TResult>(Func<Char, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)

已重载。一个序列的每个元素投影 IEnumerable<T>, 将平展为一个序列,将结果序列,其中调用结果选择器函数对每个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<Char, TCollection, TResult>(Func<Char, Int32, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)

已重载。一个序列的每个元素投影 IEnumerable<T>, 将平展为一个序列,将结果序列,其中调用结果选择器函数对每个元素。 每个源元素的索引用于该元素的中间投影表。(由 Enumerable 定义。)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>)

已重载。确定两个序列是否相等的元素进行比较通过使用相应类型的默认相等比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

已重载。确定两个序列是否通过使用指定的比较它们的元素相等 IEqualityComparer<T>(由 Enumerable 定义。)

System_CAPS_pubmethodSingle<Char>()

已重载。返回序列的唯一元素;如果该序列并非恰好包含一个元素,则会引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSingle<Char>(Func<Char, Boolean>)

已重载。返回序列中满足指定条件的唯一元素;如果有多个这样的元素存在,则会引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSingleOrDefault<Char>()

已重载。返回一个序列,或默认值的唯一元素,如果序列为空,则为如果序列中存在多个元素,则此方法将引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSingleOrDefault<Char>(Func<Char, Boolean>)

已重载。返回序列中满足指定条件的唯一元素;如果这类元素不存在,则返回默认值;如果有多个元素满足该条件,此方法将引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSkip<Char>(Int32)

跳过指定的数量的序列中的元素,然后返回剩余元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSkipWhile<Char>(Func<Char, Boolean>)

已重载。只要指定的条件为 true,然后返回剩余元素,跳过序列中的元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSkipWhile<Char>(Func<Char, Int32, Boolean>)

已重载。只要指定的条件为 true,然后返回剩余元素,跳过序列中的元素。 将在谓词函数的逻辑中使用元素的索引。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Decimal>)

已重载。计算的序列的和 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Double>)

已重载。计算的序列的和 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Int32>)

已重载。计算的序列的和 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Int64>)

已重载。计算的序列的和 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Decimal>>)

已重载。计算可以为 null 的序列的和 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Double>>)

已重载。计算可以为 null 的序列的和 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int32>>)

已重载。计算可以为 null 的序列的和 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int64>>)

已重载。计算可以为 null 的序列的和 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Single>>)

已重载。计算可以为 null 的序列的和 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<Char>(Func<Char, Single>)

已重载。计算的序列的和 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodTake<Char>(Int32)

从序列的开头返回指定的数量的连续元素。(由 Enumerable 定义。)

System_CAPS_pubmethodTakeWhile<Char>(Func<Char, Boolean>)

已重载。返回序列中的元素,只要指定的条件为真。(由 Enumerable 定义。)

System_CAPS_pubmethodTakeWhile<Char>(Func<Char, Int32, Boolean>)

已重载。返回序列中的元素,只要指定的条件为真。 将在谓词函数的逻辑中使用元素的索引。(由 Enumerable 定义。)

System_CAPS_pubmethodToArray<Char>()

创建一个数组,从 IEnumerable<T>(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器函数和键比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器函数、 比较器和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToList<Char>()

创建 List<T>IEnumerable<T>(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器函数和键比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器函数、 比较和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>)

已重载。通过使用默认的相等比较器生成的两个序列的并集。(由 Enumerable 定义。)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

已重载。使用指定的生成两个序列的并集 IEqualityComparer<T>(由 Enumerable 定义。)

System_CAPS_pubmethodWhere<Char>(Func<Char, Boolean>)

已重载。基于谓词筛选值序列。(由 Enumerable 定义。)

System_CAPS_pubmethodWhere<Char>(Func<Char, Int32, Boolean>)

已重载。基于谓词筛选值序列。 将在谓词函数的逻辑中使用每个元素的索引。(由 Enumerable 定义。)

System_CAPS_pubmethodZip<Char, TSecond, TResult>(IEnumerable<TSecond>, Func<Char, TSecond, TResult>)

适用于两个序列,生成结果的序列的相应元素指定的函数。(由 Enumerable 定义。)

System_CAPS_note说明

若要查看此类型的.NET Framework 源代码,请参阅 Reference Source 您可以浏览源代码、 下载脱机查看参考资料和调试; 在逐句通过源 (包括修补程序和更新)see instructions.

字符串是用于表示文本的字符有序集合。 一个 String 对象是的有序集合 System.Char 对象,分别代表一个字符串; System.Char 对象对应于 utf-16 代码单位。String 对象为该的有序集合的内容 System.Char 对象,并且值是不可变 (即,它是只读的)。 字符串的不变性的详细信息,请参阅 不变性和 StringBuilder 类 在本主题后面的部分。 最大大小 String 在内存中的对象是 2 GB 或大约 1 亿个字符。

本节内容:

实例化字符串对象
Char 对象和 Unicode 字符
字符串和 Unicode 标准
字符串和嵌入的空字符
字符串和已分区索引
Null 字符串和空字符串
不变性和 StringBuilder 类
与区分区域性的操作的第几个
标准化
按类别列出的字符串操作

您可以实例化 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# 和 (& a) 或 + 在 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.      
    

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

System_CAPS_note说明

请注意,因为 String 实例包含的 utf-16 代码单元有序集合,则可以创建 String 不是格式良好的 Unicode 字符串的对象。 例如,则可以创建具有一个低代理项,而无需相应的高代理项的字符串。 尽管一些方法,如编码和解码中的对象的方法 System.Text 命名空间中,可能会执行检查,以确保字符串格式正确, String 类成员不能确保字符串是格式正确。

单个 Char 对象通常表示单个码位; 也就是说,值的数值 Char 等于码位。 例如,码位的字符"a"为 U + 0061。 但是,代码点可能需要多个编码的元素 (多个 Char 对象)。 Unicode 标准定义了两种类型的相对应的字符到多个 Char 对象 ︰ graphemes,并对应于在 Unicode 辅助平面字符的 Unicode 补充码位。

  • 字形由基字符后跟一个或多个组合字符表示。 例如,由一个表示字符 ä Char 对象,其码位为 U + 0061 跟一个 Char 其码位为 U + 0308年的对象。 此字符也可通过单个定义 Char 具有 U + 00E4 码位的对象。 如下面的示例所示,区分区域性的比较相等指示这两种表示相等,尽管普通的序号比较则不然。 但是,如果两个字符串进行规范化,序号比较还指示它们是否相等。 (有关规范化字符串的详细信息,请参阅 规范化 部分。)

    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
    

字符串中的字符编码的 utf-16 代码单元,它们分别对应于由表示 Char 值。

字符串中的每个字符已由.NET Framework 中表示关联的 Unicode 字符类别 UnicodeCategory 枚举。 可通过调用确定一个字符或代理项对类别 CharUnicodeInfo.GetUnicodeCategory 方法。

.NET Framework 维护其自己表的字符和其相应的类别,这样可以确保在不同平台上运行的.NET framework 版本返回相同的字符分类信息。 下表列出的.NET Framework 版本和版本及其字符类别所基于的 Unicode 标准。

.NET Framework 版本

Unicode 标准版本

.NET Framework 1.1

The Unicode Standard, Version 4.0.0

.NET 2.0 Framework

The Unicode Standard, Version 5.0.0

.NET Framework 3.5

The Unicode Standard, Version 5.0.0

.NET Framework 4

The Unicode Standard, Version 5.0.0

.NET Framework 4.5

The Unicode Standard, Version 6.3.0

.NET Framework 4.5.1

The Unicode Standard, Version 6.3.0

.NET Framework 4.5.2

The Unicode Standard, Version 6.3.0

.NET Framework 4.6

The Unicode Standard, Version 6.3.0

.NET Framework 4.6.1

The Unicode Standard, Version 6.3.0

.NET Framework 4.6.2

The Unicode Standard, Version 8.0.0

此外,.NET Framework 支持的字符串比较和排序基于 Unicode 标准。 在通过.NET Framework 的版本 .NET Framework 4, ,.NET Framework 维护其自己的字符串数据的表。 这也是如此的开头的.NET Framework 版本 .NET Framework 4.5 Windows 7 上运行。 从开始 .NET Framework 4.5 Window 8 和更高版本的 Windows 操作系统上运行,运行时委托字符串比较和排序操作对操作系统。 下表列出的.NET Framework 版本和 Unicode 标准的字符的比较和排序所基于的版本。

.NET Framework 版本

Unicode 标准版本

.NET Framework 1.1

The Unicode Standard, Version 4.0.0

.NET 2.0 Framework

The Unicode Standard, Version 5.0.0

.NET Framework 3.5

The Unicode Standard, Version 5.0.0

.NET Framework 4

The Unicode Standard, Version 5.0.0

.NET Framework 4.5 及更高版本在 Windows 7 上

The Unicode Standard, Version 5.0.0

.NET Framework 4.5 及更高版本在 Windows 8 和更高版本的 Windows 操作系统上

The Unicode Standard, Version 6.3.0

在.NET Framework 中, String 对象可以包含嵌入的 null 字符,作为字符串的长度的一部分进行计数。 但是,在某些语言如 C 和 c + + 中,null 字符指示字符串的末尾; 它不被视为字符串的一部分,不统计为字符串的长度的一部分。 这意味着对字符串作出 C 和 c + + 程序员或在 C 或 c + + 中编写的库的下列常规假设不一定有效时应用于 String 对象 ︰

  • 返回的值 strlenwcslen 函数并不一定能 String.Length

  • 由创建的字符串 strcpy_swcscpy_s 函数不是由创建的字符串一定要完全相同 String.Copy 方法。

您应确保实例化该本机 C 和 c + + 代码 String 对象和代码传递 String 对象通过平台调用,请不要认为嵌入的 null 字符将字符串的结尾标记。

排序 (或比较) 一个字符串,以及将搜索字符串时,在字符串中嵌入的空字符还以不同方式处理。 在执行区分区域性的比较两个字符串,包括使用固定区域性的比较时,将忽略 null 字符。 它们被认为是仅为序号或不区分大小写的序号比较。 另一方面,嵌入的 null 字符时,始终考虑如用方法搜索字符串 Contains, ,StartsWith, ,和 IndexOf

索引是位置 Char 中的对象 (而不是 Unicode 字符) String 索引是从在字符串中,来表示零的索引位置的第一个位置中启动一个从零开始的、 非负数字。 很多的搜索方法,如 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 接口,您还可以循环 Char 中使用的字符串对象 foreach 构造,如以下示例所示。

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 尝试在该字符串上调用方法将引发 NullReferenceException 空字符串是不同为空字符串,这是一个字符串,其值从""或 String.Empty 在某些情况下,将作为方法调用中的参数传递空字符串或空字符串将引发异常。 例如,null 字符串传递给 Int32.Parse 方法抛出异常 ArgumentNullException, ,并传递空字符串,则会引发 FormatException 在其他情况下,方法参数可以是空字符串或空字符串。 例如,如果你要提供 IFormattable 类实现中的,你想要将空字符串和一个空字符串视为相等与常规 ("G") 格式说明符。

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

下面的示例使用 IsNullOrEmpty 中的方法 IFormattable.ToString 的自定义实现 Temperature 类。 该方法支持"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));
   }                                   
}

一个 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 与范围内的 1000 个随机字符 StringBuilder 对象。

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对象,并采用特定于区域性的大小写、 排序、 格式和考虑分析规则。 显式声明的区域性或隐式的当前区域性的上下文中执行区分区域性的操作。 它们在相同的字符串执行时,两种操作可以产生非常不同的结果。

.NET Framework 还支持通过使用固定区域性的不区分区域性的语义字符串操作 (CultureInfo.InvariantCulture),它松散基于独立于区域的英语语言的区域性设置。 与其他不同 System.Globalization.CultureInfo 保证设置、 固定区域性的设置都保持一致的单个计算机上,从系统中,与.NET Framework 各版本的系统。 固定区域性可以跨所有区域性是视为一种类型的黑色方框表示既可以确保稳定性的字符串比较和排序。

System_CAPS_security 安全性 说明

如果您的应用程序作出安全决策有关符号标识符如文件名或命名管道,或有关持久化数据,如 XML 文件中的基于文本的数据,该操作应该使用序号比较,而不是区分区域性的比较。 这是因为实际上,区分区域性的比较产生不同的结果,具体取决于该区域性而序号比较仅取决于比较的字符的二进制值。

System_CAPS_important重要事项

执行字符串操作的大多数方法包括一个具有类型参数的重载 StringComparison, ,这样您就可以指定该方法执行序号或区分区域性的操作。 一般情况下,应调用此重载,以使您的方法调用清除的意图。 有关最佳实践和使用字符串的序号和区分区域性的操作的指导,请参阅 在 .NET Framework 中使用字符串的最佳做法

用于操作 大小写, ,分析和格式化, ,比较和排序, ,和 相等性测试 可以序号或区分区域性的。 以下各节讨论每个类别的操作。

System_CAPS_tip提示

应始终调用的方法重载,使您的方法调用清除的意图。 例如,而不是调用 Compare(String, String) 要通过使用当前区域性的约定来执行区分区域性的比较两个字符串的方法应调用 Compare(String, String, StringComparison) 具有值的方法 StringComparison.CurrentCulturecomparisonType 参数。 有关详细信息,请参阅在 .NET Framework 中使用字符串的最佳做法

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

大小写操作可以基于当前区域性、 指定的区域性或固定区域性的规则。 因为大小写映射可能会变化,具体取决于所使用的区域性,大小写操作的结果将根据区域性对会有所不同。 大小写的实际差异有三种 ︰

  • 中的拉丁语 I 的大写首字母大小写映射的差异 (U + 0049),拉丁文小写字母 I (U + 0069),LATIN CAPITAL LETTER I 和带点上方 (U + 0130),拉丁文小写字母句点 I (U + 0131)。 在 TR-TR (土耳其语 (土耳其)) 和 (阿塞拜疆,拉丁语) az-Latn-AZ 区域性和 tr、 az 和 az Latn 非特定区域性,LATIN CAPITAL LETTER I 的小写等效项是拉丁文小写字母句点 I、 和拉丁文小写字母 I 的大写等效项高于 LATIN CAPITAL LETTER I 与圆点。 在所有其他区域性中,其中包括固定区域性,拉丁文小写字母 I 和 LATIN CAPITAL LETTER 进行大写和小写等效项。

    下面的示例演示如何设计的字符串比较,以防止文件系统访问权限可能会失败是否依赖的区分区域性的大小写比较。 (固定区域性的大小写约定应已使用。)

    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 +-39 C)

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

    小写

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

    拉丁文小写字母无点我 (U + 0131)

    大写

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

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

    大写

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

    小写字母 Z 带抑扬符拉丁文大写字母 D (U + 01C 5)

    小写

    拉丁文小写字母 DZ 带抑扬符 (U + 01C 6)

    组合希腊语 YPOGEGRAMMENI (U + 0345)

    大写

    希腊文大写字母 IOTA (U + 0399)

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

    • "lJ"和"nJ"HR-HR (克罗地亚语 (克罗地亚)) 区域性中。

    • "cH"CS-CZ (捷克语 (捷克共和国)) 和 SK-SK (斯洛伐克语 (斯洛伐克)) 文化中。

    • "aA"DA-DK (丹麦语 (丹麦)) 区域性中。

    • "cS"、"dZ"、"dZS"、"nY"、"sZ"、"tY"和"zS"HU-HU (匈牙利语 (匈牙利)) 区域性中。

    • "cH"和"lL"es ES_tradnl (西班牙语 (西班牙,传统风格)) 区域性中。

    • "cH"、"gI"、"kH"、"nG""nH"、"pH","qU,"tH"和"tR"vi VN (越南语 (越南)) 区域性中的。

    但是,很少会遇到的情况下,这些对区分区域性的比较在其中创建一个问题,因为这些对很少出现在固定的字符串或标识符。

下面的示例说明了一些在大小写规则区域性时将字符串转换为大写形式之间的差异。

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 

格式设置和分析为反向操作。 格式设置规则确定如何将一个值,如日期和时间或数字,转换为其字符串表示形式,而分析规则确定如何将字符串表示形式转换为一个值,如日期和时间。 格式化和分析规则都依赖于区域性的约定。 下面的示例演示解释特定于区域性的日期字符串时可能会出现不明确性。 而无需了解用于生成的日期字符串的区域性的约定,不可能知道 2011-03-01、 2011 年 3 月 1 日,和 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

用于比较和排序字符串约定而异因区域性。 例如,排序顺序可能基于拼音或基于字符的可视表示形式。 在东亚语言中,按文字的笔画和部首对字符进行排序。 排序也取决于字母表使用的排序语言和区域性。 例如,丹麦语中有“Æ”字符,它在字母表中排在“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 支持 word、 字符串和序号排序规则 ︰

  • 单词排序执行区分区域性的字符串比较在其中某些非字母数字 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.CurrentCulture, ,StringComparison.CurrentCultureIgnoreCase, ,或任何成员的 CompareOptions 以外的其他枚举 CompareOptions.OrdinalCompareOptions.OrdinalIgnoreCase 的适当重载 Compare 方法。 一般适合用于进行排序而不是序号比较是区分区域性的比较。 序号比较是一般适合用于确定两个字符串 (即,用于确定标识) 而不是区分区域性的比较。

下面的示例阐释区分区域性且序号比较之间的差异。 该示例计算结果的三个字符串"Apple"、"æ b l e"和"AEble",则使用序号比较和 DA-DK 和 EN-US 区域性的约定 (其中每个为时的默认区域性 Compare 调用方法)。 由于丹麦语将字符"Æ"视为单个字母,并对其进行排序在"Z"之后在字母表中排,字符串"æ b l e"大于"Apple"。 但是,"æ b l e"不被视为等效于"AEble",因此也"æ b l e"大于"AEble"。 EN-US 区域性不包括字母"Æ",但会将其视为等效于"AE",解释了为什么"æ b l e"小于"Apple"但等于"AEble"。 序号比较,另一方面,考虑"Apple"小于"æ b l e",并"æ b l e"必须晚于"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 方法。

System_CAPS_note说明

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

有关 word、 字符串和序号排序规则的详细信息,请参阅 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
System_CAPS_tip提示

在内部,.net Framework 使用排序关键字来支持 culturallysensitive 字符串比较。 对于字符串中的每个字符,都赋予若干类排序权重,包括字母、大小写和变音符。 排序键,由表示 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 时的结果不一样,因为这次使用的是针对丹麦语(丹麦)的排序约定。

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
System_CAPS_warning警告

如果您在比较字符串的主要用途是确定它们是否相等,则应调用 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

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

中的搜索方法 String 类的单个字符,如搜索IndexOf 方法或一组字符,如 IndexOfAny 方法中,所有执行序号搜索。 若要执行区分区域性的搜索的字符时,必须调用 CompareInfo 方法如 CompareInfo.IndexOf(String, Char)CompareInfo.LastIndexOf(String, Char) 请注意搜索的字符使用序号和区分区域性的比较的结果可能会非常困难。 例如,搜索 Unicode 字符,如连字"Æ"(U + 00 C 6) 可能匹配的所有事件,以正确的顺序,如"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, ,这将执行顺序搜索。

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

System_CAPS_warning警告

可以通过调用测试相等性 String.Compare 方法,并确定返回值是否为零。 但是,不建议此做法。 若要确定两个字符串是否相等,应调用的重载之一 String.Equals 方法。 首选的重载来调用为实例 Equals(String, StringComparison) 方法或静态 Equals(String, String, StringComparison) 方法,因为这两种方法包括 System.StringComparison 显式指定的比较类型的参数。

下面的示例演示执行区分区域性的比较相等时应改为使用其中一个的序号的危险。 在这种情况下,代码的目的是文件系统访问禁止通过执行不区分大小写的 URL 来用于字符串"FILE://"开头的比较"FILE://"或"file://"开头的 Url。 但是,如果以"file://"开头的 URL 上使用土耳其语 (土耳其) 区域性执行区分区域性的比较,则相等性比较发生故障,因为小写"i"的土耳其语大写等效项是"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。 当字符串被正常化为相同的范式时,则可以按使用序号比较比较。

序号比较是相应的 Unicode 标量值的二进制比较 Char 每个字符串中的对象。 String 类还包含一些可以执行序号比较,其中包括以下方法 ︰

您可以确定对字符串进行范式 C 到通过调用规范化 String.IsNormalized() 方法,也可以调用 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 Normalization FormsNormalization FAQ unicode.org 网站上。

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

您可以比较字符串以确定二者在排序顺序中的相对位置通过使用以下 String方法 ︰

  • Compare 返回一个整数,指示一个字符串与第二个字符串在排序顺序中的关系。

  • CompareOrdinal 返回一个整数,指示一个字符串与第二个字符串根据其码位比较的关系。

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

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

String 类包括两种类型的搜索方法 ︰

System_CAPS_warning警告

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

String 类包括以下方法看起来要修改字符串的值 ︰

  • Insert 将字符串插入到当前 String 实例。

  • PadLeft 在字符串的开头处插入指定的字符的一个或多个匹配项。

  • PadRight 在字符串的开头处插入指定的字符的一个或多个匹配项。

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

  • Replace 子字符串替换为另一个子字符串在当前 String 实例。

  • ToLowerToLowerInvariant 将字符串中的所有字符都转换为小写。

  • ToUpperToUpperInvariant 将字符串中的所有字符都转换为大写。

  • Trim 删除所有空白字符开头和结尾的字符串。

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

  • TrimStart 从中移除所有字符的字符串的开头。

System_CAPS_important重要事项

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

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

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

  • Concat 将合并成单个字符串的一个或多个子字符串。

  • Join 串联成一个元素的一个或多个子字符串,并添加每个子字符串之间的分隔符。

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

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

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

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

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

  • 若要使右对齐或左对齐较大字符串中的字段中的子字符串。

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

您可以通过调用以下 String 方法,以便进行的字符串的副本 ︰

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

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

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

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

有关详细信息和示例,请参阅 标准化 本主题前面的部分。

通用 Windows 平台
自 8 起可用
.NET Framework
自 1.1 起可用
可移植类库
可移植 .NET 平台 中受支持
Silverlight
自 2.0 起可用
Windows Phone Silverlight
自 7.0 起可用
Windows Phone
自 8.1 起可用

此类型是线程安全的。

返回页首
显示: