Strokes.StrokesEnumerator.Current (Propiedad)

Artículo
11/26/2008

Actualización: noviembre 2007

Obtiene el objeto Stroke de la colección Strokes a la que señala el enumerador.

Espacio de nombres: Microsoft.Ink
Ensamblado: Microsoft.Ink (en Microsoft.Ink.dll)

Sintaxis

'Declaración
Public ReadOnly Property Current As Stroke
'Uso
Dim instance As Strokes..::.StrokesEnumerator
Dim value As Stroke

value = instance.Current

public Stroke Current { get; }

public:
property Stroke^ Current {
    Stroke^ get ();
}

/** @property */
public Stroke get_Current()

public function get Current () : Stroke

Valor de propiedad

Tipo: Microsoft.Ink.Stroke
Objeto Stroke de la colección Strokes a la que señala el enumerador.

Comentarios

Después de crear un enumerador Strokes.StrokesEnumerator, o después de llamar al método Reset, es necesario llamar al método MoveNext para desplazar el enumerador hasta el primer elemento de la colección antes de leer el valor de la propiedad Current; de lo contrario, la propiedad Current queda sin definir.

La propiedad Current genera una excepción si la última llamada al método MoveNext devuelve false. Si la última llamada al método MoveNext devuelve false, significa que el enumerador ha llegado al final de la colección Strokes.

La propiedad Current no desplaza la posición del enumerador. Las llamadas consecutivas a la propiedad Current devuelven el mismo objeto hasta que se llama a cualquiera de los métodos MoveNext o Reset.

Un enumerador es válido mientras la colección no experimenta cambios. Si se realizan cambios en la colección, como agregar, modificar o eliminar elementos, el enumerador se invalida definitivamente. La siguiente llamada al método MoveNext o Reset genera una excepción InvalidOperationException. Si se modifica la colección entre la llamada al método MoveNext y la llamada a la propiedad Current, la propiedad Current devuelve el elemento en el que se ha establecido, aunque el enumerador ya esté invalidado.

Ejemplos

En estos ejemplos se muestran dos formas de enumerar la colección Strokes para recuperar cada uno de los objetos Stroke incluidos en la colección. La propiedad Ink.Strokes devuelve la colección Strokes.

En este ejemplo se obtiene el objeto IEnumerator de la colección Strokes y se usa para recorrer la colección.

Private Sub EnumerateStrokesWithEnumerator(ByVal mInk As Ink)
    ' access the Strokes property via using statement
    ' to insure that the object mStrokes is disposed when finished
    ' Otherwise, you will have a memory leak
    Using mStrokes As Strokes = mInk.Strokes
        Dim mStrokesEnumerator As IEnumerator = mStrokes.GetEnumerator()
        mStrokesEnumerator.Reset()
        While (mStrokesEnumerator.MoveNext())
            Dim S As Stroke = DirectCast(mStrokesEnumerator.Current, Stroke)
            Me.listBoxStrokeId.Items.Add(S.Id)
        End While
    End Using
End Sub

private void EnumerateStrokesWithEnumerator(Ink mInk)
{
    // access the Strokes property via using statement
    // to insure that the object mStrokes is disposed when finished
    // Otherwise, you will have a memory leak
    using (Strokes mStrokes = mInk.Strokes)
    {
        IEnumerator mStrokesEnumerator = mStrokes.GetEnumerator();
        mStrokesEnumerator.Reset();
        while (mStrokesEnumerator.MoveNext())
        {
            Stroke S = (Stroke)mStrokesEnumerator.Current;
            this.listBoxStrokeId.Items.Add(S.Id);
        }
    }
}

En este ejemplo se usa la instrucción foreach, que llama al método GetEnumerator en el código interno que el compilador genera para admitir la instrucción.

Private Sub EnumerateStrokesWithForEach(ByVal mInk As Ink)
    ' access the Strokes property via using statement
    ' to insure that the object mStrokes is disposed when finished
    ' Otherwise, you will have a memory leak
    Using mStrokes As Strokes = mInk.Strokes
        For Each S As Stroke In mStrokes
            Me.listBoxStrokeId.Items.Add(S.Id)
        Next
    End Using
End Sub

private void EnumerateStrokesWithForEach(Ink mInk)
{    
    // access the Strokes property via using statement
    // to insure that the object mStrokes is disposed when finished
    // Otherwise, you will have a memory leak
    using (Strokes mStrokes = mInk.Strokes)
    {
        foreach (Stroke S in mStrokes)
        {
            this.listBoxStrokeId.Items.Add(S.Id);
        }
    }
}

Plataformas

Windows Vista

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.