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

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.

字符串是用于表示文本的字符的有序集合。 AString对象是的有序集合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# 中和 & 或 + 在 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
    
  • 补充代码点 (代理项对) 表示通过 UnicodeChar其码位是一个高代理项对象跟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 Framework 2.0

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 Framework 2.0

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 字符。 它们都仅进行序号或不区分大小写的序号比较。 另一方面,嵌入的空字符始终被视为如使用方法搜索字符串时ContainsStartsWith,和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 Null 字符串是不同于空字符串,这是一个字符串,其值""或String.Empty 在某些情况下,将 null 字符串或空字符串作为方法调用中的参数传递的操作将会引发异常。 例如,将传递到一个 null 字符串Int32.Parse方法抛出异常ArgumentNullException,并传递空字符串将引发FormatException 在其他情况下,方法自变量可以是空字符串或空字符串。 例如,如果你要提供IFormattable类实现中的,你想要将一个 null 字符串和一个空字符串视为相等与常规 ("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));
   }                                   
}

AString对象调用不可变 (只读),因为它已被创建后不能修改其值。 看起来要修改的方法String对象实际返回一个新String包含修改的对象。

由于字符串是不可变,执行的字符串操作例程重复添加或删除操作到看起来是单个字符串可以精确显著的性能损失。 例如,下面的代码使用的随机数生成器使用 1000年个字符,范围从 0x0001 到 0x052F 中创建一个字符串。 尽管代码会使用字符串串联以将新字符追加到名为的现有字符串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方法将字符串转换为词首字母大写。

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

  • 大小写映射的 LATIN CAPITAL LETTER I 方面的差异 (U + 0049),拉丁文小写字母 I (U + 0069),LATIN CAPITAL LETTER I 随 (U + 0130),上面的点和拉丁文小写字母无点 I (U + 0131)。 在 TR-TR (土耳其语 (土耳其)) 和 (阿塞拜疆,拉丁语) az-Latn-AZ 区域性和 tr、 az 和 az Latn 非特定区域性,拉丁文大写字母 I 的小写等效项是拉丁文小写字母无点 I、 和拉丁文小写字母 I 的大写等效项高于拉丁文大写字母 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 (克罗地亚语 (克罗地亚)) 区域性中。

    • "频道"cs CZ (捷克语 (捷克共和国)) 和 sk-SK (斯洛伐克语 (斯洛伐克)) 区域性中。

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

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

    • "频道"和"lL"es ES_tradnl (西班牙语 (西班牙,传统排序)) 区域性中。

    • "频道"、"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 字符可能具有特殊的权重执行区分区域性的比较的字符串。 例如,连字符 (-) 可能具有很小的权重分配给它,以便"联合"和"合作"挨着出现在已排序的列表。 有关的列表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.OrdinalCompareOptions.OrdinalIgnoreCase的相应重载Compare方法。 通常适用于排序而序号比较不区分区域性的比较。 序号比较是通常适用于确定两个字符串是否相等 (即,用于确定标识) 而不是区分区域性的比较。

下面的示例演示区分区域性且序号比较之间的差异。 该示例计算结果的三个字符串、"Apple"、"Æble"和"AEble",以使用序号比较和 DA-DK 并 EN-US 区域性的约定 (其中每个时的默认区域性Compare调用方法)。 因为丹麦语语言字符"Æ"将其视为单个字母并对进行排序它在"Z"之后在字母表中,字符串"Æble"大于"Apple"。 但是,"Æble"不被视为等效于"AEble",因此"Æble"也是大于"AEble"。 EN-US 区域性不包括字母"Æ",但会将其视为等效于"遍历",解释了为什么"Æble"小于"Apple"但等于"AEble"。 序号比较,另一方面,会将"Apple"小于"Æble"和"Æble"必须晚于"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) 的搜索可能匹配其组件在正确的顺序,如"遍历"中的任何匹配项 (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显式指定的比较类型的参数。

下面的示例演示执行区分区域性的比较相等时是执行序号一个应改为使用的危险。 在这种情况下,代码的目的是禁止在通过执行不区分大小写比较的字符串"FILE://"带的 URL 开头的"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 支持 C、 D、 KC 和 KD 的 Unicode 范式。 当已为同一范式标准化字符串时,它们可以通过使用序号比较进行比较。

序号比较是相应的 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 起可用

此类型是线程安全的。

返回页首
显示: