通过

MemoryExtensions 类

  • 参考

定义

命名空间:
System
程序集:
System.Memory.dll
程序集:
netstandard.dll
包:
System.Memory v4.5.5
Source:
MemoryExtensions.cs
Source:
MemoryExtensions.cs
Source:
MemoryExtensions.cs

提供内存相关和跨度相关的类型的扩展方法，例如 Memory<T>、ReadOnlyMemory<T>、Span<T>和 ReadOnlySpan<T>。

public ref class MemoryExtensions abstract sealed
public static class MemoryExtensions
type MemoryExtensions = class
Public Module MemoryExtensions
继承
Object
MemoryExtensions

方法

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>。
AsMemory<T>(ArraySegment<T>)

在目标数组段的部分上创建新的内存区域。
AsMemory<T>(ArraySegment<T>, Int32)

在目标数组段的一部分上创建一个新的内存区域，从指定位置开始到段的末尾。
AsMemory<T>(ArraySegment<T>, Int32, Int32)

在目标数组段部分上创建一个新的内存区域，该部分从具有指定长度的指定位置开始。
AsMemory<T>(T[])

在目标数组上创建新的内存区域。
AsMemory<T>(T[], Index)

在从指定索引开始到数组末尾的目标数组部分创建一个新的内存区域。
AsMemory<T>(T[], Int32)

在目标数组的一部分上创建一个新的内存区域，从指定位置开始到数组的末尾。
AsMemory<T>(T[], Int32, Int32)

基于目标数组部分创建一个新的内存区域，该部分从指定长度的指定位置开始。
AsMemory<T>(T[], Range)

在目标数组的一部分上创建一个新的内存区域，该区域从范围的非独占开始索引开始，以该范围的独占结束索引结束。
AsSpan(String)

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

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

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

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

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

在目标数组段上创建新的跨度。
AsSpan<T>(ArraySegment<T>, Index)

在目标数组段的一部分上创建一个新的跨度，该范围从指定的索引开始，并在段的末尾结束。
AsSpan<T>(ArraySegment<T>, Int32)

在目标数组段的一部分（从指定位置到段末尾）上创建新跨度。
AsSpan<T>(ArraySegment<T>, Int32, Int32)

从指定长度的指定位置创建一个新范围，覆盖目标数组段的一部分。
AsSpan<T>(ArraySegment<T>, Range)

使用范围开始和结束索引在目标数组段的一部分上创建新范围。
AsSpan<T>(T[])

在目标数组上创建新范围。
AsSpan<T>(T[], Index)

在 Index 值定义的目标数组部分上创建新范围。
AsSpan<T>(T[], Int32)

在目标数组的一部分上创建新范围，该范围从指定位置开始到数组末尾。
AsSpan<T>(T[], Int32, Int32)

为指定长度从指定位置开始的目标数组部分创建一个新的跨度。
AsSpan<T>(T[], Range)

在由 Range 值定义的目标数组的一部分上创建新范围。
BinarySearch<T,TComparable>(ReadOnlySpan<T>, TComparable)

使用指定的 TComparable 泛型类型搜索整个排序 ReadOnlySpan<T> 值。
BinarySearch<T,TComparable>(Span<T>, TComparable)

使用指定的 TComparable 泛型类型搜索整个排序 Span<T> 值。
BinarySearch<T,TComparer>(ReadOnlySpan<T>, T, TComparer)

使用指定的 TComparer 泛型类型搜索整个排序 ReadOnlySpan<T> 指定值。
BinarySearch<T,TComparer>(Span<T>, T, TComparer)

使用指定的 TComparer 泛型类型搜索整个排序 Span<T> 指定值。
BinarySearch<T>(ReadOnlySpan<T>, IComparable<T>)

使用指定的 IComparable<T> 泛型接口搜索整个排序 ReadOnlySpan<T> 的值。
BinarySearch<T>(Span<T>, IComparable<T>)

使用指定的 IComparable<T> 泛型接口搜索整个排序 Span<T> 的值。
CommonPrefixLength<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

查找在 span 和 other之间共享的任何常见前缀的长度。
CommonPrefixLength<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>)

确定在 span 和 other之间共享的任何常见前缀的长度。
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>)

查找在 span 和 other之间共享的任何常见前缀的长度。
CommonPrefixLength<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)

查找在 span 和 other之间共享的任何常见前缀的长度。
CompareTo(ReadOnlySpan<Char>, ReadOnlySpan<Char>, StringComparison)

使用指定的字符串比较将一个字符范围与另一个字符范围进行比较，并返回一个整数，该整数指示它们在排序顺序中的相对位置。
Contains(ReadOnlySpan<Char>, ReadOnlySpan<Char>, StringComparison)

指示指定的值是否在只读字符范围内发生。
Contains<T>(ReadOnlySpan<T>, T)

指示是否在只读跨度中找到指定的值。 使用 IEquatable{T} 比较值。等于（T）。
Contains<T>(Span<T>, T)

指示是否在范围中找到指定的值。 使用 IEquatable{T} 比较值。等于（T）。
ContainsAny(ReadOnlySpan<Char>, SearchValues<String>)

搜索任何指定子字符串 values的任何匹配项。
ContainsAny(Span<Char>, SearchValues<String>)

搜索任何指定子字符串 values的任何匹配项。
ContainsAny<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

搜索任何指定的 values的匹配项。
ContainsAny<T>(ReadOnlySpan<T>, SearchValues<T>)

搜索任何指定的 values的匹配项。
ContainsAny<T>(ReadOnlySpan<T>, T, T)

搜索 value0 或 value1。
ContainsAny<T>(ReadOnlySpan<T>, T, T, T)

搜索 value0、value1或 value2。
ContainsAny<T>(Span<T>, ReadOnlySpan<T>)

搜索任何指定的 values 的匹配项，并返回 true（如果找到）。 如果未找到，则返回 false。
ContainsAny<T>(Span<T>, SearchValues<T>)

搜索任何指定的 values 的匹配项，并返回 true（如果找到）。 如果未找到，则返回 false。
ContainsAny<T>(Span<T>, T, T)

搜索出现 value0 或 value1，如果找到，则返回 true。 如果未找到，则返回 false。
ContainsAny<T>(Span<T>, T, T, T)

搜索 value0、value1或 value2的出现，如果找到，则返回 true。 如果未找到，则返回 false。
ContainsAnyExcept<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

搜索指定 values以外的任何值。
ContainsAnyExcept<T>(ReadOnlySpan<T>, SearchValues<T>)

搜索指定 values以外的任何值。
ContainsAnyExcept<T>(ReadOnlySpan<T>, T)

搜索指定 value以外的任何值。
ContainsAnyExcept<T>(ReadOnlySpan<T>, T, T)

搜索除 value0 或 value1以外的任何值。
ContainsAnyExcept<T>(ReadOnlySpan<T>, T, T, T)

搜索除 value0、value1或 value2以外的任何值。
ContainsAnyExcept<T>(Span<T>, ReadOnlySpan<T>)

搜索指定 values以外的任何值。
ContainsAnyExcept<T>(Span<T>, SearchValues<T>)

搜索指定 values以外的任何值。
ContainsAnyExcept<T>(Span<T>, T)

搜索指定 value以外的任何值。
ContainsAnyExcept<T>(Span<T>, T, T)

搜索除 value0 或 value1以外的任何值。
ContainsAnyExcept<T>(Span<T>, T, T, T)

搜索除 value0、value1或 value2以外的任何值。
ContainsAnyExceptInRange<T>(ReadOnlySpan<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围之外的任何值。
ContainsAnyExceptInRange<T>(Span<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围之外的任何值。
ContainsAnyInRange<T>(ReadOnlySpan<T>, T, T)

在 lowInclusive 和 highInclusive（含）范围内搜索任何值。
ContainsAnyInRange<T>(Span<T>, T, T)

搜索 lowInclusive 和 highInclusive、非独占范围内的任何值，如果找到，则返回 true。 如果未找到，则返回 false。
CopyTo<T>(T[], Memory<T>)

将数组的内容复制到内存区域中。
CopyTo<T>(T[], Span<T>)

将数组的内容复制到范围中。
Count<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

计算 span中发生的 value 次数。
Count<T>(ReadOnlySpan<T>, T)

计算指定 value 在 span中发生的次数。
Count<T>(Span<T>, ReadOnlySpan<T>)

计算指定 value 在 span中发生的次数。
Count<T>(Span<T>, T)

计算指定 value 在 span中发生的次数。
EndsWith(ReadOnlySpan<Char>, ReadOnlySpan<Char>, StringComparison)

使用指定的 comparisonType 选项进行比较时，确定 span 末尾是否与指定的 value 匹配。
EndsWith<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

确定指定的序列是否出现在只读范围末尾。
EndsWith<T>(ReadOnlySpan<T>, T)

确定指定的值是否出现在范围末尾。
EndsWith<T>(Span<T>, ReadOnlySpan<T>)

确定指定的序列是否出现在范围末尾。
EnumerateLines(ReadOnlySpan<Char>)

返回提供的跨度上的行的枚举。
EnumerateLines(Span<Char>)

返回提供的跨度上的行的枚举。
EnumerateRunes(ReadOnlySpan<Char>)

从提供的只读范围返回 Rune 的枚举。
EnumerateRunes(Span<Char>)

从提供的跨度返回 Rune 的枚举。
Equals(ReadOnlySpan<Char>, ReadOnlySpan<Char>, StringComparison)

确定使用指定的 comparisonType 选项进行比较时，此 span 和指定的 other 范围是否具有相同的字符。
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, StringComparison)

报告当前 span中指定 value 的第一个匹配项的从零开始的索引。
IndexOf<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

搜索指定的序列并返回其第一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
IndexOf<T>(ReadOnlySpan<T>, T)

搜索指定的值并返回其第一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
IndexOf<T>(Span<T>, ReadOnlySpan<T>)

搜索指定的序列并返回其第一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
IndexOf<T>(Span<T>, T)

搜索指定的值并返回其第一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
IndexOfAny(ReadOnlySpan<Char>, SearchValues<String>)

搜索任何指定子字符串值的第一个索引。
IndexOfAny(Span<Char>, SearchValues<String>)

搜索任何指定子字符串值的第一个索引。
IndexOfAny<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

使用逻辑 OR 运算符搜索任何指定值的第一个索引，类似于多次调用 IndexOf。
IndexOfAny<T>(ReadOnlySpan<T>, SearchValues<T>)

搜索任何指定值的第一个索引。
IndexOfAny<T>(ReadOnlySpan<T>, T, T)

使用逻辑 OR 运算符搜索任何指定值的第一个索引，类似于多次调用 IndexOf。
IndexOfAny<T>(ReadOnlySpan<T>, T, T, T)

使用逻辑 OR 运算符搜索任何指定值的第一个索引，类似于多次调用 IndexOf。
IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

使用逻辑 OR 运算符搜索任何指定值的第一个索引，类似于多次调用 IndexOf。
IndexOfAny<T>(Span<T>, SearchValues<T>)

搜索任何指定值的第一个索引。
IndexOfAny<T>(Span<T>, T, T)

使用逻辑 OR 运算符搜索任何指定值的第一个索引，类似于多次调用 IndexOf。
IndexOfAny<T>(Span<T>, T, T, T)

使用逻辑 OR 运算符搜索任何指定值的第一个索引，类似于多次调用 IndexOf。
IndexOfAnyExcept<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

搜索指定 values以外的任何值的第一个索引。
IndexOfAnyExcept<T>(ReadOnlySpan<T>, SearchValues<T>)

搜索指定 values以外的任何值的第一个索引。
IndexOfAnyExcept<T>(ReadOnlySpan<T>, T)

搜索指定 value以外的任何值的第一个索引。
IndexOfAnyExcept<T>(ReadOnlySpan<T>, T, T)

搜索指定 value0 或 value1以外的任何值的第一个索引。
IndexOfAnyExcept<T>(ReadOnlySpan<T>, T, T, T)

搜索指定 value0、value1或 value2以外的任何值的第一个索引。
IndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)

搜索指定 values以外的任何值的第一个索引。
IndexOfAnyExcept<T>(Span<T>, SearchValues<T>)

搜索指定 values以外的任何值的第一个索引。
IndexOfAnyExcept<T>(Span<T>, T)

搜索指定 value以外的任何值的第一个索引。
IndexOfAnyExcept<T>(Span<T>, T, T)

搜索指定 value0 或 value1以外的任何值的第一个索引。
IndexOfAnyExcept<T>(Span<T>, T, T, T)

搜索指定 value0、value1或 value2以外的任何值的第一个索引。
IndexOfAnyExceptInRange<T>(ReadOnlySpan<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围之外的任何值的第一个索引。
IndexOfAnyExceptInRange<T>(Span<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围之外的任何值的第一个索引。
IndexOfAnyInRange<T>(ReadOnlySpan<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围内任何值的第一个索引。
IndexOfAnyInRange<T>(Span<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围内任何值的第一个索引。
IsWhiteSpace(ReadOnlySpan<Char>)

指示指定的范围是否仅包含空格字符。
LastIndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, StringComparison)

报告当前 span中指定 value 最后一个匹配项的从零开始的索引。
LastIndexOf<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

搜索指定的序列并返回其最后一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
LastIndexOf<T>(ReadOnlySpan<T>, T)

搜索指定的值并返回其最后一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
LastIndexOf<T>(Span<T>, ReadOnlySpan<T>)

搜索指定的序列并返回其最后一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
LastIndexOf<T>(Span<T>, T)

搜索指定的值并返回其最后一个匹配项的索引。 使用 IEquatable{T} 比较值。等于（T）。
LastIndexOfAny<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

使用逻辑 OR 运算符多次搜索与调用 LastIndexOf 类似的任何指定值的最后一个索引。
LastIndexOfAny<T>(ReadOnlySpan<T>, SearchValues<T>)

搜索任何指定值的最后一个索引。
LastIndexOfAny<T>(ReadOnlySpan<T>, T, T)

使用逻辑 OR 运算符多次搜索与调用 LastIndexOf 类似的任何指定值的最后一个索引。
LastIndexOfAny<T>(ReadOnlySpan<T>, T, T, T)

使用逻辑 OR 运算符多次搜索与调用 LastIndexOf 类似的任何指定值的最后一个索引。
LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

使用逻辑 OR 运算符多次搜索与调用 LastIndexOf 类似的任何指定值的最后一个索引。
LastIndexOfAny<T>(Span<T>, SearchValues<T>)

搜索任何指定值的最后一个索引。
LastIndexOfAny<T>(Span<T>, T, T)

使用逻辑 OR 运算符多次搜索与调用 LastIndexOf 类似的任何指定值的最后一个索引。
LastIndexOfAny<T>(Span<T>, T, T, T)

使用逻辑 OR 运算符多次搜索与调用 LastIndexOf 类似的任何指定值的最后一个索引。
LastIndexOfAnyExcept<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

搜索指定 values以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(ReadOnlySpan<T>, SearchValues<T>)

搜索指定 values以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(ReadOnlySpan<T>, T)

搜索指定 value以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(ReadOnlySpan<T>, T, T)

搜索指定 value0 或 value1以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(ReadOnlySpan<T>, T, T, T)

搜索指定 value0、value1或 value2以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(Span<T>, ReadOnlySpan<T>)

搜索指定 values以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(Span<T>, SearchValues<T>)

搜索指定 values以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(Span<T>, T)

搜索指定 value以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(Span<T>, T, T)

搜索指定 value0 或 value1以外的任何值的最后一个索引。
LastIndexOfAnyExcept<T>(Span<T>, T, T, T)

搜索指定 value0、value1或 value2以外的任何值的最后一个索引。
LastIndexOfAnyExceptInRange<T>(ReadOnlySpan<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围之外的任何值的最后一个索引。
LastIndexOfAnyExceptInRange<T>(Span<T>, T, T)

搜索 lowInclusive 和 highInclusive（含）范围之外的任何值的最后一个索引。
LastIndexOfAnyInRange<T>(ReadOnlySpan<T>, T, T)

在 lowInclusive 和 highInclusive（含）范围内搜索任何值的最后一个索引。
LastIndexOfAnyInRange<T>(Span<T>, T, T)

在 lowInclusive 和 highInclusive（含）范围内搜索任何值的最后一个索引。
Overlaps<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

确定两个只读序列是否在内存中重叠。
Overlaps<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, Int32)

确定两个只读序列是否在内存中重叠，并输出元素偏移量。
Overlaps<T>(Span<T>, ReadOnlySpan<T>)

确定范围和只读跨度是否在内存中重叠。
Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32)

确定范围和只读跨度是否在内存中重叠，并输出元素偏移量。
Replace<T>(ReadOnlySpan<T>, Span<T>, T, T)

将 source 复制到 destination，并将 oldValue 的所有匹配项替换为 newValue。
Replace<T>(Span<T>, T, T)

将 oldValue 的所有匹配项替换为 newValue。
Reverse<T>(Span<T>)

反转整个跨度中的元素序列。
SequenceCompareTo<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

通过使用 IComparable{T} 比较两个只读序列的相对顺序。CompareTo（T）。
SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>)

通过使用 IComparable{T} 比较元素来确定范围和只读范围的相对顺序。CompareTo（T）。
SequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

通过使用 IEquatable{T} 比较元素，确定两个只读序列是否相等。等于（T）。
SequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>)

通过使用 IEqualityComparer<T>比较元素来确定两个序列是否相等。
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)

通过使用 IEquatable{T} 比较元素，确定范围和只读跨度是否相等。等于（T）。
SequenceEqual<T>(Span<T>, ReadOnlySpan<T>, IEqualityComparer<T>)

通过使用 IEqualityComparer<T>比较元素来确定两个序列是否相等。
Sort<T,TComparer>(Span<T>, TComparer)

使用 TComparer对整个 Span<T> 中的元素进行排序。
Sort<T>(Span<T>)

使用 Span<T>的每个元素的 IComparable<T> 实现对整个 Span<T> 中的元素进行排序。
Sort<T>(Span<T>, Comparison<T>)

使用指定的 Comparison<T>对整个 Span<T> 中的元素进行排序。
Sort<TKey,TValue,TComparer>(Span<TKey>, Span<TValue>, TComparer)

使用指定的比较器，根据第一个 Span<T> 中的键对范围（一个包含键，另一个包含相应项）进行排序。
Sort<TKey,TValue>(Span<TKey>, Span<TValue>)

使用每个键的 IComparable<T> 实现，根据第一个 Span<T> 中的键对范围（一个包含键，另一个包含相应项）进行排序。
Sort<TKey,TValue>(Span<TKey>, Span<TValue>, Comparison<TKey>)

根据使用指定比较的第一个 Span<T> 中的键对范围（一个包含键，另一个包含相应项）进行排序。
Split(ReadOnlySpan<Char>, Span<Range>, Char, StringSplitOptions)

分析指定 separator的源 ReadOnlySpan<T>，用表示分隔符之间的区域 Range 实例填充 destination 范围。
Split(ReadOnlySpan<Char>, Span<Range>, ReadOnlySpan<Char>, StringSplitOptions)

分析指定 separator的源 ReadOnlySpan<T>，用表示分隔符之间的区域 Range 实例填充 destination 范围。
Split<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

提供内存相关和跨度相关的类型的扩展方法，例如 Memory<T>、ReadOnlyMemory<T>、Span<T>和 ReadOnlySpan<T>。
Split<T>(ReadOnlySpan<T>, T)

提供内存相关和跨度相关的类型的扩展方法，例如 Memory<T>、ReadOnlyMemory<T>、Span<T>和 ReadOnlySpan<T>。
SplitAny(ReadOnlySpan<Char>, Span<Range>, ReadOnlySpan<Char>, StringSplitOptions)

分析指定 separators之一的源 ReadOnlySpan<T>，使用表示分隔符之间的区域 Range 实例填充 destination 范围。
SplitAny(ReadOnlySpan<Char>, Span<Range>, ReadOnlySpan<String>, StringSplitOptions)

分析指定 separators之一的源 ReadOnlySpan<T>，使用表示分隔符之间的区域 Range 实例填充 destination 范围。
SplitAny<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

提供内存相关和跨度相关的类型的扩展方法，例如 Memory<T>、ReadOnlyMemory<T>、Span<T>和 ReadOnlySpan<T>。
SplitAny<T>(ReadOnlySpan<T>, SearchValues<T>)

提供内存相关和跨度相关的类型的扩展方法，例如 Memory<T>、ReadOnlyMemory<T>、Span<T>和 ReadOnlySpan<T>。
StartsWith(ReadOnlySpan<Char>, ReadOnlySpan<Char>, StringComparison)

使用指定的 StringComparison 值进行比较时，确定只读字符范围是否以指定值开头。
StartsWith<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

确定指定的序列是否出现在只读范围开始时。
StartsWith<T>(ReadOnlySpan<T>, T)

确定指定值是否出现在范围开头。
StartsWith<T>(Span<T>, ReadOnlySpan<T>)

确定指定的序列是否出现在范围开头。
ToLower(ReadOnlySpan<Char>, Span<Char>, CultureInfo)

使用指定区域性的大小写规则将源范围中的字符复制到目标中，将每个字符转换为小写。
ToLowerInvariant(ReadOnlySpan<Char>, Span<Char>)

使用固定区域性的大小写规则将源范围中的字符复制到目标，将每个字符转换为小写。
ToUpper(ReadOnlySpan<Char>, Span<Char>, CultureInfo)

使用指定区域性的大小写规则将源范围中的字符复制到目标，将每个字符转换为大写。
ToUpperInvariant(ReadOnlySpan<Char>, Span<Char>)

将源范围中的字符复制到目标，使用固定区域性的大小写规则将每个字符转换为大写。
Trim(Memory<Char>)

从字符内存区域中删除所有前导和尾随空格字符。
Trim(ReadOnlyMemory<Char>)

从只读字符内存区域中删除所有前导和尾随空格字符。
Trim(ReadOnlySpan<Char>)

从只读字符范围中删除所有前导和尾随空格字符。
Trim(ReadOnlySpan<Char>, Char)

从只读字符范围中删除指定字符的所有前导和尾随匹配项。
Trim(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

从只读字符范围中删除在只读范围中指定的一组字符的所有前导和尾随匹配项。
Trim(Span<Char>)

从字符范围中删除所有前导和尾随空格字符。
Trim<T>(Memory<T>, ReadOnlySpan<T>)

从内存区域删除在只读跨度中指定的一组元素的所有前导和尾随匹配项。
Trim<T>(Memory<T>, T)

从内存区域中删除指定元素的所有前导和尾随匹配项。
Trim<T>(ReadOnlyMemory<T>, ReadOnlySpan<T>)

从只读内存区域中删除在只读跨度中指定的一组元素的所有前导和尾随匹配项。
Trim<T>(ReadOnlyMemory<T>, T)

从只读内存区域中删除指定元素的所有前导和尾随匹配项。
Trim<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

从只读范围中移除一组在只读范围中指定的元素的所有前导和尾随匹配项。
Trim<T>(ReadOnlySpan<T>, T)

从只读跨度中删除指定元素的所有前导和尾随匹配项。
Trim<T>(Span<T>, ReadOnlySpan<T>)

从范围中移除在只读跨度中指定的一组元素的所有前导和尾随匹配项。
Trim<T>(Span<T>, T)

从范围中删除指定元素的所有前导和尾随匹配项。
TrimEnd(Memory<Char>)

从字符内存区域中删除所有尾随空格字符。
TrimEnd(ReadOnlyMemory<Char>)

从只读字符内存区域中删除所有尾随空格字符。
TrimEnd(ReadOnlySpan<Char>)

从只读字符范围中删除所有尾随空格字符。
TrimEnd(ReadOnlySpan<Char>, Char)

从只读范围中删除指定字符的所有尾随匹配项。
TrimEnd(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

从只读字符范围中删除在只读范围中指定的一组字符的所有尾随匹配项。
TrimEnd(Span<Char>)

从字符范围中删除所有尾随空格字符。
TrimEnd<T>(Memory<T>, ReadOnlySpan<T>)

从内存区域中删除在只读跨度中指定的一组元素的所有尾随匹配项。
TrimEnd<T>(Memory<T>, T)

从字符内存区域中删除指定元素的所有尾随匹配项。
TrimEnd<T>(ReadOnlyMemory<T>, ReadOnlySpan<T>)

从只读内存区域中删除在只读跨度中指定的一组元素的所有尾随匹配项。
TrimEnd<T>(ReadOnlyMemory<T>, T)

从只读内存区域中删除指定元素的所有尾随匹配项。
TrimEnd<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

从只读范围中删除在只读范围中指定的一组元素的所有尾随匹配项。
TrimEnd<T>(ReadOnlySpan<T>, T)

从只读范围中删除指定元素的所有尾随匹配项。
TrimEnd<T>(Span<T>, ReadOnlySpan<T>)

从范围中移除在只读跨度中指定的一组元素的所有尾随匹配项。
TrimEnd<T>(Span<T>, T)

从范围中删除指定元素的所有尾随匹配项。
TrimStart(Memory<Char>)

从内存区域中删除所有前导空格字符。
TrimStart(ReadOnlyMemory<Char>)

从只读内存区域中删除所有前导空格字符。
TrimStart(ReadOnlySpan<Char>)

从只读范围中删除所有前导空格字符。
TrimStart(ReadOnlySpan<Char>, Char)

从范围中删除指定字符的所有前导匹配项。
TrimStart(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

从范围中删除在只读跨度中指定的一组字符的所有前导匹配项。
TrimStart(Span<Char>)

从范围中删除所有前导空格字符。
TrimStart<T>(Memory<T>, ReadOnlySpan<T>)

从内存区域中删除在只读跨度中指定的一组元素的所有前导事件。
TrimStart<T>(Memory<T>, T)

从内存区域中删除指定元素的所有前导事件。
TrimStart<T>(ReadOnlyMemory<T>, ReadOnlySpan<T>)

从内存区域中删除在只读跨度中指定的一组元素的所有前导事件。
TrimStart<T>(ReadOnlyMemory<T>, T)

从内存区域中删除指定元素的所有前导事件。
TrimStart<T>(ReadOnlySpan<T>, ReadOnlySpan<T>)

从范围中移除在只读跨度中指定的一组元素的所有前导事件。
TrimStart<T>(ReadOnlySpan<T>, T)

从范围中删除指定元素的所有前导匹配项。
TrimStart<T>(Span<T>, ReadOnlySpan<T>)

从范围中移除在只读跨度中指定的一组元素的所有前导事件。
TrimStart<T>(Span<T>, T)

从范围中删除指定元素的所有前导匹配项。
TryWrite(Span<Char>, IFormatProvider, CompositeFormat, Int32, Object[])

将 CompositeFormat 字符串写入字符范围，用相应参数的字符串表示形式替换格式项或项。
TryWrite(Span<Char>, IFormatProvider, CompositeFormat, Int32, ReadOnlySpan<Object>)

将 CompositeFormat 字符串写入字符范围，用相应参数的字符串表示形式替换格式项或项。
TryWrite(Span<Char>, IFormatProvider, MemoryExtensions+TryWriteInterpolatedStringHandler, Int32)

将指定的内插字符串写入字符范围。
TryWrite(Span<Char>, MemoryExtensions+TryWriteInterpolatedStringHandler, Int32)

将指定的内插字符串写入字符范围。
TryWrite<TArg0,TArg1,TArg2>(Span<Char>, IFormatProvider, CompositeFormat, Int32, TArg0, TArg1, TArg2)

将 CompositeFormat 字符串写入字符范围，用相应参数的字符串表示形式替换格式项或项。
TryWrite<TArg0,TArg1>(Span<Char>, IFormatProvider, CompositeFormat, Int32, TArg0, TArg1)

将 CompositeFormat 字符串写入字符范围，用相应参数的字符串表示形式替换格式项或项。
TryWrite<TArg0>(Span<Char>, IFormatProvider, CompositeFormat, Int32, TArg0)

将 CompositeFormat 字符串写入字符范围，用相应参数的字符串表示形式替换格式项或项。

适用于