Span<T> Span<T> Span<T> Span<T> Struct

定義

任意のメモリの隣接した領域をタイプセーフかつメモリセーフで表します。Provides a type- and memory-safe representation of a contiguous region of arbitrary memory.

generic <typename T>
public value class Span
public struct Span<T>
type Span<'T> = struct
Public Structure Span(Of T)

型パラメーター

T

Span<T>内の項目の型。The type of items in the Span<T>.

継承

注釈

Span<T>はマネージド ヒープではなく、スタックに割り当てられるref 構造体です。Span<T> is a ref struct that is allocated on the stack rather than on the managed heap. ref 構造体は、ボックス化できない、Objectdynamicまたは任意のインターフェイス型の変数に割り当てられない、参照型のフィールドにできない、awaityieldをまたいで使用できないなど、マネージド ヒープに昇格しないようにするためのいくつかの制限があります。Ref struct types have a number of restrictions to ensure that they cannot be promoted to the managed heap, including that they can't be boxed, they can't be assigned to variables of type Object, dynamic or to any interface type, they can't be fields in a reference type, and they can't be used across await and yield boundaries. さらに、Equals(Object)GetHashCodeの2つのメソッドを呼び出すと、NotSupportedExceptionをスローします。In addition, calls to two methods, Equals(Object) and GetHashCode, throw a NotSupportedException.

重要

Span<T>はスタック専用の型であるため、ヒープ上でバッファーへの参照を格納する必要のある、多くのシナリオには適していません。Because it is a stack-only type, Span<T> is unsuitable for many scenarios that require storing references to buffers on the heap. たとえば、非同期メソッドの呼び出しを行うルーチンなどが当てはまります。This is true, for example, of routines that make asynchronous method calls. このようなシナリオでは、補完的なSystem.Memory<T>System.ReadOnlyMemory<T>型を使用できます。For such scenarios, you can use the complementary System.Memory<T> and System.ReadOnlyMemory<T> types.

不変、または読み取り専用の構造を表すスパンの場合、System.ReadOnlySpan<T>を使用してください。For spans that represent immutable or read-only structures, use System.ReadOnlySpan<T>.

Span<T> とメモリSpan<T> and memory

Span<T>は任意のメモリの連続した領域を表します。A Span<T> represents a contiguous region of arbitrary memory. Span<T>インスタンスは、配列の要素または配列の一部を保持するためによく使用されます。A Span<T> instance is often used to hold the elements of an array or a portion of an array. ただし、配列とは異なり、Span<T>インスタンスは、マネージド メモリ、ネイティブ メモリ、スタック上で管理されたメモリを指すことができます。Unlike an array, however, a Span<T> instance can point to managed memory, native memory, or memory managed on the stack. 次の例では、配列からSpan<Byte>を作成します。The following example creates a Span<Byte> from an array:

// Create a span over an array.
var array = new byte[100];
var arraySpan = new Span<byte>(array);

byte data = 0;
for (int ctr = 0; ctr < arraySpan.Length; ctr++)
    arraySpan[ctr] = data++;

int arraySum = 0;
foreach (var value in array)
    arraySum += value;

Console.WriteLine($"The sum is {arraySum}");
// Output:  The sum is 4950

次の例では、ネイティブ メモリの 100 バイトからSpan<Byte>を作成します。The following example creates a Span<Byte> from 100 bytes of native memory:

// Create a span from native memory.
var native = Marshal.AllocHGlobal(100);
Span<byte> nativeSpan;
unsafe
{
    nativeSpan = new Span<byte>(native.ToPointer(), 100);
}
byte data = 0;
for (int ctr = 0; ctr < nativeSpan.Length; ctr++)
    nativeSpan[ctr] = data++;

int nativeSum = 0;
foreach (var value in nativeSpan)
    nativeSum += value;

Console.WriteLine($"The sum is {nativeSum}");
Marshal.FreeHGlobal(native);
// Output:  The sum is 4950

次の例では、 C#のstackallocキーワードを用いて、スタック上に 100 バイトのメモリを割り当てます。The following example uses the C# stackalloc keyword to allocate 100 bytes of memory on the stack:

// Create a span on the stack.
byte data = 0;
Span<byte> stackSpan = stackalloc byte[100];
for (int ctr = 0; ctr < stackSpan.Length; ctr++)
    stackSpan[ctr] = data++;

int stackSum = 0;
foreach (var value in stackSpan)
    stackSum += value;

Console.WriteLine($"The sum is {stackSum}");
// Output:  The sum is 4950

Span<T>は、メモリ上の任意のブロックを抽象化したものであるため、Span<T>クラスのメソッドとSpan<T>をパラメーターに持つメソッドは、カプセル化するメモリの種類に関係なく、任意のSpan<T>オブジェクトで動作します。Because Span<T> is an abstraction over an arbitrary block of memory, methods of the Span<T> class and methods with Span<T> parameters operate on any Span<T> object regardless of the kind of memory it encapsulates. たとえば、スパンを初期化して、その要素を合計するコードの各セクションは、次の例のように単一の初期化メソッドと計算メソッドに変更できます。For example, each of the separate sections of code that initialize the span and calculate the sum of its elements can be changed into single initialization and calculation methods, as the following example illustrates:

public static void WorkWithSpans()
{
    // Create a span over an array.
    var array = new byte[100];
    var arraySpan = new Span<byte>(array);
    
    InitializeSpan(arraySpan);
    Console.WriteLine($"The sum is {ComputeSum(arraySpan):N0}");

    // Create an array from native memory.
    var native = Marshal.AllocHGlobal(100);
    Span<byte> nativeSpan;
    unsafe
    {
        nativeSpan = new Span<byte>(native.ToPointer(), 100);
    }

    InitializeSpan(nativeSpan);
    Console.WriteLine($"The sum is {ComputeSum(nativeSpan):N0}");
    
    Marshal.FreeHGlobal(native);

    // Create a span on the stack.
    Span<byte> stackSpan = stackalloc byte[100];

    InitializeSpan(stackSpan);
    Console.WriteLine($"The sum is {ComputeSum(stackSpan):N0}");
}

public static void InitializeSpan(Span<byte> span)
{
    byte value = 0;
    for (int ctr = 0; ctr < span.Length; ctr++)
        span[ctr] = value++;
}

public static int ComputeSum(Span<byte> span)
{
    int sum = 0;
    foreach (var value in span)
        sum += value;

    return sum;
}
// The example displays the following output:
//    The sum is 4,950
//    The sum is 4,950
//    The sum is 4,950

Span<T> と配列Span<T> and arrays

Span<T> とメモリセクションの例のように、配列をラップした場合、Span<T>は配列全体をラップすることができます。 スライスをサポートするため、Span<T>は配列内の連続する範囲を指すこともできます。When it wraps an array, Span<T> can wrap an entire array, as it did in the examples in the Span<T> and memory section. スライスがサポートされるため、@no__t 0 は配列内の連続する範囲を指すこともできます。Because it supports slicing, Span<T> can also point to any contiguous range within the array.

次の例では、10 要素ある整数配列の中間 5 つの要素のスライスを作成します。The following example creates a slice of the middle five elements of a 10-element integer array. コードがスライス内の各整数の値を 2 倍することに注意してください。Note that the code doubles the values of each integer in the slice. 出力のとおり、スパンで加えられた変更は、配列の値に反映されます。As the output shows, the changes made by the span are reflected in the values of the array.

using System;

namespace span
{
    class Program
    {
        static void Main(string[] args)
        {
            var array = new int[] { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
            var slice = new Span<int>(array, 2, 5);
            for (int ctr = 0; ctr < slice.Length; ctr++)
               slice[ctr] *= 2;
            
            // Examine the original array values.
            foreach (var value in array)
                Console.Write($"{value}  ");
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//      2  4  12  16  20  24  28  16  18  20

Span<T> とスライスSpan<T> and slices

Span<T>には、現在のスパンより、指定したインデックスから始まるスライスを形成するSliceメソッドの 2 つのオーバー ロードが含まれています。Span<T> includes two overloads of the Slice method that form a slice out of the current span that starts at a specified index. これにより、Span<T>のデータを、パフォーマンスの影響を最小限にしながら、データ処理パイプラインの一部で必要に応じて処理できる、一連の論理的なまとまりとして扱うことができます。This makes it possible to treat the data in a Span<T> as a set of logical chunks that can be processed as needed by portions of a data processing pipeline with minimal performance impact. たとえば、最新のサーバー プロトコルは多くの場合、テキスト ベースであるため、文字列と部分文字列の操作は特に重要です。For example, since modern server protocols are often text-based, manipulation of strings and substrings is particularly important. Stringクラスの場合、部分文字列の抽出に使う主要なメソッドはSubstringです。In the String class, the major method for extracting substrings is Substring. 広範な文字列操作に依存するデータ パイプラインは、次のように、いくつかのパフォーマンスの低下を招きます。For data pipelines that rely on extensive string manipulation, its use offers some performance penalties, since it:

  1. 部分文字列を格納する新しい文字列を作成します。Creates a new string to hold the substring.

  2. 元の文字列の文字のサブセットを新しい文字列にコピーします。Copies a subset of the characters from the original string to the new string.

次の例に示すように、この割り当てとコピー操作は、Span<T>またはReadOnlySpan<T>いずれかを使用して削除できます。This allocation and copy operation can be eliminated by using either Span<T> or ReadOnlySpan<T>, as the following example shows:

using System;

class Program
{
    static void Main()
    {
        string contentLength = "Content-Length: 132";
        var length = GetContentLength(contentLength.ToCharArray());	
        Console.WriteLine($"Content length: {length}"); 
    }

    private static int GetContentLength(ReadOnlySpan<char> span)
    {
        var slice = span.Slice(16);
        return int.Parse(slice);	
    }
}
// Output:
//      Content length: 132

コンストラクター

Span<T>(T[]) Span<T>(T[]) Span<T>(T[]) Span<T>(T[])

指定された配列全体で新しい Span<T> オブジェクトを作成します。Creates a new Span<T> object over the entirety of a specified array.

Span<T>(Void*, Int32) Span<T>(Void*, Int32) Span<T>(Void*, Int32) Span<T>(Void*, Int32)

指定されたメモリ アドレスで始まり、指定された数の T 要素を持つ、新しい Span<T> オブジェクトを作成します。Creates a new Span<T> object from a specified number of T elements starting at a specified memory address.

Span<T>(T[], Int32, Int32) Span<T>(T[], Int32, Int32) Span<T>(T[], Int32, Int32) Span<T>(T[], Int32, Int32)

指定インデックスで始まる配列の指定要素数を含む新しい Span<T> オブジェクトを作成します。Creates a new Span<T> object that includes a specified number of elements of an array starting at a specified index.

プロパティ

Empty Empty Empty Empty

空の Span<T> オブジェクトを返します。Returns an empty Span<T> object.

IsEmpty IsEmpty IsEmpty IsEmpty

現在の Span<T> が空かどうかを示す値を返します。Returns a value that indicates whether the current Span<T> is empty.

Item[Int32] Item[Int32] Item[Int32] Item[Int32]

0 から始まる指定したインデックス位置にある要素を取得します。Gets the element at the specified zero-based index.

Length Length Length Length

現在のスパンの長さを返します。Returns the length of the current span.

メソッド

Clear() Clear() Clear() Clear()

この Span<T> オブジェクトの内容を消去します。Clears the contents of this Span<T> object.

CopyTo(Span<T>) CopyTo(Span<T>) CopyTo(Span<T>) CopyTo(Span<T>)

この Span<T> の内容をコピー先 Span<T> にコピーします。Copies the contents of this Span<T> into a destination Span<T>.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

このメソッドを呼び出すことはできません。Calls to this method are not supported.

Fill(T) Fill(T) Fill(T) Fill(T)

このスパンの要素に指定の値を入力します。Fills the elements of this span with a specified value.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

この Span<T> の列挙子を返します。Returns an enumerator for this Span<T>.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

NotSupportedException をスローします。Throws a NotSupportedException.

GetPinnableReference() GetPinnableReference() GetPinnableReference() GetPinnableReference()

インデックス 0 にある Span<T> の要素の参照を返します。Returns a reference to the element of the Span<T> at index zero.

Slice(Int32) Slice(Int32) Slice(Int32) Slice(Int32)

指定のインデックスで始まる現在のスパンからスライスを形成します。Forms a slice out of the current span that begins at a specified index.

Slice(Int32, Int32) Slice(Int32, Int32) Slice(Int32, Int32) Slice(Int32, Int32)

指定インデックスから始まる現在のスパンからスライスを指定の長さで形成します。Forms a slice out of the current span starting at a specified index for a specified length.

ToArray() ToArray() ToArray() ToArray()

このスパンの内容を新しい配列にコピーします。Copies the contents of this span into a new array.

ToString() ToString() ToString() ToString()

この Span<T> オブジェクトの文字列表現を返します。Returns the string representation of this Span<T> object.

TryCopyTo(Span<T>) TryCopyTo(Span<T>) TryCopyTo(Span<T>) TryCopyTo(Span<T>)

コピー先 Span<T> に対して現在の Span<T> のコピーを試行し、コピー操作が成功したかどうかを示す値を返します。Attempts to copy the current Span<T> to a destination Span<T> and returns a value that indicates whether the copy operation succeeded.

演算子

Equality(Span<T>, Span<T>) Equality(Span<T>, Span<T>) Equality(Span<T>, Span<T>) Equality(Span<T>, Span<T>)

2 つの Span<T> オブジェクトが等しいかどうかを示す値を返します。Returns a value that indicates whether two Span<T> objects are equal.

Implicit(ArraySegment<T> to Span<T>) Implicit(ArraySegment<T> to Span<T>) Implicit(ArraySegment<T> to Span<T>) Implicit(ArraySegment<T> to Span<T>)

ArraySegment<T> から Span<T> への暗黙の型変換を定義します。Defines an implicit conversion of an ArraySegment<T> to a Span<T>.

Implicit(Span<T> to ReadOnlySpan<T>) Implicit(Span<T> to ReadOnlySpan<T>) Implicit(Span<T> to ReadOnlySpan<T>) Implicit(Span<T> to ReadOnlySpan<T>)

Span<T> から ReadOnlySpan<T> への暗黙の型変換を定義します。Defines an implicit conversion of a Span<T> to a ReadOnlySpan<T>.

Implicit(T[] to Span<T>) Implicit(T[] to Span<T>) Implicit(T[] to Span<T>) Implicit(T[] to Span<T>)

配列から Span<T> への暗黙の型変換を定義します。Defines an implicit conversion of an array to a Span<T>.

Inequality(Span<T>, Span<T>) Inequality(Span<T>, Span<T>) Inequality(Span<T>, Span<T>) Inequality(Span<T>, Span<T>)

2 つの Span<T> オブジェクトが等しくないかどうかを示す値を返します。Returns a value that indicates whether two Span<T> objects are not equal.

拡張メソッド

BinarySearch<T>(Span<T>, IComparable<T>) BinarySearch<T>(Span<T>, IComparable<T>) BinarySearch<T>(Span<T>, IComparable<T>) BinarySearch<T>(Span<T>, IComparable<T>)

指定した IComparable<T> ジェネリック インターフェイスを使用し、並べ替えられた Span<T> 全体の中から値を検索します。Searches an entire sorted Span<T> for a value using the specified IComparable<T> generic interface.

BinarySearch<T,TComparer>(Span<T>, T, TComparer) BinarySearch<T,TComparer>(Span<T>, T, TComparer) BinarySearch<T,TComparer>(Span<T>, T, TComparer) BinarySearch<T,TComparer>(Span<T>, T, TComparer)

指定した TComparer ジェネリック型を使用し、並べ替えられた Span<T> 全体の中から、指定した値を検索します。Searches an entire sorted Span<T> for a specified value using the specified TComparer generic type.

BinarySearch<T,TComparable>(Span<T>, TComparable) BinarySearch<T,TComparable>(Span<T>, TComparable) BinarySearch<T,TComparable>(Span<T>, TComparable) BinarySearch<T,TComparable>(Span<T>, TComparable)

指定した TComparable ジェネリック型を使用し、並べ替えられた Span<T> 全体の中から値を検索します。Searches an entire sorted Span<T> for a value using the specified TComparable generic type.

Contains<T>(Span<T>, T) Contains<T>(Span<T>, T) Contains<T>(Span<T>, T) Contains<T>(Span<T>, T)

指定した値がスパンに存在するかどうかを示します。Indicates whether a specified value is found in a span. 値は IEquatable{T}.Equals(T) を使用して比較されます。Values are compared using IEquatable{T}.Equals(T).

EndsWith<T>(Span<T>, ReadOnlySpan<T>) EndsWith<T>(Span<T>, ReadOnlySpan<T>) EndsWith<T>(Span<T>, ReadOnlySpan<T>) EndsWith<T>(Span<T>, ReadOnlySpan<T>)

指定されたシーケンスがスパンの末尾にあるかどうかを判断します。Determines whether the specified sequence appears at the end of a span.

IndexOf<T>(Span<T>, T) IndexOf<T>(Span<T>, T) IndexOf<T>(Span<T>, T) IndexOf<T>(Span<T>, T)

指定した値を検索し、それが最初に見つかった位置のインデックスを返します。Searches for the specified value and returns the index of its first occurrence. 値は IEquatable{T}.Equals(T) を使用して比較されます。Values are compared using IEquatable{T}.Equals(T).

IndexOf<T>(Span<T>, ReadOnlySpan<T>) IndexOf<T>(Span<T>, ReadOnlySpan<T>) IndexOf<T>(Span<T>, ReadOnlySpan<T>) IndexOf<T>(Span<T>, ReadOnlySpan<T>)

指定したシーケンスを検索し、それが最初に見つかった位置のインデックスを返します。Searches for the specified sequence and returns the index of its first occurrence. 値は IEquatable{T}.Equals(T) を使用して比較されます。Values are compared using IEquatable{T}.Equals(T).

IndexOfAny<T>(Span<T>, T, T) IndexOfAny<T>(Span<T>, T, T) IndexOfAny<T>(Span<T>, T, T) IndexOfAny<T>(Span<T>, T, T)

論理 OR 演算子を使用して IndexOf を数回呼び出すのと同様に、指定されたいずれかの値の最初のインデックスを検索します。Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator.

IndexOfAny<T>(Span<T>, T, T, T) IndexOfAny<T>(Span<T>, T, T, T) IndexOfAny<T>(Span<T>, T, T, T) IndexOfAny<T>(Span<T>, T, T, T)

論理 OR 演算子を使用して IndexOf を数回呼び出すのと同様に、指定されたいずれかの値の最初のインデックスを検索します。Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator.

IndexOfAny<T>(Span<T>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

論理 OR 演算子を使用して IndexOf を数回呼び出すのと同様に、指定されたいずれかの値の最初のインデックスを検索します。Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator.

LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, T)

指定した値を検索し、それが最後に見つかった位置のインデックスを返します。Searches for the specified value and returns the index of its last occurrence. 値は IEquatable{T}.Equals(T) を使用して比較されます。Values are compared using IEquatable{T}.Equals(T).

LastIndexOf<T>(Span<T>, ReadOnlySpan<T>) LastIndexOf<T>(Span<T>, ReadOnlySpan<T>) LastIndexOf<T>(Span<T>, ReadOnlySpan<T>) LastIndexOf<T>(Span<T>, ReadOnlySpan<T>)

指定したシーケンスを検索し、それが最後に見つかった位置のインデックスを返します。Searches for the specified sequence and returns the index of its last occurrence. 値は IEquatable{T}.Equals(T) を使用して比較されます。Values are compared using IEquatable{T}.Equals(T).

LastIndexOfAny<T>(Span<T>, T, T) LastIndexOfAny<T>(Span<T>, T, T) LastIndexOfAny<T>(Span<T>, T, T) LastIndexOfAny<T>(Span<T>, T, T)

論理 OR 演算子で LastIndexOf を数回呼び出すのと同様に、指定された値のいずれかの最後のインデックスを検索します。Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator.

LastIndexOfAny<T>(Span<T>, T, T, T) LastIndexOfAny<T>(Span<T>, T, T, T) LastIndexOfAny<T>(Span<T>, T, T, T) LastIndexOfAny<T>(Span<T>, T, T, T)

論理 OR 演算子で LastIndexOf を数回呼び出すのと同様に、指定された値のいずれかの最後のインデックスを検索します。Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator.

LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)

論理 OR 演算子で LastIndexOf を数回呼び出すのと同様に、指定された値のいずれかの最後のインデックスを検索します。Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator.

Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>)

スパンと読み取り専用スパンがメモリ内で重なり合うかどうかを判断します。Determines whether a span and a read-only span overlap in memory.

Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32) Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32) Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32) Overlaps<T>(Span<T>, ReadOnlySpan<T>, Int32)

スパンと読み取り専用スパンがメモリ内で重なり合うかどうかを判断し、要素のオフセットを出力します。Determines whether a span and a read-only span overlap in memory and outputs the element offset.

Reverse<T>(Span<T>) Reverse<T>(Span<T>) Reverse<T>(Span<T>) Reverse<T>(Span<T>)

スパン全体の要素のシーケンスを反転させます。Reverses the sequence of the elements in the entire span.

SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>) SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>) SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>) SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>)

IComparable{T}.CompareTo(T) を使用して要素を比較することで、スパンと読み取り専用スパンの相対順序を決定します。Determines the relative order of a span and a read-only span by comparing the elements using IComparable{T}.CompareTo(T).

SequenceEqual<T>(Span<T>, ReadOnlySpan<T>) SequenceEqual<T>(Span<T>, ReadOnlySpan<T>) SequenceEqual<T>(Span<T>, ReadOnlySpan<T>) SequenceEqual<T>(Span<T>, ReadOnlySpan<T>)

IEquatable{T}.Equals(T) を使用して要素を比較することで、スパンと読み取り専用スパンが等しいかどうかを判断します。Determines whether a span and a read-only span are equal by comparing the elements using IEquatable{T}.Equals(T).

StartsWith<T>(Span<T>, ReadOnlySpan<T>) StartsWith<T>(Span<T>, ReadOnlySpan<T>) StartsWith<T>(Span<T>, ReadOnlySpan<T>) StartsWith<T>(Span<T>, ReadOnlySpan<T>)

指定されたシーケンスがスパンの先頭にあるかどうかを判断します。Determines whether a specified sequence appears at the start of a span.

Trim<T>(Span<T>, T) Trim<T>(Span<T>, T) Trim<T>(Span<T>, T) Trim<T>(Span<T>, T)

指定された要素が先頭と末尾に現れる箇所をすべて、スパンから削除します。Removes all leading and trailing occurrences of a specified element from a span.

Trim<T>(Span<T>, ReadOnlySpan<T>) Trim<T>(Span<T>, ReadOnlySpan<T>) Trim<T>(Span<T>, ReadOnlySpan<T>) Trim<T>(Span<T>, ReadOnlySpan<T>)

読み取り専用スパンで指定された一連の要素が先頭と末尾に現れる箇所をすべて、スパンから削除します。Removes all leading and trailing occurrences of a set of elements specified in a read-only span from a span.

TrimEnd<T>(Span<T>, T) TrimEnd<T>(Span<T>, T) TrimEnd<T>(Span<T>, T) TrimEnd<T>(Span<T>, T)

指定された要素が末尾に現れる箇所をすべて、スパンから削除します。Removes all trailing occurrences of a specified element from a span.

TrimEnd<T>(Span<T>, ReadOnlySpan<T>) TrimEnd<T>(Span<T>, ReadOnlySpan<T>) TrimEnd<T>(Span<T>, ReadOnlySpan<T>) TrimEnd<T>(Span<T>, ReadOnlySpan<T>)

読み取り専用スパンで指定された一連の要素が末尾に現れる箇所をすべて、スパンから削除します。Removes all trailing occurrences of a set of elements specified in a read-only span from a span.

TrimStart<T>(Span<T>, T) TrimStart<T>(Span<T>, T) TrimStart<T>(Span<T>, T) TrimStart<T>(Span<T>, T)

指定した要素が先頭に現れる箇所をすべてスパンから削除します。Removes all leading occurrences of a specified element from the span.

TrimStart<T>(Span<T>, ReadOnlySpan<T>) TrimStart<T>(Span<T>, ReadOnlySpan<T>) TrimStart<T>(Span<T>, ReadOnlySpan<T>) TrimStart<T>(Span<T>, ReadOnlySpan<T>)

読み取り専用スパンで指定された一連の要素が先頭に現れる箇所をすべて、スパンから削除します。Removes all leading occurrences of a set of elements specified in a read-only span from the span.

適用対象