通过

String 类

  • 参考

定义

命名空间:
System
程序集:
System.Runtime.dll
程序集:
mscorlib.dll
程序集:
netstandard.dll
Source:
String.cs
Source:
String.cs
Source:
String.cs

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

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, IParsable<System::String ^>, ISpanParsable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public ref class System::String sealed : ICloneable, IComparable, IConvertible, System::Collections::IEnumerable
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::IEnumerable
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public sealed class String : IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, IParsable<string>, ISpanParsable<string>, System.Collections.Generic.IEnumerable<char>
[System.Serializable]
public sealed class String : ICloneable, IComparable, IConvertible, System.Collections.IEnumerable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.IEnumerable
public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface IParsable<string>
    interface ISpanParsable<string>
type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface ICloneable
[<System.Serializable>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IComparable<string>
    interface seq<char>
    interface IEnumerable
    interface IEquatable<string>
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
type string = class
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
type string = class
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
    interface seq<char>
    interface IEnumerable
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String), IParsable(Of String), ISpanParsable(Of String)
Public NotInheritable Class String
Implements ICloneable, IComparable, IConvertible, IEnumerable
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable, IEquatable(Of String)
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable(Of Char), IEquatable(Of String)
继承
Object
String
属性
SerializableAttribute ComVisibleAttribute
实现
IEnumerable<Char> IEnumerable IComparable IComparable<String> IConvertible IEquatable<String> ICloneable IParsable<String> IParsable<TSelf> ISpanParsable<String>

注解

有关此 API 的详细信息，请参阅字符串的补充 API 说明。

构造函数

String(Char*)

将 String 类的新实例初始化为指向 Unicode 字符数组的指定指针指示的值。
String(Char*, Int32, Int32)

将 String 类的新实例初始化为指向 Unicode 字符数组的指定指针、该数组中的起始字符位置以及长度的值。
String(Char, Int32)

将 String 类的新实例初始化为指定的 Unicode 字符重复指定的次数所指示的值。
String(Char[])

将 String 类的新实例初始化为指定字符数组中指示的 Unicode 字符。
String(Char[], Int32, Int32)

将 String 类的新实例初始化为 Unicode 字符数组、该数组中的起始字符位置和长度指示的值。
String(ReadOnlySpan<Char>)

将 String 类的新实例初始化为指定只读范围中指示的 Unicode 字符。
String(SByte*)

将 String 类的新实例初始化为指向 8 位带符号整数数组的指针指示的值。
String(SByte*, Int32, Int32)

将 String 类的新实例初始化为指定指针指示的值，该值指向 8 位有符号整数的数组、该数组中的起始位置以及长度。
String(SByte*, Int32, Int32, Encoding)

将 String 类的新实例初始化为由指定指针指示的值，该数组中具有 8 位有符号整数的数组、该数组中的起始位置、长度和 Encoding 对象。

字段

Empty

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

属性

Chars[Int32]

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

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

方法

Clone()

返回对此 String实例的引用。
Compare(String, Int32, String, Int32, Int32)

比较两个指定 String 对象的子字符串，并返回一个整数，指示它们在排序顺序中的相对位置。
Compare(String, Int32, String, Int32, Int32, Boolean)

比较两个指定 String 对象的子字符串，忽略或遵循其大小写，并返回一个整数，指示它们在排序顺序中的相对位置。
Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

比较两个指定 String 对象的子字符串，忽略或遵循其大小写，并使用区域性特定的信息影响比较，并返回一个整数，指示其相对位置在排序顺序。
Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

使用指定的比较选项和区域性特定的信息比较两个指定 String 对象的子字符串来影响比较，并返回一个整数，指示两个子字符串在排序顺序中彼此之间的关系。
Compare(String, Int32, String, Int32, Int32, StringComparison)

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

比较两个指定的 String 对象，并返回一个整数，指示它们在排序顺序中的相对位置。
Compare(String, String, Boolean)

比较两个指定的 String 对象，忽略或遵循其大小写，并返回一个整数，指示它们在排序顺序中的相对位置。
Compare(String, String, Boolean, CultureInfo)

比较两个指定的 String 对象，忽略或遵循其大小写，并使用区域性特定的信息影响比较，并返回一个整数，指示它们在排序顺序中的相对位置。
Compare(String, String, CultureInfo, CompareOptions)

使用指定的比较选项和区域性特定的信息比较两个指定的 String 对象来影响比较，并返回一个整数，该整数指示两个字符串在排序顺序中彼此之间的关系。
Compare(String, String, StringComparison)

使用指定的规则比较两个指定的 String 对象，并返回一个整数，指示它们在排序顺序中的相对位置。
CompareOrdinal(String, Int32, String, Int32, Int32)

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

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

将此实例与指定的 Object 进行比较，并指示此实例在排序顺序中是否与指定的 Object位于同一位置。
CompareTo(String)

将此实例与指定的 String 对象进行比较，并指示此实例在排序顺序中是否与指定字符串位于同一位置。
Concat(IEnumerable<String>)

连接类型为 String的构造 IEnumerable<T> 集合的成员。
Concat(Object)

创建指定对象的字符串表示形式。
Concat(Object, Object)

连接两个指定对象的字符串表示形式。
Concat(Object, Object, Object)

连接三个指定对象的字符串表示形式。
Concat(Object, Object, Object, Object)

连接四个指定对象的字符串表示形式和在可选变量长度参数列表中指定的任何对象。
Concat(Object[])

连接指定 Object 数组中元素的字符串表示形式。
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

连接两个指定的只读字符范围的字符串表示形式。
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

连接三个指定的只读字符范围的字符串表示形式。
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

连接四个指定的只读字符范围的字符串表示形式。
Concat(ReadOnlySpan<Object>)

连接指定对象范围中元素的字符串表示形式。
Concat(ReadOnlySpan<String>)

连接指定范围 String的元素。
Concat(String, String)

连接两个指定的 String实例。
Concat(String, String, String)

连接三个指定的 String实例。
Concat(String, String, String, String)

连接四个指定的 String实例。
Concat(String[])

连接指定 String 数组的元素。
Concat<T>(IEnumerable<T>)

连接 IEnumerable<T> 实现的成员。
Contains(Char)

返回一个值，该值指示指定字符是否在此字符串中发生。
Contains(Char, StringComparison)

返回一个值，该值指示是否使用指定的比较规则在此字符串中发生指定字符。
Contains(String)

返回一个值，该值指示指定的子字符串是否在此字符串中发生。
Contains(String, StringComparison)

返回一个值，该值指示指定的字符串是否在此字符串中使用指定的比较规则发生。
Copy(String)
已过时.

使用与指定 String相同的值创建 String 的新实例。
CopyTo(Int32, Char[], Int32, Int32)

将指定数目的字符从此实例中的指定位置复制到 Unicode 字符数组中的指定位置。
CopyTo(Span<Char>)

将此字符串的内容复制到目标范围。
Create(IFormatProvider, DefaultInterpolatedStringHandler)

通过使用指定的提供程序来控制指定内插字符串的格式，创建一个新字符串。
Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

通过使用指定的提供程序来控制指定内插字符串的格式，创建一个新字符串。
Create<TState>(Int32, TState, SpanAction<Char,TState>)

使用指定的回调创建具有特定长度的新字符串，并在创建后对其进行初始化。
EndsWith(Char)

确定此字符串实例的末尾是否与指定的字符匹配。
EndsWith(String)

确定此字符串实例的末尾是否与指定的字符串匹配。
EndsWith(String, Boolean, CultureInfo)

确定此字符串实例的末尾在使用指定的区域性进行比较时是否与指定的字符串匹配。
EndsWith(String, StringComparison)

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

返回此字符串中 Rune 的枚举。
Equals(Object)

确定此实例和指定对象（还必须是 String 对象）是否具有相同的值。
Equals(String)

确定此实例和另一个指定的 String 对象是否具有相同的值。
Equals(String, String)

确定两个指定的 String 对象是否具有相同的值。
Equals(String, String, StringComparison)

确定两个指定的 String 对象是否具有相同的值。 参数指定比较中使用的区域性、大小写和排序规则。
Equals(String, StringComparison)

确定此字符串和指定的 String 对象是否具有相同的值。 参数指定比较中使用的区域性、大小写和排序规则。
Format(IFormatProvider, CompositeFormat, Object[])

将 CompositeFormat 中的格式项或项替换为指定格式中相应对象的字符串表示形式。
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)

将 CompositeFormat 中的格式项或项替换为指定格式中相应对象的字符串表示形式。
Format(IFormatProvider, String, Object)

将指定字符串中的格式项或项替换为相应对象的字符串表示形式。 参数提供区域性特定的格式设置信息。
Format(IFormatProvider, String, Object, Object)

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

将字符串中的格式项替换为三个指定对象的字符串表示形式。 参数提供区域性特定的格式设置信息。
Format(IFormatProvider, String, Object[])

将字符串中的格式项替换为指定数组中相应对象的字符串表示形式。 参数提供区域性特定的格式设置信息。
Format(IFormatProvider, String, ReadOnlySpan<Object>)

将字符串中的格式项替换为指定范围中相应对象的字符串表示形式。 参数提供区域性特定的格式设置信息。
Format(String, Object)

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

将字符串中的格式项替换为两个指定对象的字符串表示形式。
Format(String, Object, Object, Object)

将字符串中的格式项替换为三个指定对象的字符串表示形式。
Format(String, Object[])

将指定字符串中的格式项替换为指定数组中相应对象的字符串表示形式。
Format(String, ReadOnlySpan<Object>)

将指定字符串中的格式项替换为指定范围中相应对象的字符串表示形式。
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)

将 CompositeFormat 中的格式项或项替换为指定格式中相应对象的字符串表示形式。
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)

将 CompositeFormat 中的格式项或项替换为指定格式中相应对象的字符串表示形式。
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)

将 CompositeFormat 中的格式项或项替换为指定格式中相应对象的字符串表示形式。
GetEnumerator()

检索一个对象，该对象可以循环访问此字符串中的单个字符。
GetHashCode()

返回此字符串的哈希代码。
GetHashCode(ReadOnlySpan<Char>)

返回提供的只读字符范围的哈希代码。
GetHashCode(ReadOnlySpan<Char>, StringComparison)

使用指定的规则返回提供的只读字符范围的哈希代码。
GetHashCode(StringComparison)

使用指定的规则返回此字符串的哈希代码。
GetPinnableReference()

返回对索引为零的字符串元素的引用。

此方法旨在支持 .NET 编译器，不应由用户代码调用。
GetType()

获取当前实例的 Type。

(继承自 Object)
GetTypeCode()

返回 String 类的 TypeCode。
IndexOf(Char)

报告此字符串中指定 Unicode 字符的第一个匹配项的从零开始的索引。
IndexOf(Char, Int32)

报告此字符串中指定 Unicode 字符的第一个匹配项的从零开始的索引。 搜索从指定的字符位置开始。
IndexOf(Char, Int32, Int32)

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

报告此字符串中指定 Unicode 字符的第一个匹配项的从零开始的索引。 参数指定要用于指定字符的搜索类型。
IndexOf(String)

报告此实例中指定字符串的第一个匹配项的从零开始的索引。
IndexOf(String, Int32)

报告此实例中指定字符串的第一个匹配项的从零开始的索引。 搜索从指定的字符位置开始。
IndexOf(String, Int32, Int32)

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

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

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

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

报告指定 Unicode 字符数组中任何字符的此实例中第一个匹配项的从零开始的索引。
IndexOfAny(Char[], Int32)

报告指定 Unicode 字符数组中任何字符的此实例中第一个匹配项的从零开始的索引。 搜索从指定的字符位置开始。
IndexOfAny(Char[], Int32, Int32)

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

返回一个新字符串，在此实例的指定索引位置插入指定的字符串。
Intern(String)

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

检索对指定 String的引用。
IsNormalized()

指示此字符串是否采用 Unicode 规范化形式 C。
IsNormalized(NormalizationForm)

指示此字符串是否采用指定的 Unicode 规范化形式。
IsNullOrEmpty(String)

指示指定的字符串是 null 还是空字符串（“）。
IsNullOrWhiteSpace(String)

指示指定的字符串是 null、空还是仅包含空格字符。
Join(Char, Object[])

使用每个成员之间的指定分隔符连接对象数组的字符串表示形式。
Join(Char, ReadOnlySpan<Object>)

使用每个成员之间的指定分隔符连接对象范围的字符串表示形式。
Join(Char, ReadOnlySpan<String>)

使用每个成员之间的指定分隔符连接字符串范围。
Join(Char, String[])

使用每个成员之间的指定分隔符连接字符串数组。
Join(Char, String[], Int32, Int32)

使用每个成员之间的指定分隔符连接字符串数组，从位于 startIndex 位置的 value 元素开始，并连接最多 count 元素。
Join(String, IEnumerable<String>)

使用每个成员之间的指定分隔符连接 String类型的构造 IEnumerable<T> 集合的成员。
Join(String, Object[])

使用每个元素之间的指定分隔符连接对象数组的元素。
Join(String, ReadOnlySpan<Object>)

使用每个成员之间的指定分隔符连接对象范围的字符串表示形式。
Join(String, ReadOnlySpan<String>)

使用每个成员之间的指定分隔符连接字符串范围。
Join(String, String[])

使用每个元素之间的指定分隔符连接字符串数组的所有元素。
Join(String, String[], Int32, Int32)

使用每个元素之间的指定分隔符连接字符串数组的指定元素。
Join<T>(Char, IEnumerable<T>)

使用每个成员之间的指定分隔符连接集合的成员。
Join<T>(String, IEnumerable<T>)

使用每个成员之间的指定分隔符连接集合的成员。
LastIndexOf(Char)

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

报告此实例中指定 Unicode 字符的最后一个匹配项的从零开始的索引位置。 搜索从指定的字符位置开始，并向后向向字符串的开头。
LastIndexOf(Char, Int32, Int32)

报告在此实例中的子字符串中指定 Unicode 字符的最后一个匹配项的从零开始的索引位置。 搜索从指定的字符位置开始，然后向后向向字符串开头的指定数目的字符位置。
LastIndexOf(String)

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

报告此实例中指定字符串的最后一个匹配项的从零开始的索引位置。 搜索从指定的字符位置开始，并向后向向字符串的开头。
LastIndexOf(String, Int32, Int32)

报告此实例中指定字符串的最后一个匹配项的从零开始的索引位置。 搜索从指定的字符位置开始，然后向后向向字符串开头的指定数目的字符位置。
LastIndexOf(String, Int32, Int32, StringComparison)

报告此实例中指定字符串的最后一个匹配项的从零开始的索引位置。 搜索从指定的字符位置开始，然后向后向向字符串开头的指定字符位置。 参数指定搜索指定字符串时要执行的比较类型。
LastIndexOf(String, Int32, StringComparison)

报告当前 String 对象中指定字符串的最后一个匹配项的从零开始的索引。 搜索从指定的字符位置开始，并向后向向字符串的开头。 参数指定搜索指定字符串时要执行的比较类型。
LastIndexOf(String, StringComparison)

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

报告 Unicode 数组中指定的一个或多个字符的此实例中最后一个匹配项的从零开始的索引位置。
LastIndexOfAny(Char[], Int32)

报告 Unicode 数组中指定的一个或多个字符的此实例中最后一个匹配项的从零开始的索引位置。 搜索从指定的字符位置开始，并向后向向字符串的开头。
LastIndexOfAny(Char[], Int32, Int32)

报告 Unicode 数组中指定的一个或多个字符的此实例中最后一个匹配项的从零开始的索引位置。 搜索从指定的字符位置开始，然后向后向向字符串开头的指定数目的字符位置。
MemberwiseClone()

创建当前 Object的浅表副本。

(继承自 Object)
Normalize()

返回一个新字符串，其文本值与此字符串相同，但其二进制表示形式为 Unicode 规范化形式 C。
Normalize(NormalizationForm)

返回一个新字符串，其文本值与此字符串相同，但其二进制表示形式采用指定的 Unicode 规范化形式。
PadLeft(Int32)

返回一个新字符串，该字符串通过在左侧用空格填充字符，使此实例中的字符右对齐，以指定的总长度。
PadLeft(Int32, Char)

返回一个新字符串，该字符串通过用指定的 Unicode 字符在左侧填充字符，以指定的总长度来右对齐此实例中的字符。
PadRight(Int32)

返回一个新字符串，该字符串通过用右侧的空格填充字符，使该字符串中的字符保持左对齐，以指定的总长度。
PadRight(Int32, Char)

返回一个新字符串，该字符串通过用指定的 Unicode 字符在右侧填充字符以指定总长度来使字符串中的字符左对齐。
Remove(Int32)

返回一个新字符串，其中当前实例中的所有字符（从指定位置开始并继续执行最后一个位置）已被删除。
Remove(Int32, Int32)

返回一个新字符串，其中从指定位置开始的当前实例中的指定字符数已被删除。
Replace(Char, Char)

返回一个新字符串，在该字符串中，此实例中指定 Unicode 字符的所有匹配项都替换为另一个指定的 Unicode 字符。
Replace(String, String)

返回一个新字符串，其中当前实例中指定字符串的所有匹配项都替换为另一个指定的字符串。
Replace(String, String, Boolean, CultureInfo)

返回一个新字符串，在该字符串中，当前实例中指定字符串的所有匹配项都替换为另一个指定的字符串，并使用提供的区域性和区分大小写。
Replace(String, String, StringComparison)

返回一个新字符串，在该字符串中，当前实例中指定字符串的所有匹配项都替换为另一个指定的字符串，并使用提供的比较类型。
ReplaceLineEndings()

用 NewLine替换当前字符串中的所有换行序列。
ReplaceLineEndings(String)

用 replacementText替换当前字符串中的所有换行序列。
Split(Char, Int32, StringSplitOptions)

根据指定的分隔符和（可选）选项，将字符串拆分为最大数量的子字符串。 根据提供的字符分隔符将字符串拆分为最大子字符串数，可以选择省略结果中的空子字符串。
Split(Char, StringSplitOptions)

根据指定的分隔符以及（可选）选项将字符串拆分为子字符串。
Split(Char[])

根据指定的分隔字符将字符串拆分为子字符串。
Split(Char[], Int32)

根据指定的分隔字符将字符串拆分为最大数量的子字符串。
Split(Char[], Int32, StringSplitOptions)

根据指定的分隔字符和（可选）选项，将字符串拆分为最大数量的子字符串。
Split(Char[], StringSplitOptions)

根据指定的分隔字符和选项将字符串拆分为子字符串。
Split(ReadOnlySpan<Char>)

根据指定的分隔字符将字符串拆分为子字符串。
Split(String, Int32, StringSplitOptions)

根据指定的分隔字符串和（可选）选项，将字符串拆分为最大数量的子字符串。
Split(String, StringSplitOptions)

将字符串拆分为基于提供的字符串分隔符的子字符串。
Split(String[], Int32, StringSplitOptions)

根据指定的分隔字符串和（可选）选项，将字符串拆分为最大子字符串数。
Split(String[], StringSplitOptions)

根据指定的分隔字符串以及（可选）选项将字符串拆分为子字符串。
StartsWith(Char)

确定此字符串实例是否以指定字符开头。
StartsWith(String)

确定此字符串实例的开头是否与指定的字符串匹配。
StartsWith(String, Boolean, CultureInfo)

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

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

从此实例检索子字符串。 子字符串从指定的字符位置开始，并继续到字符串的末尾。
Substring(Int32, Int32)

从此实例检索子字符串。 子字符串从指定的字符位置开始，并具有指定的长度。
ToCharArray()

将此实例中的字符复制到 Unicode 字符数组。
ToCharArray(Int32, Int32)

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

返回转换为小写的此字符串的副本。
ToLower(CultureInfo)

使用指定区域性的大小写规则返回转换为小写的此字符串的副本。
ToLowerInvariant()

返回此 String 对象的副本，该对象使用固定区域性的大小写规则转换为小写。
ToString()

返回 String的此实例;不执行实际转换。
ToString(IFormatProvider)

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

返回转换为大写的此字符串的副本。
ToUpper(CultureInfo)

使用指定区域性的大小写规则返回转换为大写的此字符串的副本。
ToUpperInvariant()

返回此 String 对象的副本，该对象使用固定区域性的大小写规则转换为大写。
Trim()

从当前字符串中删除所有前导和尾随空格字符。
Trim(Char)

从当前字符串中删除字符的所有前导和尾随实例。
Trim(Char[])

从当前字符串中删除数组中指定的一组字符的所有前导和尾随匹配项。
Trim(ReadOnlySpan<Char>)

从当前字符串中删除在范围中指定的一组字符的所有前导和尾随匹配项。
TrimEnd()

从当前字符串中删除所有尾随空格字符。
TrimEnd(Char)

从当前字符串中删除字符的所有尾随匹配项。
TrimEnd(Char[])

从当前字符串中删除数组中指定的一组字符的所有尾随匹配项。
TrimEnd(ReadOnlySpan<Char>)

从当前字符串中删除在范围中指定的一组字符的所有尾随匹配项。
TrimStart()

从当前字符串中删除所有前导空格字符。
TrimStart(Char)

从当前字符串中删除指定字符的所有前导匹配项。
TrimStart(Char[])

从当前字符串中删除数组中指定的一组字符的所有前导匹配项。
TrimStart(ReadOnlySpan<Char>)

从当前字符串中删除范围中指定的一组字符的所有前导匹配项。
TryCopyTo(Span<Char>)

将此字符串的内容复制到目标范围。

运算符

Equality(String, String)

确定两个指定的字符串是否具有相同的值。
Implicit(String to ReadOnlySpan<Char>)

定义给定字符串到只读字符范围的隐式转换。
Inequality(String, String)

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

显式接口实现

IComparable.CompareTo(Object)

将此实例与指定的 Object 进行比较，并指示此实例在排序顺序中是否与指定的 Object位于同一位置。
IConvertible.GetTypeCode()

返回 String 类的 TypeCode。
IConvertible.ToBoolean(IFormatProvider)

有关此成员的说明，请参阅 ToBoolean(IFormatProvider)。
IConvertible.ToByte(IFormatProvider)

有关此成员的说明，请参阅 ToByte(IFormatProvider)。
IConvertible.ToChar(IFormatProvider)

有关此成员的说明，请参阅 ToChar(IFormatProvider)。
IConvertible.ToDateTime(IFormatProvider)

有关此成员的说明，请参阅 ToDateTime(IFormatProvider)。
IConvertible.ToDecimal(IFormatProvider)

有关此成员的说明，请参阅 ToDecimal(IFormatProvider)。
IConvertible.ToDouble(IFormatProvider)

有关此成员的说明，请参阅 ToDouble(IFormatProvider)。
IConvertible.ToInt16(IFormatProvider)

有关此成员的说明，请参阅 ToInt16(IFormatProvider)。
IConvertible.ToInt32(IFormatProvider)

有关此成员的说明，请参阅 ToInt32(IFormatProvider)。
IConvertible.ToInt64(IFormatProvider)

有关此成员的说明，请参阅 ToInt64(IFormatProvider)。
IConvertible.ToSByte(IFormatProvider)

有关此成员的说明，请参阅 ToSByte(IFormatProvider)。
IConvertible.ToSingle(IFormatProvider)

有关此成员的说明，请参阅 ToSingle(IFormatProvider)。
IConvertible.ToString(IFormatProvider)

有关此成员的说明，请参阅 ToString(IFormatProvider)。
IConvertible.ToType(Type, IFormatProvider)

有关此成员的说明，请参阅 ToType(Type, IFormatProvider)。
IConvertible.ToUInt16(IFormatProvider)

有关此成员的说明，请参阅 ToUInt16(IFormatProvider)。
IConvertible.ToUInt32(IFormatProvider)

有关此成员的说明，请参阅 ToUInt32(IFormatProvider)。
IConvertible.ToUInt64(IFormatProvider)

有关此成员的说明，请参阅 ToUInt64(IFormatProvider)。
IEnumerable.GetEnumerator()

返回循环访问当前 String 对象的枚举数。
IEnumerable<Char>.GetEnumerator()

返回循环访问当前 String 对象的枚举数。
IParsable<String>.Parse(String, IFormatProvider)

将字符串分析为值。
IParsable<String>.TryParse(String, IFormatProvider, String)

将文本表示为 UTF-16 代码单元序列。
ISpanParsable<String>.Parse(ReadOnlySpan<Char>, IFormatProvider)

将字符的范围分析为值。
ISpanParsable<String>.TryParse(ReadOnlySpan<Char>, IFormatProvider, String)

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

扩展方法

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数从 IEnumerable<T> 创建 FrozenDictionary<TKey,TValue>。
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

根据指定的键选择器和元素选择器函数从 IEnumerable<T> 创建 FrozenDictionary<TKey,TValue>。
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)

创建具有指定值的 FrozenSet<T>。
ToImmutableArray<TSource>(IEnumerable<TSource>)

从指定的集合创建不可变数组。
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

从现有元素集合构造不可变字典，将转换函数应用于源键。
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

基于序列的某些转换构造不可变字典。
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

枚举和转换序列，并生成其内容的不可变字典。
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

枚举和转换序列，并使用指定的键比较器生成其内容的不可变字典。
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

枚举和转换序列，并使用指定的键和值比较器生成其内容的不可变字典。
ToImmutableHashSet<TSource>(IEnumerable<TSource>)

枚举序列并生成其内容的不可变哈希集。
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

枚举序列，生成其内容的不可变哈希集，并为集类型使用指定的相等比较器。
ToImmutableList<TSource>(IEnumerable<TSource>)

枚举序列并生成其内容的不可变列表。
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

枚举和转换序列，并生成其内容的不可变排序字典。
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

枚举和转换序列，并使用指定的键比较器生成其内容的不可变排序字典。
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

枚举和转换序列，并使用指定的键和值比较器生成其内容的不可变排序字典。
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

枚举序列并生成其内容的不可变排序集。
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

枚举序列，生成其内容的不可变排序集，并使用指定的比较器。
CopyToDataTable<T>(IEnumerable<T>)

返回一个包含 DataRow 对象副本的 DataTable，给定 IEnumerable<T> 对象的输入 IEnumerable<T> 对象，其中泛型参数 TDataRow。
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

给定泛型参数 TDataRow的输入 IEnumerable<T> 对象，将 DataRow 对象复制到指定的 DataTable。
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

给定泛型参数 TDataRow的输入 IEnumerable<T> 对象，将 DataRow 对象复制到指定的 DataTable。
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

对序列应用累加器函数。
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

对序列应用累加器函数。 指定的种子值用作初始累加器值。
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

对序列应用累加器函数。 指定的种子值用作初始累加器值，并且指定函数用于选择结果值。
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)

将文本表示为 UTF-16 代码单元序列。
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)

将文本表示为 UTF-16 代码单元序列。
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

确定序列的所有元素是否满足条件。
Any<TSource>(IEnumerable<TSource>)

确定序列是否包含任何元素。
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

确定序列的任何元素是否满足条件。
Append<TSource>(IEnumerable<TSource>, TSource)

将值追加到序列的末尾。
AsEnumerable<TSource>(IEnumerable<TSource>)

返回类型化为 IEnumerable<T>的输入。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

计算通过对输入序列的每个元素调用转换函数获得的 Decimal 值的序列的平均值。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

计算通过对输入序列的每个元素调用转换函数获得的 Double 值的序列的平均值。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

计算通过对输入序列的每个元素调用转换函数获得的 Int32 值的序列的平均值。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

计算通过对输入序列的每个元素调用转换函数获得的 Int64 值的序列的平均值。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

计算一系列可为 null 的 Decimal 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

计算一系列可为 null 的 Double 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

计算一系列可为 null 的 Int32 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

计算一系列可为 null 的 Int64 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

计算一系列可为 null 的 Single 值的平均值，这些值是通过对输入序列的每个元素调用转换函数获得的。
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

计算通过对输入序列的每个元素调用转换函数获得的 Single 值的序列的平均值。
Cast<TResult>(IEnumerable)

将 IEnumerable 的元素强制转换为指定类型。
Chunk<TSource>(IEnumerable<TSource>, Int32)

将序列的元素拆分为大小块，最多 size。
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

连接两个序列。
Contains<TSource>(IEnumerable<TSource>, TSource)

使用默认相等比较器确定序列是否包含指定的元素。
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

确定序列是否使用指定的 IEqualityComparer<T>包含指定的元素。
Count<TSource>(IEnumerable<TSource>)

返回序列中的元素数。
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回一个数字，该值代表指定序列中满足条件的元素数。
CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

将文本表示为 UTF-16 代码单元序列。
DefaultIfEmpty<TSource>(IEnumerable<TSource>)

如果序列为空，则返回指定序列的元素或类型参数在单一实例集合中的默认值。
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

如果序列为空，则返回指定序列的元素或单个实例集合中的指定值。
Distinct<TSource>(IEnumerable<TSource>)

通过使用默认相等比较器比较值，从序列中返回不同的元素。
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

通过使用指定的 IEqualityComparer<T> 来比较值，从序列中返回不同的元素。
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据指定的键选择器函数返回序列中的不同元素。
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数并使用指定的比较器比较键，从序列中返回不同的元素。
ElementAt<TSource>(IEnumerable<TSource>, Index)

返回序列中指定索引处的元素。
ElementAt<TSource>(IEnumerable<TSource>, Int32)

返回序列中指定索引处的元素。
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)

返回序列中指定索引处的元素;如果索引范围不足，则返回默认值。
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

返回序列中指定索引处的元素;如果索引范围不足，则返回默认值。
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

使用默认相等比较器来比较值，生成两个序列的集差。
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

通过使用指定的 IEqualityComparer<T> 来比较值，生成两个序列的集差异。
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

根据指定的键选择器函数生成两个序列的集差异。
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数生成两个序列的集差异。
First<TSource>(IEnumerable<TSource>)

返回序列的第一个元素。
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回满足指定条件的序列中的第一个元素。
FirstOrDefault<TSource>(IEnumerable<TSource>)

返回序列的第一个元素;如果序列不包含任何元素，则返回默认值。
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)

返回序列的第一个元素;如果序列不包含任何元素，则返回指定的默认值。
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回满足条件的序列的第一个元素;如果未找到此类元素，则返回默认值。
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

返回满足条件的序列的第一个元素;如果未找到此类元素，则返回指定的默认值。
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据指定的键选择器函数对序列的元素进行分组。
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数对序列的元素进行分组，并使用指定的比较器比较键。
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

根据指定的键选择器函数对序列的元素进行分组，并使用指定的函数投影每个组的元素。
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

根据键选择器函数对序列的元素进行分组。 通过使用比较器比较键，并且每个组的元素都通过使用指定的函数进行投影。
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。 使用指定的比较器比较键。
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。 每个组的元素是使用指定的函数投影的。
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

根据指定的键选择器函数对序列的元素进行分组，并从每个组及其键创建结果值。 使用指定的比较器比较键值，并且每个组的元素都通过使用指定的函数进行投影。
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)

根据键的相等性关联两个序列的元素，并对结果进行分组。 默认相等比较器用于比较键。
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

根据键相等性关联两个序列的元素，并对结果进行分组。 指定的 IEqualityComparer<T> 用于比较键。
Index<TSource>(IEnumerable<TSource>)

返回一个可枚举值，该枚举将元素的索引合并到元组中。
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

通过使用默认相等比较器来比较值，生成两个序列的集交集。
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

通过使用指定的 IEqualityComparer<T> 来比较值，生成两个序列的集交集。
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

根据指定的键选择器函数生成两个序列的集交集。
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数生成两个序列的集交集。
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

根据匹配键关联两个序列的元素。 默认相等比较器用于比较键。
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

根据匹配键关联两个序列的元素。 指定的 IEqualityComparer<T> 用于比较键。
Last<TSource>(IEnumerable<TSource>)

返回序列的最后一个元素。
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回满足指定条件的序列的最后一个元素。
LastOrDefault<TSource>(IEnumerable<TSource>)

返回序列的最后一个元素;如果序列不包含任何元素，则返回默认值。
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)

返回序列的最后一个元素;如果序列不包含任何元素，则返回指定的默认值。
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回满足条件的序列的最后一个元素;如果未找到此类元素，则返回默认值。
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

返回满足条件的序列的最后一个元素;如果未找到此类元素，则返回指定的默认值。
LongCount<TSource>(IEnumerable<TSource>)

返回一个表示序列中元素总数的 Int64。
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回表示序列中满足条件的元素数的 Int64。
Max<TSource>(IEnumerable<TSource>)

返回泛型序列中的最大值。
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)

返回泛型序列中的最大值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

对序列的每个元素调用转换函数，并返回最大 Decimal 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

对序列的每个元素调用转换函数，并返回最大 Double 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

对序列的每个元素调用转换函数，并返回最大 Int32 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

对序列的每个元素调用转换函数，并返回最大 Int64 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

对序列的每个元素调用转换函数，并返回最大可为 null Decimal 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

对序列的每个元素调用转换函数，并返回最大可为 null Double 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

对序列的每个元素调用转换函数，并返回最大可为 null Int32 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

对序列的每个元素调用转换函数，并返回最大可为 null Int64 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

对序列的每个元素调用转换函数，并返回最大可为 null Single 值。
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

对序列的每个元素调用转换函数，并返回最大 Single 值。
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

对泛型序列的每个元素调用转换函数，并返回得到的最大值。
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据指定的键选择器函数返回泛型序列中的最大值。
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

根据指定的键选择器函数和键比较器返回泛型序列中的最大值。
Min<TSource>(IEnumerable<TSource>)

返回泛型序列中的最小值。
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)

返回泛型序列中的最小值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

对序列的每个元素调用转换函数，并返回最小 Decimal 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

对序列的每个元素调用转换函数，并返回最小 Double 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

对序列的每个元素调用转换函数，并返回最小 Int32 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

对序列的每个元素调用转换函数，并返回最小 Int64 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Decimal 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Double 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Int32 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Int64 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

对序列的每个元素调用转换函数，并返回可为 null 的最小 Single 值。
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

对序列的每个元素调用转换函数，并返回最小 Single 值。
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

对泛型序列的每个元素调用转换函数，并返回生成的最小值。
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据指定的键选择器函数返回泛型序列中的最小值。
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

根据指定的键选择器函数和键比较器返回泛型序列中的最小值。
OfType<TResult>(IEnumerable)

根据指定类型筛选 IEnumerable 的元素。
Order<T>(IEnumerable<T>)

按升序对序列的元素进行排序。
Order<T>(IEnumerable<T>, IComparer<T>)

按升序对序列的元素进行排序。
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据键按升序对序列的元素进行排序。
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

使用指定的比较器按升序对序列的元素进行排序。
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据键按降序对序列的元素进行排序。
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

使用指定的比较器按降序对序列的元素进行排序。
OrderDescending<T>(IEnumerable<T>)

按降序对序列的元素进行排序。
OrderDescending<T>(IEnumerable<T>, IComparer<T>)

按降序对序列的元素进行排序。
Prepend<TSource>(IEnumerable<TSource>, TSource)

将值添加到序列的开头。
Reverse<TSource>(IEnumerable<TSource>)

反转序列中元素的顺序。
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

将序列的每个元素投影到一个新窗体中。
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

通过合并元素的索引，将序列的每个元素投影到一个新窗体中。
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

将序列的每个元素投影到 IEnumerable<T>，并将生成的序列平展为一个序列。
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

将序列的每个元素投影到 IEnumerable<T>，并将生成的序列平展为一个序列。 每个源元素的索引用于该元素的投影形式。
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

将序列的每个元素投影到 IEnumerable<T>，将生成的序列平展为一个序列，并在其中的每个元素上调用结果选择器函数。
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

将序列的每个元素投影到 IEnumerable<T>，将生成的序列平展为一个序列，并在其中的每个元素上调用结果选择器函数。 每个源元素的索引用于该元素的中间投影形式。
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

通过使用其类型的默认相等比较器，确定两个序列是否相等。
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

通过使用指定的 IEqualityComparer<T>，确定两个序列是否相等。
Single<TSource>(IEnumerable<TSource>)

返回序列的唯一元素，如果序列中没有完全有一个元素，则会引发异常。
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回满足指定条件的序列的唯一元素，如果存在多个此类元素，则会引发异常。
SingleOrDefault<TSource>(IEnumerable<TSource>)

返回序列的唯一元素;如果序列为空，则返回默认值;如果序列中有多个元素，此方法将引发异常。
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)

返回序列的唯一元素;如果序列为空，则返回指定的默认值;如果序列中有多个元素，此方法将引发异常。
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

返回满足指定条件的序列的唯一元素;如果没有此类元素，则返回默认值;如果多个元素满足条件，此方法将引发异常。
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

返回满足指定条件的序列的唯一元素;如果没有此类元素，则返回指定的默认值;如果多个元素满足条件，此方法将引发异常。
Skip<TSource>(IEnumerable<TSource>, Int32)

绕过序列中的指定数量的元素，然后返回其余元素。
SkipLast<TSource>(IEnumerable<TSource>, Int32)

返回一个新的可枚举集合，该集合包含 source 的元素，其中省略了源集合的最后一个 count 元素。
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

只要指定条件为 true，即可绕过序列中的元素，然后返回其余元素。
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

只要指定条件为 true，即可绕过序列中的元素，然后返回其余元素。 元素的索引用于谓词函数的逻辑。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

计算通过对输入序列的每个元素调用转换函数获得的 Decimal 值序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

计算通过对输入序列的每个元素调用转换函数获得的 Double 值序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

计算通过对输入序列的每个元素调用转换函数获得的 Int32 值序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

计算通过对输入序列的每个元素调用转换函数获得的 Int64 值序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Decimal 值的序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Double 值的序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Int32 值的序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Int64 值的序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

计算通过对输入序列的每个元素调用转换函数获取的可为 null Single 值的序列的总和。
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

计算通过对输入序列的每个元素调用转换函数获得的 Single 值序列的总和。
Take<TSource>(IEnumerable<TSource>, Int32)

从序列的开头返回指定的连续元素数。
Take<TSource>(IEnumerable<TSource>, Range)

返回序列中连续元素的指定范围。
TakeLast<TSource>(IEnumerable<TSource>, Int32)

返回一个新的可枚举集合，该集合包含来自 source的最后一个 count 元素。
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

只要指定的条件为 true，就从序列中返回元素。
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

只要指定的条件为 true，就从序列中返回元素。 元素的索引用于谓词函数的逻辑。
ToArray<TSource>(IEnumerable<TSource>)

从 IEnumerable<T>创建数组。
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据指定的键选择器函数从 IEnumerable<T> 创建 Dictionary<TKey,TValue>。
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数和键比较器从 IEnumerable<T> 创建 Dictionary<TKey,TValue>。
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

根据指定的键选择器和元素选择器函数从 IEnumerable<T> 创建 Dictionary<TKey,TValue>。
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

根据指定的键选择器函数、比较器和元素选择器函数从 IEnumerable<T> 创建 Dictionary<TKey,TValue>。
ToHashSet<TSource>(IEnumerable<TSource>)

从 IEnumerable<T>创建 HashSet<T>。
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

使用 comparer 比较键从 IEnumerable<T> 创建 HashSet<T>。
ToList<TSource>(IEnumerable<TSource>)

从 IEnumerable<T>创建 List<T>。
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

根据指定的键选择器函数从 IEnumerable<T> 创建 Lookup<TKey,TElement>。
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数和键比较器从 IEnumerable<T> 创建 Lookup<TKey,TElement>。
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

根据指定的键选择器和元素选择器函数从 IEnumerable<T> 创建 Lookup<TKey,TElement>。
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

根据指定的键选择器函数、比较器和元素选择器函数从 IEnumerable<T> 创建 Lookup<TKey,TElement>。
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)

尝试在不强制枚举的情况下确定序列中的元素数。
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

使用默认相等比较器生成两个序列的集并集。
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

使用指定的 IEqualityComparer<T>生成两个序列的集并集。
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)

根据指定的键选择器函数生成两个序列的集并集。
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

根据指定的键选择器函数生成两个序列的集并集。
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

根据谓词筛选值序列。
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

根据谓词筛选值序列。 每个元素的索引都在谓词函数的逻辑中使用。
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

生成包含两个指定序列中的元素的元组序列。
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

生成包含三个指定序列中的元素的元组序列。
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

将指定的函数应用于两个序列的相应元素，从而生成结果序列。
AsParallel(IEnumerable)

启用查询的并行化。
AsParallel<TSource>(IEnumerable<TSource>)

启用查询的并行化。
AsQueryable(IEnumerable)

将 IEnumerable 转换为 IQueryable。
AsQueryable<TElement>(IEnumerable<TElement>)

将泛型 IEnumerable<T> 转换为泛型 IQueryable<T>。
AsMemory(String)

在目标字符串部分创建新的 ReadOnlyMemory<Char>。
AsMemory(String, Index)

基于从指定索引开始的目标字符串的一部分创建新的 ReadOnlyMemory<Char>。
AsMemory(String, Int32)

基于从指定字符位置开始的目标字符串的一部分创建新的 ReadOnlyMemory<Char>。
AsMemory(String, Int32, Int32)

在目标字符串的一部分上创建一个新的 ReadOnlyMemory<Char>，该部分以长度为长度的指定位置开始。
AsMemory(String, Range)

在目标字符串的指定范围内创建新的 ReadOnlyMemory<Char>。
AsSpan(String)

在字符串上创建新的只读范围。
AsSpan(String, Index)

基于目标字符串的一部分从指定位置到字符串末尾创建一个新 ReadOnlySpan<T>。
AsSpan(String, Int32)

从指定位置到字符串末尾，在目标字符串的一部分上创建新的只读范围。
AsSpan(String, Int32, Int32)

从指定数量的字符的指定位置创建一个新的只读跨度，覆盖目标字符串的一部分。
AsSpan(String, Range)

使用范围开始和结束索引在目标字符串的一部分上创建新的 ReadOnlySpan<T>。
IsNormalized(String)

指示指定的字符串是否采用 Unicode 规范化形式 C。
IsNormalized(String, NormalizationForm)

指示字符串是否采用指定的 Unicode 规范化形式。
Normalize(String)

将字符串规范化为 Unicode 规范化形式 C。
Normalize(String, NormalizationForm)

将字符串规范化为指定的 Unicode 规范化形式。
Ancestors<T>(IEnumerable<T>)

返回一个元素集合，其中包含源集合中每个节点的上级。
Ancestors<T>(IEnumerable<T>, XName)

返回一个筛选的元素集合，其中包含源集合中每个节点的上级。 集合中仅包含具有匹配 XName 的元素。
DescendantNodes<T>(IEnumerable<T>)

返回源集合中每个文档和元素的子代节点的集合。
Descendants<T>(IEnumerable<T>)

返回一个元素集合，其中包含源集合中每个元素和文档的子代元素。
Descendants<T>(IEnumerable<T>, XName)

返回一个筛选的元素集合，其中包含源集合中每个元素和文档的子代元素。 集合中仅包含具有匹配 XName 的元素。
Elements<T>(IEnumerable<T>)

返回源集合中每个元素和文档的子元素的集合。
Elements<T>(IEnumerable<T>, XName)

返回源集合中每个元素和文档的子元素的筛选集合。 集合中仅包含具有匹配 XName 的元素。
InDocumentOrder<T>(IEnumerable<T>)

返回一个节点集合，其中包含源集合中的所有节点，按文档顺序排序。
Nodes<T>(IEnumerable<T>)

返回源集合中每个文档和元素的子节点的集合。
Remove<T>(IEnumerable<T>)

从源集合的父节点中删除每个节点。

适用于

线程安全性

此类型是线程安全的。

另请参阅