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 de Span<T>.The type of items in the Span<T>.

Héritage

Remarques

Span<T>est un struct de référence qui est alloué 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. Les types de struct Ref ont un certain nombre de restrictions pour s’assurer qu’elles ne peuvent pas être promues vers le tas managé, y compris qu’elles ne peuvent pas être Objectconverties, qu’elles ne peuvent pas être assignées à des variables de type, dynamic ou à n’importe quel type d’interface, qu’elles ne peuvent pas être des champs dans un type référence, et ils ne peuvent pas être await utilisés yield à travers les limites et.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) , GetHashCodeet, lèvent NotSupportedException.In addition, calls to two methods, Equals(Object) and GetHashCode, throw a NotSupportedException.

Important

Étant donné qu’il s’agit d’un type Span<T> de pile uniquement, est inapproprié pour de nombreux scénarios qui nécessitent le stockage des références aux mémoires tampons 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. C’est le cas, par exemple, des routines qui effectuent des appels de méthode asynchrones.This is true, for example, of routines that make asynchronous method calls. Pour ces scénarios, vous pouvez utiliser les types System.Memory<T> et System.ReadOnlyMemory<T> complémentaires.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 System.ReadOnlySpan<T>, utilisez.For spans that represent immutable or read-only structures, use System.ReadOnlySpan<T>.

Span<T > et mémoireSpan<T> and memory

Un Span<T> représente une région contiguë de mémoire arbitraire.A Span<T> represents a contiguous region of arbitrary memory. Une 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. Toutefois, contrairement à un tableau, Span<T> une instance peut pointer vers la mémoire managée, la mémoire native ou la mémoire managé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# mot clé stackalloc pour 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 Span<T> donné que est une abstraction sur un bloc de mémoire arbitraire, les Span<T> méthodes de la classe Span<T> et les méthodes avec Span<T> des paramètres fonctionnent sur tout 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 de code distinctes qui initialisent l’étendue et calculent la somme de ses éléments peut être modifiée en une seule méthode d’initialisation et de calcul, comme l’illustre l’exemple suivant :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 > et tableauxSpan<T> and arrays

Lorsqu’il encapsule un tableau, Span<T> peut encapsuler un tableau entier, comme c’était le cas dans les exemples de la section span<T > et Memory .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. Étant donné qu’il prend en Span<T> charge le découpage, peut également 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 des cinq éléments centraux d’un tableau d’entiers à 10 éléments.The following example creates a slice of the middle five elements of a 10-element integer array. Notez que le code double les valeurs de chaque entier dans 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 reflété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

Span<T > et tranchesSpan<T> and slices

Span<T>comprend deux surcharges de la Slice méthode qui forment un segment hors de l’étendue actuelle qui commence à un 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 en Span<T> tant qu’ensemble de blocs logiques qui peuvent être traités en fonction des besoins des parties d’un pipeline de traitement des données avec un impact minime 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 basés sur du texte, la 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 la String classe, la principale méthode d’extraction de sous-chaînes est Substring.In the String class, the major method for extracting substrings is Substring. Pour les pipelines de données qui reposent sur des manipulations de chaînes étendues, son utilisation offre des pénalités en matière de performances, dans la mesure où :For data pipelines that rely on extensive string manipulation, its use offers some performance penalties, since it:

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

  2. Copie un sous-ensemble des caractères 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 Span<T> à ReadOnlySpan<T>l’aide de ou de, comme le montre 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[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.

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

Recherche une valeur dans une Span<T> entière triée en utilisant l’interface générique IComparable<T> spécifiée.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)

Recherche une valeur spécifiée dans une Span<T> entière triée en utilisant le type générique TComparer spécifié.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)

Recherche une valeur dans une Span<T> entière triée en utilisant le type générique TComparable spécifié.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)

Indique si une valeur spécifiée est trouvée dans une étendue.Indicates whether a specified value is found in a span. Les valeurs sont comparées en utilisant 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>)

Détermine si la séquence spécifiée apparaît à la fin d’une étendue.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)

Recherche la valeur spécifiée et retourne l’index de sa première occurrence.Searches for the specified value and returns the index of its first occurrence. Les valeurs sont comparées en utilisant 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>)

Recherche la séquence spécifiée et retourne l’index de sa première occurrence.Searches for the specified sequence and returns the index of its first occurrence. Les valeurs sont comparées en utilisant 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)

Recherche le premier index de l’une des valeurs spécifiées similaires à l’appel d’IndexOf plusieurs fois avec l’opérateur OR logique.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)

Recherche le premier index de l’une des valeurs spécifiées similaires à l’appel d’IndexOf plusieurs fois avec l’opérateur OR logique.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>)

Recherche le premier index de l’une des valeurs spécifiées similaires à l’appel d’IndexOf plusieurs fois avec l’opérateur OR logique.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)

Recherche la valeur spécifiée et retourne l’index de sa dernière occurrence.Searches for the specified value and returns the index of its last occurrence. Les valeurs sont comparées en utilisant 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>)

Recherche la séquence spécifiée et retourne l’index de sa dernière occurrence.Searches for the specified sequence and returns the index of its last occurrence. Les valeurs sont comparées en utilisant 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)

Recherche le dernier index de l’une des valeurs spécifiées similaires à l’appel de LastIndexOf plusieurs fois avec l’opérateur OR logique.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)

Recherche le dernier index de l’une des valeurs spécifiées similaires à l’appel de LastIndexOf plusieurs fois avec l’opérateur OR logique.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>)

Recherche le dernier index de l’une des valeurs spécifiées similaires à l’appel de LastIndexOf plusieurs fois avec l’opérateur OR logique.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>)

Détermine si une étendue et une étendue en lecture seule se chevauchent dans la mémoire.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)

Détermine si une étendue et une étendue en lecture seule se chevauchent dans la mémoire et génère le décalage des éléments.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>)

Inverse la séquence des éléments dans l’intégralité de l’étendue.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>)

Détermine l’ordre relatif d’une étendue et d’une étendue en lecture seule en comparant les éléments avec 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>)

Détermine si une étendue et une étendue en lecture seule sont égales en comparant les éléments avec 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>)

Détermine si une séquence spécifiée apparaît au début d’une étendue.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)

Supprime d’une étendue toutes les occurrences de début et de fin d’un élément spécifié.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>)

Supprime d’une étendue toutes les occurrences de début et de fin d’un jeu d’éléments spécifié dans une étendue en lecture seule.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)

Supprime d’une étendue toutes les occurrences de fin d’un élément spécifié.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>)

Supprime d’une étendue toutes les occurrences de fin d’un jeu d’éléments spécifié dans une étendue en lecture seule.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)

Supprime de l’étendue toutes les occurrences de début d’un élément spécifié.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>)

Supprime d’une étendue toutes les occurrences de début d’un jeu d’éléments spécifié dans une étendue en lecture seule.Removes all leading occurrences of a set of elements specified in a read-only span from the span.

S’applique à