Span<T>.Enumerator Estructura

Definición

Proporciona un enumerador para los elementos de 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

Parámetros de tipo

T
Herencia
Span<T>.Enumerator

Comentarios

El C# foreach del C# lenguaje y la instrucción for each... La siguiente construcción de Visual Basic oculta la complejidad de los enumeradores.The C# foreach of the C# language and the For Each...Next construct in Visual Basic hides the complexity of enumerators. En lugar de manipular directamente el enumerador, se foreach recomienda For Each...Next usar o.Instead of directly manipulating the enumerator, using foreach or For Each...Next is recommended.

Inicialmente, el enumerador se coloca delante del primer elemento de Span<T>.Initially, the enumerator is positioned before the first element in the Span<T>. En esta posición, el valor de propiedad Current está sin definir.At this position, Current is undefined. Debe llamar MoveNext a para avanzar el enumerador hasta el primer elemento Span<T> de antes de leer el valor Currentde.You must call MoveNext to advance the enumerator to the first item in the Span<T> before reading the value of Current.

CurrentDevuelve el mismo valor hasta MoveNext que se llama a.Current returns the same value until MoveNext is called. MoveNextestablece Current en el siguiente elemento Span<T>de.MoveNext sets Current to the next item in the Span<T>.

Si MoveNext pasa el final Span<T>de, MoveNext devuelve false.If MoveNext passes the end of the Span<T>, MoveNext returns false. Cuando el enumerador está en este estado, las llamadas MoveNext subsiguientes Current a también devuelven false y no están definidas.When the enumerator is at this state, subsequent calls to MoveNext also return false and Current is undefined. No se puede Current establecer en el primer elemento del Span<T> de nuevo; en su lugar, debe crear una nueva instancia de enumerador.You cannot set Current to the first item in the Span<T> again; you must create a new enumerator instance instead.

El enumerador no tiene acceso exclusivo a Span<T>.The enumerator does not have exclusive access to the Span<T>. Además, los datos subyacentes en los que se basa el intervalo también se pueden modificar.In addition, the underlying data on which the span is based can also be modified. Por lo tanto, la enumeración a través de un intervalo no es intrínsecamente un procedimiento seguro para subprocesos.Therefore, enumerating through a span is intrinsically not a thread-safe procedure. Para garantizar la seguridad para subprocesos durante la enumeración, debe implementar su propia sincronización.To guarantee thread safety during enumeration, you must implement your own synchronization. Por ejemplo, el código siguiente tiene una condición de carrera.For example, the following code has a race condition. No garantiza que el intervalo se enumerará antes de que se ejecute ClearContents el método.It does not ensure that the span will be enumerated before the ClearContents method executes. Como resultado, la matriz subyacente se borra durante la enumeración del intervalo: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

Si sincroniza el acceso a la matriz antes de enumerar el intervalo, como la versión revisada del EnumerateSpan método, en el ejemplo siguiente, el método no modifica los datos de ClearContents intervalo subyacentes durante la enumeración.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. Tenga en cuenta que en el ejemplo se bloquea la matriz subyacente en la que se basa el intervalo.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 diferencia de otras estructuras de enumerador en .NET Span<T>.Enumerator,:Unlike some other enumerator structures in .NET, the Span<T>.Enumerator:

  • No implementa la IEnumerator interfaz o IEnumerator<T> .Does not implement the IEnumerator or IEnumerator<T> interface. Esto se debe Span<T>.Enumerator a que es una estructura Ref.This is because Span<T>.Enumerator is a ref struct.

  • No incluye un Reset método, que puede establecer el enumerador en su posición inicial delante del primer elemento del intervalo.Does not include a Reset method, which can set the enumerator to its initial position before the first element in the span. (El IEnumerator.Reset() método debe implementarse como parte de la interfaz, pero la mayoría de los implementadores producen una excepción o no proporcionan ninguna implementación).(The IEnumerator.Reset() method must be implemented as part of the interface, but most implementors either throw an exception or provide no implementation.)

Propiedades

Current

Obtiene una referencia al elemento en la posición actual del enumerador.Gets a reference to the item at the current position of the enumerator.

Métodos

MoveNext()

Desplaza el enumerador al siguiente elemento de Span<T>.Advances the enumerator to the next item of the Span<T>.

Se aplica a