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

Définition

Fournit une représentation de type et de mémoire sécurisés d’une zone contiguë de mémoire arbitraire.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)

Paramètres de type

T

Type des éléments dans le Span<T>.The type of items in the Span<T>.

Héritage

Remarques

Span<T> est un ref struct qui est allouée sur la pile plutôt que sur le tas managé.Span<T> is a ref struct that is allocated on the stack rather than on the managed heap. Types de struct REF ont un nombre de restrictions pour vous assurer qu’ils ne peut pas être promus vers le tas managé, y compris qu’ils ne peuvent pas être convertis, ils ne peuvent pas être attribués à des variables de type Object, dynamic ou à n’importe quel type d’interface, ils ne peut pas être des champs dans un type de référence et ils ne peut pas être utilisé sur await et yield des limites.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. En outre, les appels à deux méthodes, Equals(Object) et GetHashCode, lever une NotSupportedException.In addition, calls to two methods, Equals(Object) and GetHashCode, throw a NotSupportedException.

Important

Étant donné que c’est un type de pile uniquement, Span<T> ne convient pas pour plusieurs scénarios qui requièrent des références aux mémoires tampons de stockage sur le tas.Because it is a stack-only type, Span<T> is unsuitable for many scenarios that require storing references to buffers on the heap. Cela est vrai, par exemple, des routines qui effectuent des appels de méthode asynchrone.This is true, for example, of routines that make asynchronous method calls. Dans ce cas, vous pouvez utiliser les informations complémentaires System.Memory<T> et System.ReadOnlyMemory<T> types.For such scenarios, you can use the complementary System.Memory<T> and System.ReadOnlyMemory<T> types.

Pour les étendues qui représentent des structures immuables ou en lecture seule, utilisez System.ReadOnlySpan<T>.For spans that represent immutable or read-only structures, use System.ReadOnlySpan<T>.

Étendue<T > et de la mémoireSpan<T> and memory

Un Span<T> représente une zone contiguë de mémoire arbitraire.A Span<T> represents a contiguous region of arbitrary memory. Un Span<T> instance est souvent utilisée pour contenir les éléments d’un tableau ou une partie d’un tableau.A Span<T> instance is often used to hold the elements of an array or a portion of an array. Contrairement à un tableau, toutefois, un Span<T> instance peut pointer vers la mémoire managée, la mémoire native, ou la mémoire gérée sur la pile.Unlike an array, however, a Span<T> instance can point to managed memory, native memory, or memory managed on the stack. L’exemple suivant crée un Span<Byte> à partir d’un tableau :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

L’exemple suivant crée un Span<Byte> à partir de 100 octets de mémoire native :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

L’exemple suivant utilise le C# stackalloc mot clé allouer 100 octets de mémoire sur la pile :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

Étant donné que Span<T> est une abstraction sur un bloc de mémoire, les méthodes d’arbitraire le Span<T> classe et les méthodes avec Span<T> paramètres fonctionnent sur n’importe quel Span<T> objet, quel que soit le type de mémoire qu’il encapsule.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. Par exemple, chacune des sections distinctes de code pour initialiser l’étendue et de calculer que la somme de ses éléments peut être modifiée dans une initialisation unique et méthodes de calcul, comme dans l’exemple suivant montre :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

Étendue<T > et les tableauxSpan<T> and arrays

Lorsque qu’il encapsule un tableau, Span<T> peut encapsuler un tableau entier, comme elle le faisait dans les exemples de la étendue<T > et de la mémoire section.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. Car il prend en charge le découpage, Span<T> peut aussi pointer vers n’importe quelle plage contiguë dans le tableau.Because it supports slicing, Span<T> can also point to any contiguous range within the array.

L’exemple suivant crée une tranche de cinq éléments intermédiaires d’un tableau d’entiers de 10 éléments.The following example creates a slice of the middle five elements of a 10-element integer array. Notez que le code multiplie par deux les valeurs de chaque entier de la tranche.Note that the code doubles the values of each integer in the slice. Comme le montre la sortie, les modifications apportées par l’étendue sont répercutées dans les valeurs du tableau.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

Étendue<T > et les segmentsSpan<T> and slices

Span<T> inclut deux surcharges de la Slice méthode qui forment une tranche en dehors de l’étendue actuelle qui commence à l’index spécifié.Span<T> includes two overloads of the Slice method that form a slice out of the current span that starts at a specified index. Cela permet de traiter les données dans un Span<T> comme un ensemble de segments logiques qui peuvent être traitées en fonction des besoins en parties d’un pipeline de traitement des données avec un impact minimal sur les performances.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. Par exemple, étant donné que les protocoles serveur modernes sont souvent textuel, manipulation de chaînes et de sous-chaînes est particulièrement importante.For example, since modern server protocols are often text-based, manipulation of strings and substrings is particularly important. Dans le String de classe, la principale méthode pour extraire des sous-chaînes est Substring.In the String class, the major method for extracting substrings is Substring. Pour les pipelines de données qui s’appuient sur la manipulation de chaînes étendues, son utilisation offre quelques dégradations des performances, car il :For data pipelines that rely on extensive string manipulation, its use offers some performance penalties, since it:

  1. Crée une chaîne contenant la sous-chaîne.Creates a new string to hold the substring.

  2. Copie un sous-ensemble de caractères à partir de la chaîne d’origine vers la nouvelle chaîne.Copies a subset of the characters from the original string to the new string.

Cette opération d’allocation et de copie peut être éliminée en utilisant soit Span<T> ou ReadOnlySpan<T>, comme illustré dans l’exemple suivant :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

Constructeurs

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

Crée un objet Span<T> sur l’intégralité d’un tableau spécifié.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)

Crée un objet Span<T> à partir d’un nombre spécifié d’éléments T commençant à une adresse mémoire spécifiée.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)

Crée un objet Span<T> qui inclut un nombre spécifié d’élément à partir d’un tableau commençant à l’index spécifié.Creates a new Span<T> object that includes a specified number of elements of an array starting at a specified index.

Propriétés

Empty Empty Empty Empty

Retourne un objet Span<T> vide.Returns an empty Span<T> object.

IsEmpty IsEmpty IsEmpty IsEmpty

Retourne une valeur qui indique si le Span<T> actuel est vide.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]

Obtient l’élément au niveau de l’index de base zéro spécifié.Gets the element at the specified zero-based index.

Item[Index] Item[Index] Item[Index] Item[Index]
Length Length Length Length

Retourne la longueur de l’étendue actuelle.Returns the length of the current span.

Méthodes

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

Efface le contenu de cet objet Span<T>.Clears the contents of this Span<T> object.

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

Copie le contenu de ce Span<T> dans un Span<T> de destination.Copies the contents of this Span<T> into a destination Span<T>.

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

Les appels à cette méthode ne sont pas pris en charge.Calls to this method are not supported.

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

Remplit les éléments de cette étendue avec une valeur spécifiée.Fills the elements of this span with a specified value.

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

Retourne un énumérateur pour ce Span<T>.Returns an enumerator for this Span<T>.

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

Lève un NotSupportedException.Throws a NotSupportedException.

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

Retourne une référence à l’élément de Span<T> à l’index zéro.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)

Constitue une section en dehors de l’étendue actuelle qui commence à l’index spécifié.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)

Constitue une section en dehors de l’étendue actuelle qui commence à un index spécifié pour une longueur spécifiée.Forms a slice out of the current span starting at a specified index for a specified length.

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

Copie le contenu de cette étendue dans un nouveau tableau.Copies the contents of this span into a new array.

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

Retourne la représentation sous forme de chaîne de cet objet Span<T>.Returns the string representation of this Span<T> object.

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

Tente de copier le Span<T> actuel vers un Span<T> de destination et retourne une valeur qui indique si l’opération de copie a réussi.Attempts to copy the current Span<T> to a destination Span<T> and returns a value that indicates whether the copy operation succeeded.

Opérateurs

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

Retourne une valeur qui indique si deux objets Span<T> sont égaux.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>)

Définit une conversion implicite d’un ArraySegment<T> en 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>)

Définit une conversion implicite d’un Span<T> en 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>)

Définit une conversion implicite d’un tableau en 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>)

Retourne une valeur qui indique si deux objets Span<T> ne sont pas égaux.Returns a value that indicates whether two Span<T> objects are not equal.

Méthodes d’extension

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>)

S’applique à