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

Definizione

Fornisce una rappresentazione indipendente dai tipi e dalla memoria di una regione contigua di memoria arbitraria.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)

Parametri di tipo

T

Tipo di elementi nell'oggetto Span<T>.The type of items in the Span<T>.

Ereditarietà

Commenti

Span<T>è uno struct di riferimento allocato nello stack anziché nell'heap gestito.Span<T> is a ref struct that is allocated on the stack rather than on the managed heap. I tipi di struct Ref presentano una serie di restrizioni per assicurarsi che non possano essere innalzate di grado nell'heap gestito, incluso il fatto che non possono essere sottoposte a ObjectBoxing dynamic , non possono essere assegnate a variabili di tipo o a qualsiasi tipo di interfaccia, non possono essere campi in un tipo di riferimento e non possono essere usati tra await e yield i limiti.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. Inoltre, le chiamate a due metodi, Equals(Object) e GetHashCode, generano NotSupportedExceptionun'.In addition, calls to two methods, Equals(Object) and GetHashCode, throw a NotSupportedException.

Importante

Poiché è un tipo di solo stack, Span<T> non è adatto per molti scenari che richiedono l'archiviazione di riferimenti ai buffer nell'heap.Because it is a stack-only type, Span<T> is unsuitable for many scenarios that require storing references to buffers on the heap. Questo vale, ad esempio, delle routine che effettuano chiamate asincrone al metodo.This is true, for example, of routines that make asynchronous method calls. Per questi scenari, è possibile usare i tipi System.Memory<T> complementari System.ReadOnlyMemory<T> e.For such scenarios, you can use the complementary System.Memory<T> and System.ReadOnlyMemory<T> types.

Per gli intervalli che rappresentano strutture non modificabili o di sola lettura, System.ReadOnlySpan<T>usare.For spans that represent immutable or read-only structures, use System.ReadOnlySpan<T>.

><Span T e memoriaSpan<T> and memory

Un Span<T> oggetto rappresenta un'area contigua della memoria arbitraria.A Span<T> represents a contiguous region of arbitrary memory. Un' Span<T> istanza viene spesso utilizzata per conservare gli elementi di una matrice o di una parte di una matrice.A Span<T> instance is often used to hold the elements of an array or a portion of an array. A differenza di una matrice, tuttavia, Span<T> un'istanza può puntare alla managed memory, alla memoria nativa o alla memoria gestita nello stack.Unlike an array, however, a Span<T> instance can point to managed memory, native memory, or memory managed on the stack. Nell'esempio seguente viene creato Span<Byte> un oggetto da una matrice: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

Nell'esempio seguente viene creato Span<Byte> un da 100 byte di memoria nativa: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

Nell'esempio seguente viene usata C# la parola chiave stackalloc per allocare 100 byte di memoria nello stack: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

Poiché Span<T> è un'astrazione in un blocco di memoria arbitrario, i metodi Span<T> della classe e i Span<T> metodi con parametri operano su qualsiasi Span<T> oggetto indipendentemente dal tipo di memoria incapsulato.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. Ad esempio, ogni sezione separata del codice che Inizializza l'intervallo e calcola la somma dei relativi elementi può essere modificata in singoli metodi di inizializzazione e calcolo, come illustrato nell'esempio seguente: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 e matriciSpan<T> and arrays

Quando esegue il wrapping di una matrice Span<T> , può eseguire il wrapping di un'intera matrice, come negli esempi della sezione<span T > e 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. Poiché supporta il sezionamento, Span<T> può puntare anche a qualsiasi intervallo contiguo all'interno della matrice.Because it supports slicing, Span<T> can also point to any contiguous range within the array.

Nell'esempio seguente viene creata una sezione dei cinque elementi intermedi di una matrice di interi a 10 elementi.The following example creates a slice of the middle five elements of a 10-element integer array. Si noti che il codice raddoppia i valori di ogni intero nella sezione.Note that the code doubles the values of each integer in the slice. Come illustrato nell'output, le modifiche apportate dall'intervallo vengono riflesse nei valori della matrice.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 > e sezioniSpan<T> and slices

Span<T>include due overload del Slice metodo che formano una sezione dall'intervallo corrente che inizia in corrispondenza di un indice specificato.Span<T> includes two overloads of the Slice method that form a slice out of the current span that starts at a specified index. In questo modo è possibile trattare i dati in un Span<T> come un set di blocchi logici che possono essere elaborati in base alle esigenze da parte di una pipeline di elaborazione dati con un effetto minimo sulle prestazioni.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. Ad esempio, poiché i protocolli server moderni sono spesso basati su testo, la manipolazione di stringhe e sottostringhe è particolarmente importante.For example, since modern server protocols are often text-based, manipulation of strings and substrings is particularly important. Nella classe il metodo principale per l'estrazione di sottostringhe è Substring. StringIn the String class, the major method for extracting substrings is Substring. Per le pipeline di dati che si basano su una manipolazione estesa delle stringhe, il suo utilizzo offre alcune sanzioni in materia di prestazioni, in quanto:For data pipelines that rely on extensive string manipulation, its use offers some performance penalties, since it:

  1. Crea una nuova stringa in cui deve essere contenuta la sottostringa.Creates a new string to hold the substring.

  2. Copia un subset dei caratteri dalla stringa originale alla nuova stringa.Copies a subset of the characters from the original string to the new string.

Questa operazione di allocazione e copia può essere eliminata Span<T> utilizzando ReadOnlySpan<T>o, come illustrato nell'esempio seguente: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

Costruttori

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

Crea un nuovo oggetto Span<T> sull'intera matrice specificata.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)

Crea un nuovo oggetto Span<T> da un numero specificato di elementi T partire da un indirizzo di memoria specificato.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)

Crea un nuovo oggetto Span<T> che include un numero specificato di elementi di una matrice che iniziano in un indice specificato.Creates a new Span<T> object that includes a specified number of elements of an array starting at a specified index.

Proprietà

Empty Empty Empty Empty

Restituisce un oggetto Span<T> vuoto.Returns an empty Span<T> object.

IsEmpty IsEmpty IsEmpty IsEmpty

Restituisce un valore che indica se l'oggetto Span<T> corrente è vuoto.Returns a value that indicates whether the current Span<T> is empty.

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

Ottiene l'elemento in corrispondenza dell'indice in base zero.Gets the element at the specified zero-based index.

Length Length Length Length

Restituisce la lunghezza dell'intervallo corrente.Returns the length of the current span.

Metodi

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

Cancella il contenuto di questo oggetto Span<T>.Clears the contents of this Span<T> object.

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

Copia il contenuto di questo Span<T> in una destinazione Span<T>.Copies the contents of this Span<T> into a destination Span<T>.

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

Le chiamate a questo metodo non sono supportate.Calls to this method are not supported.

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

Inserisce un valore specificato negli elementi di questo intervallo.Fills the elements of this span with a specified value.

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

Restituisce un enumeratore per questo Span<T>.Returns an enumerator for this Span<T>.

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

Genera un oggetto NotSupportedException.Throws a NotSupportedException.

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

Restituisce un riferimento all'elemento di Span<T> in corrispondenza dell'indice zero.Returns a reference to the element of the Span<T> at index zero.

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

Crea una sezione dall'intervallo corrente che inizia in corrispondenza di un indice specificato.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)

Crea una sezione dall'intervallo corrente che inizia in corrispondenza di un indice specificato per una lunghezza specificata.Forms a slice out of the current span starting at a specified index for a specified length.

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

Copia il contenuto di questo intervallo in una nuova matrice.Copies the contents of this span into a new array.

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

Restituisce la rappresentazione di stringa dell'oggetto Span<T>.Returns the string representation of this Span<T> object.

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

Tenta di copiare l'oggetto Span<T> corrente in un Span<T> di destinazione e restituisce un valore che indica se l'operazione di copia ha avuto esito positivo.Attempts to copy the current Span<T> to a destination Span<T> and returns a value that indicates whether the copy operation succeeded.

Operatori

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

Restituisce un valore che indica se due oggetti Span<T> sono uguali.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>)

Definisce una conversione implicita di un ArraySegment<T> in un 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>)

Definisce una conversione implicita di un oggetto Span<T> in un oggetto 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>)

Definisce una conversione implicita di una matrice in 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>)

Restituisce un valore che indica se due oggetti Span<T> non sono uguali.Returns a value that indicates whether two Span<T> objects are not equal.

Metodi di estensione

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

Esegue la ricerca di un valore in un'intera matrice Span<T> ordinata usando l'interfaccia generica IComparable<T> specificata.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)

Esegue la ricerca di un valore specifico in un'intera matrice Span<T> ordinata usando il tipo generico TComparer specificato.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)

Esegue la ricerca di un valore in un'intera matrice Span<T> ordinata usando il tipo generico TComparable specificato.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)

Indica se un valore specificato viene trovato in un intervallo.Indicates whether a specified value is found in a span. I valori vengono confrontati tramite 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>)

Determina se la sequenza specificata viene visualizzata alla fine di un intervallo.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)

Cerca il valore specificato e restituisce l'indice della prima occorrenza.Searches for the specified value and returns the index of its first occurrence. I valori vengono confrontati tramite 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>)

Cerca la sequenza specificata e restituisce l'indice della prima occorrenza.Searches for the specified sequence and returns the index of its first occurrence. I valori vengono confrontati tramite 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)

Cerca il primo indice di uno dei valori specificati simile alla chiamata di IndexOf eseguita più volte con l'operatore logico OR.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)

Cerca il primo indice di uno dei valori specificati simile alla chiamata di IndexOf eseguita più volte con l'operatore logico OR.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>)

Cerca il primo indice di uno dei valori specificati simile alla chiamata di IndexOf eseguita più volte con l'operatore logico OR.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)

Cerca il valore specificato e restituisce l'indice dell'ultima occorrenza.Searches for the specified value and returns the index of its last occurrence. I valori vengono confrontati tramite 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>)

Cerca la sequenza specificata e restituisce l'indice dell'ultima occorrenza.Searches for the specified sequence and returns the index of its last occurrence. I valori vengono confrontati tramite 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)

Cerca l'ultimo indice di uno dei valori specificati simile alla chiamata di LastIndexOf eseguita più volte con l'operatore logico OR.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)

Cerca l'ultimo indice di uno dei valori specificati simile alla chiamata di LastIndexOf eseguita più volte con l'operatore logico OR.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>)

Cerca l'ultimo indice di uno dei valori specificati simile alla chiamata di LastIndexOf eseguita più volte con l'operatore logico OR.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>)

Determina se un intervallo e un intervallo di sola lettura si sovrappongono in memoria.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)

Determina se un intervallo e un intervallo di sola lettura si sovrappongono in memoria e genera l'offset dell'elemento.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>)

Inverte la sequenza degli elementi nell'intero intervallo.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>)

Determina l'ordine relativo di un intervallo e di un intervallo di sola lettura confrontando i relativi elementi usando 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>)

Determina se un intervallo e un intervallo di sola lettura sono uguali confrontando gli elementi con 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>)

Determina se una sequenza specificata viene visualizzata all'inizio di un intervallo.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)

Rimuove tutte le occorrenze iniziali e finali di un elemento specificato da un intervallo.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>)

Rimuove tutte le occorrenze iniziali e finali di un set di elementi specificato in un intervallo di sola lettura da un intervallo.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)

Rimuove tutte le occorrenze finali di un elemento specificato da un intervallo.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>)

Rimuove tutte le occorrenze finali di un set di elementi specificato in un intervallo di sola lettura da un intervallo.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)

Rimuove tutte le occorrenze iniziali di un elemento specificato da un intervallo.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>)

Rimuove tutte le occorrenze iniziali di un set di elementi specificato in un intervallo di sola lettura da un intervallo.Removes all leading occurrences of a set of elements specified in a read-only span from the span.

Si applica a