Span<T>.Enumerator Estrutura

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

Span.cs

Fornece um enumerador para os elementos de um Span<T>.

public: value class Span<T>::Enumerator

public ref struct Span<T>.Enumerator

type Span<'T>.Enumerator = struct

Public Structure Span(Of T).Enumerator

Parâmetros de tipo

T

Herança

Object

ValueType

Span<T>.Enumerator

Comentários

O foreach do C# da linguagem C# e o for each... O próximo constructo no Visual Basic oculta a complexidade dos enumeradores. Em vez de manipular diretamente o enumerador, é recomendável usar foreach ou For Each...Next .

Inicialmente, o enumerador é posicionado antes do primeiro elemento no Span<T>. Nesta posição, Current está indefinido. Você deve chamar MoveNext para avançar o enumerador para o primeiro item no Span<T> antes de ler o valor de Current.

Current retorna o mesmo valor até MoveNext que seja chamado. MoveNext define Current como o próximo item no Span<T>.

Se MoveNext passar o final do Span<T>, MoveNext retornará false. Quando o enumerador está nesse estado, as chamadas subsequentes para MoveNext também retornam false e Current são indefinidas. Não é possível definir Current como o primeiro item no Span<T> novamente; em vez disso, você deve criar uma nova instância de enumerador.

O enumerador não tem acesso exclusivo ao Span<T>. Além disso, os dados subjacentes nos quais o intervalo se baseia também podem ser modificados. Portanto, enumerar por meio de um intervalo não é intrinsecamente um procedimento thread-safe. Para garantir a segurança do thread durante a enumeração, você deve implementar sua própria sincronização. Por exemplo, o código a seguir tem uma condição de corrida. Ele não garante que o intervalo será enumerado antes da execução do ClearContents método. Como resultado, a matriz subjacente é limpa durante a enumeração do intervalo:

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

Se você sincronizar o acesso à matriz antes de enumerar o intervalo, como a versão revisada do EnumerateSpan método faz no exemplo a seguir, o ClearContents método não modifica os dados de span subjacentes durante a enumeração. Observe que o exemplo bloqueia a matriz subjacente na qual o intervalo se baseia.

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

Ao contrário de algumas outras estruturas de enumerador no .NET, o Span<T>.Enumerator:

• Não implementa a IEnumerator interface ou IEnumerator<T> . Isso ocorre porque Span<T>.Enumerator é um struct ref.

• Não inclui um Reset método , que pode definir o enumerador como sua posição inicial antes do primeiro elemento no intervalo. (O IEnumerator.Reset() método deve ser implementado como parte da interface, mas a maioria dos implementadores gera uma exceção ou não fornece nenhuma implementação.)

Propriedades

Current

Obtém uma referência ao item na posição atual do enumerador.

Métodos

MoveNext()

Avança o enumerador para o próximo item do Span<T>.