Span<T>.Enumerator Struct

Definitie

public: value class Span<T>::Enumerator : System::Collections::Generic::IEnumerator<T>

public: value class Span<T>::Enumerator

public ref struct Span<T>.Enumerator : System.Collections.Generic.IEnumerator<T>

public ref struct Span<T>.Enumerator

type Span<'T>.Enumerator = struct
    interface IEnumerator<'T>
    interface IEnumerator
    interface IDisposable

type Span<'T>.Enumerator = struct

Public Structure Span(Of T).Enumerator
Implements IEnumerator(Of T)

Public Structure Span(Of T).Enumerator

Type parameters

Overname

Object

ValueType

Span<T>.Enumerator

Implementeringen

IEnumerator<T> IEnumerator IDisposable

Opmerkingen

De C# foreach van de C#-taal en de Voor elke... Vervolgens constructie in Visual Basic de complexiteit van opsommingen verborgen. In plaats van de enumerator rechtstreeks te bewerken, wordt het gebruik foreach of For Each...Next aanbevolen.

In eerste instantie wordt de enumerator vóór het eerste element in de Span<T>. Op deze positie Current is niet gedefinieerd. U moet de opsomming doorschakelen MoveNext naar het eerste item in de Span<T> voordat u de waarde leest Current.

Current retourneert dezelfde waarde totdat MoveNext deze wordt aangeroepen. MoveNext wordt ingesteld Current op het volgende item in de Span<T>.

Als MoveNext het einde van de Span<T>waarde wordt doorgegeven, MoveNext wordt het resultaat geretourneerd false. Wanneer de enumerator deze status heeft, worden volgende aanroepen ook MoveNext geretourneerd false en Current is deze niet gedefinieerd. U kunt het eerste item niet Current opnieuw instellenSpan<T>. U moet in plaats daarvan een nieuw enumerator-exemplaar maken.

De enumerator heeft geen exclusieve toegang tot de Span<T>. Daarnaast kunnen ook de onderliggende gegevens waarop de spanwijdte is gebaseerd, worden gewijzigd. Daarom is het intrinsiek niet een thread-veilige procedure om een span te inventariseren. Als u de veiligheid van threads tijdens de inventarisatie wilt garanderen, moet u uw eigen synchronisatie implementeren. De volgende code heeft bijvoorbeeld een racevoorwaarde. Het zorgt er niet voor dat de periode wordt geïnventariseerd voordat de ClearContents methode wordt uitgevoerd. Als gevolg hiervan wordt de onderliggende matrix gewist tijdens de inventarisatie van de periode:

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

module Program

open System
open System.Threading.Tasks

let array = Array.zeroCreate<byte> 5

let clearContents () =
    Task.Delay(20).Wait()
    lock array (fun () -> 
        Array.Clear(array, 0, array.Length) )

let enumerateSpan (span: Span<byte>) =
    for element in span do
        printfn $"{element}"
        Task.Delay(10).Wait()

[<EntryPoint>]
let main _ =
    Random(42).NextBytes array
    printfn "%A" array
    let span: Span<byte> = array

    Task.Run clearContents |> ignore

    enumerateSpan span
    
    0

// The example displays output like the following:
//     62
//     23
//     186
//     0
//     0

Als u de toegang tot de matrix synchroniseert voordat u de periode opsommen, zoals de herziene versie van de EnumerateSpan methode in het volgende voorbeeld doet, ClearContents worden de onderliggende spangegevens tijdens de inventarisatie niet gewijzigd. Houd er rekening mee dat in het voorbeeld de onderliggende matrix wordt vergrendeld waarop de spanwijdte is gebaseerd.

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

let enumerateSpan (span: Span<byte>) =
    // Spans cannot be accessed in closures including in the F# lock function.
    // Monitor.Enter and Monitor.Exit are used here directly.
    Monitor.Enter array
    try
        for element in span do
            printfn $"{element}"
            Task.Delay(10).Wait()
    finally
        Monitor.Exit array
// The example displays the following output:
//    62
//    23
//    186
//    150
//    174

In tegenstelling tot andere enumeratorstructuren in .NET, wordt de Span<T>.Enumerator:

• Implementeert de IEnumerator of IEnumerator<T> interface niet. Dit komt omdat Span<T>.Enumerator het een refstruct is.

• Bevat geen Reset methode, die de enumerator kan instellen op de oorspronkelijke positie vóór het eerste element in de periode. (De IEnumerator.Reset() methode moet worden geïmplementeerd als onderdeel van de interface, maar de meeste implementors genereren een uitzondering of bieden geen implementatie.)