Span<T>.Enumerator Struct

Definizione

Fornisce un enumeratore per gli elementi di un Span<T>.Provides an enumerator for the elements of a Span<T>.

public: value class Span<T>::Enumerator
public struct Span<T>.Enumerator
type Span<'T>.Enumerator = struct
Public Structure Span(Of T).Enumerator

Parametri di tipo

T
Ereditarietà
Span<T>.Enumerator

Commenti

Foreach c# del linguaggio C# e per ogni... Il costrutto successivo in Visual Basic nasconde la complessità degli enumeratori.The C# foreach of the C# language and the For Each...Next construct in Visual Basic hides the complexity of enumerators. Anziché modificare direttamente l'enumeratore, foreach For Each...Next è consigliabile utilizzare o.Instead of directly manipulating the enumerator, using foreach or For Each...Next is recommended.

Inizialmente, l'enumeratore è posizionato prima del primo elemento in Span<T> .Initially, the enumerator is positioned before the first element in the Span<T>. In questa posizione, la proprietà Current è indefinita.At this position, Current is undefined. È necessario chiamare MoveNext per far avanzare l'enumeratore al primo elemento in Span<T> prima di leggere il valore di Current .You must call MoveNext to advance the enumerator to the first item in the Span<T> before reading the value of Current.

Current Restituisce lo stesso valore fino a quando non MoveNext viene chiamato il metodo.Current returns the same value until MoveNext is called. MoveNext imposta Current sull'elemento successivo nell'oggetto Span<T> .MoveNext sets Current to the next item in the Span<T>.

Se MoveNext supera la fine di Span<T> , MoveNext restituisce false .If MoveNext passes the end of the Span<T>, MoveNext returns false. Quando l'enumeratore si trova in questo stato, le chiamate successive a MoveNext restituiscono anche false e non Current sono definite.When the enumerator is at this state, subsequent calls to MoveNext also return false and Current is undefined. Non è possibile impostare Current di nuovo il primo elemento nell'oggetto Span<T> . è invece necessario creare una nuova istanza dell'enumeratore.You cannot set Current to the first item in the Span<T> again; you must create a new enumerator instance instead.

L'enumeratore non dispone di accesso esclusivo a Span<T> .The enumerator does not have exclusive access to the Span<T>. Inoltre, è possibile modificare anche i dati sottostanti su cui si basa l'intervallo.In addition, the underlying data on which the span is based can also be modified. Pertanto, l'enumerazione tramite un intervallo non è intrinsecamente una procedura thread-safe.Therefore, enumerating through a span is intrinsically not a thread-safe procedure. Per garantire thread safety durante l'enumerazione, è necessario implementare una sincronizzazione personalizzata.To guarantee thread safety during enumeration, you must implement your own synchronization. Il codice seguente, ad esempio, ha un race condition.For example, the following code has a race condition. Non garantisce che l'intervallo venga enumerato prima dell' ClearContents esecuzione del metodo.It does not ensure that the span will be enumerated before the ClearContents method executes. La matrice sottostante viene quindi cancellata durante l'enumerazione dell'intervallo:As a result, the underlying array is cleared during enumeration of the span:

using System;
using System.Threading.Tasks;

class Program
{
    private static readonly byte[] _array = new byte[5];

    static void Main()
    {
        new Random(42).NextBytes(_array);
        Span<byte> span = _array;

        Task.Run( () => ClearContents() );

       EnumerateSpan(span);
    }

    public static void ClearContents()
    {
        Task.Delay(20).Wait();
        lock (_array)
        {
           Array.Clear(_array, 0, _array.Length);
        }
    }

    public static void EnumerateSpan(Span<byte> span)
    {
        foreach (byte element in span)
        {
            Console.WriteLine(element);
            Task.Delay(10).Wait();
        }
    }
}
// The example displays output like the following:
//     62
//     23
//     186
//     0
//     0

Se si sincronizza l'accesso alla matrice prima di enumerare l'intervallo, come la versione modificata del EnumerateSpan metodo nell'esempio seguente, il ClearContents metodo non modifica i dati dell'intervallo sottostante durante l'enumerazione.If you synchronize access to the array before enumerating the span, as the revised version of the EnumerateSpan method does in the following example, the ClearContents method doesn't modify underlying span data during enumeration. Si noti che nell'esempio viene bloccata la matrice sottostante su cui si basa l'intervallo.Note that the example locks the underlying array on which the span is based.

public static void EnumerateSpan(Span<byte> span)
{
    lock (_array)
    {
        foreach (byte element in span)
        {
            Console.WriteLine(element);
            Task.Delay(10).Wait();
        }
    }
}
// The example displays the following output:
//    62
//    23
//    186
//    150
//    174

A differenza di altre strutture di enumeratore in .NET, il Span<T>.Enumerator :Unlike some other enumerator structures in .NET, the Span<T>.Enumerator:

  • Non implementa l' IEnumerator interfaccia o IEnumerator<T> .Does not implement the IEnumerator or IEnumerator<T> interface. Questo è dovuto Span<T>.Enumerator al fatto che è uno struct Ref.This is because Span<T>.Enumerator is a ref struct.

  • Non include un Reset metodo, che può impostare l'enumeratore sulla relativa posizione iniziale prima del primo elemento nell'intervallo.Does not include a Reset method, which can set the enumerator to its initial position before the first element in the span. Il IEnumerator.Reset() metodo deve essere implementato come parte dell'interfaccia, ma la maggior parte degli implementatori genera un'eccezione o non fornisce alcuna implementazione.(The IEnumerator.Reset() method must be implemented as part of the interface, but most implementors either throw an exception or provide no implementation.)

Proprietà

Current

Restituisce un riferimento all'elemento in corrispondenza della posizione corrente dell'enumeratore.Gets a reference to the item at the current position of the enumerator.

Metodi

MoveNext()

Sposta l'enumeratore all'elemento successivo dell'oggetto Span<T>.Advances the enumerator to the next item of the Span<T>.

Si applica a