Proprietà Strokes.StrokesEnumerator.Current

Articolo
10/29/2008

Aggiornamento: novembre 2007

Ottiene l'oggetto Stroke nell'insieme Strokes a cui l'enumerazione sta puntando.

Spazio dei nomi: Microsoft.Ink
Assembly: Microsoft.Ink (in Microsoft.Ink.dll)

Sintassi

'Dichiarazione
Public ReadOnly Property Current As Stroke
'Utilizzo
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

Valore proprietà

Tipo: Microsoft.Ink.Stroke
Oggetto Stroke nell'insieme Strokes a cui l'enumerazione sta puntando.

Note

Dopo aver creato un enumeratore Strokes.StrokesEnumerator o dopo avere chiamato il metodo Reset, è necessario chiamare il metodo MoveNext per spostare in avanti l'enumeratore in corrispondenza del primo elemento dell'insieme, prima di leggere il valore della proprietà Current; in caso contrario, la proprietà Current non è definita.

La proprietà Current genera un'eccezione se l'ultima chiamata al metodo MoveNext restituisce false. Se l'ultima chiamata al metodo MoveNext restituisce false, l'enumeratore ha raggiunto la fine dell'insieme Strokes.

La proprietà Current non sposta la posizione dell'enumeratore. Le chiamate consecutive alla proprietà Current restituiscono lo stesso oggetto, fino a quando non viene chiamato il metodo MoveNext o Reset.

Un enumeratore rimane valido fino a quando l'insieme rimane invariato. Se vengono apportate modifiche all'insieme, ad esempio l'aggiunta, la modifica o l'eliminazione di elementi, l'enumeratore verrà invalidato in modo irreversibile. La successiva chiamata a MoveNext o al metodo Reset genera un'eccezione InvalidOperationException. Se l'insieme viene modificato tra la chiamata al metodo MoveNext e la chiamata alla proprietà Current, la proprietà Current restituisce l'elemento sul quale è impostata, anche se l'enumeratore è già stato invalidato.

Esempi

In questi esempi vengono presentate due modalità per enumerare l'insieme Strokes allo scopo di recuperare ogni oggetto Stroke contenuto nell'insieme. L'insieme Strokes viene restituito dalla proprietà Ink.Strokes.

In questo esempio si ottiene l'oggetto IEnumerator per l'insieme Strokes e lo si utilizza per attraversare l'insieme.

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);
        }
    }
}

In questo esempio viene utilizzata l'istruzione foreach che chiama il metodo GetEnumerator nel codice interno generato dal compilatore per supportare l'istruzione.

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);
        }
    }
}

Piattaforme

Windows Vista

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.