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. さらに、2 つのメソッドを呼び出すEquals(Object)GetHashCode、スロー、NotSupportedExceptionします。In addition, calls to two methods, Equals(Object) and GetHashCode, throw a NotSupportedException.

重要

Stack 専用の種類が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. これは、true の場合、たとえば、非同期メソッドの呼び出しを行うルーチンの。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>.

スパン<T > とメモリSpan<T> and memory

ASpan<T>任意のメモリの連続した領域を表します。A Span<T> represents a contiguous region of arbitrary memory. ASpan<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

次の例では、作成、Span<Byte>ネイティブ メモリの 100 バイトから。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(arraySpan):N0}");    
    
    Marshal.FreeHGlobal(native);

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

    InitializeSpan(stackSpan);
    Console.WriteLine($"The sum is {ComputeSum(arraySpan):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

スパン<T > と配列Span<T> and arrays

配列をラップして場合、Span<T>と同じ例では、配列全体をラップすることができます、スパン<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. スライスをサポートするため、Span<T>配列内の任意の連続する範囲を指すこともできます。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

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

Span<T> 2 つのオーバー ロードが含まれています、Slice指定したインデックスから始まりの現在の範囲外のスライスを形成するメソッド。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[Range] Item[Range] Item[Range] Item[Range]
Item[Int32] Item[Int32] Item[Int32] Item[Int32]

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

Item[Index] Item[Index] Item[Index] Item[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(Index) Slice(Index) Slice(Index) Slice(Index)
Slice(Int32) Slice(Int32) Slice(Int32) Slice(Int32)

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

Slice(Range) Slice(Range) Slice(Range) Slice(Range)
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.

Extension Methods

BinarySearch<T>(Span<T>, IComparable<T>) BinarySearch<T>(Span<T>, IComparable<T>) BinarySearch<T>(Span<T>, IComparable<T>) BinarySearch<T>(Span<T>, IComparable<T>)
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)
BinarySearch<T,TComparable>(Span<T>, TComparable) BinarySearch<T,TComparable>(Span<T>, TComparable) BinarySearch<T,TComparable>(Span<T>, TComparable) BinarySearch<T,TComparable>(Span<T>, TComparable)
EndsWith<T>(Span<T>, ReadOnlySpan<T>) EndsWith<T>(Span<T>, ReadOnlySpan<T>) EndsWith<T>(Span<T>, ReadOnlySpan<T>) EndsWith<T>(Span<T>, ReadOnlySpan<T>)
IndexOf<T>(Span<T>, T) IndexOf<T>(Span<T>, T) IndexOf<T>(Span<T>, T) IndexOf<T>(Span<T>, 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>)
IndexOfAny<T>(Span<T>, T, 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, T) 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>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>) IndexOfAny<T>(Span<T>, ReadOnlySpan<T>)
LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, T) LastIndexOf<T>(Span<T>, 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>)
LastIndexOfAny<T>(Span<T>, T, 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, T) 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>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>) LastIndexOfAny<T>(Span<T>, ReadOnlySpan<T>)
Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>) Overlaps<T>(Span<T>, ReadOnlySpan<T>)
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)
Reverse<T>(Span<T>) Reverse<T>(Span<T>) Reverse<T>(Span<T>) Reverse<T>(Span<T>)
SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>) SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>) SequenceCompareTo<T>(Span<T>, ReadOnlySpan<T>) SequenceCompareTo<T>(Span<T>, ReadOnlySpan<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>)
StartsWith<T>(Span<T>, ReadOnlySpan<T>) StartsWith<T>(Span<T>, ReadOnlySpan<T>) StartsWith<T>(Span<T>, ReadOnlySpan<T>) StartsWith<T>(Span<T>, ReadOnlySpan<T>)

適用対象