Strokes.StrokesEnumerator.Current, propriété

Article
11/05/2008

Mise à jour : November 2007

Obtient l'objet Stroke dans la collection Strokes sur laquelle l'énumérateur pointe.

Espace de noms : Microsoft.Ink
Assembly : Microsoft.Ink (dans Microsoft.Ink.dll)

Syntaxe

'Déclaration
Public ReadOnly Property Current As Stroke
'Utilisation
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

Valeur de propriété

Type : Microsoft.Ink.Stroke
Objet Stroke dans la collection Strokes sur laquelle l'énumérateur pointe.

Notes

Après la création d'un énumérateur Strokes.StrokesEnumerator ou un appel à la méthode Reset, vous devez appeler la méthode MoveNext pour avancer l'énumérateur au premier élément de la collection avant la lecture de la valeur de la propriété Current ; sinon, la propriété Current n'est pas définie.

La propriété Current lève une exception si le dernier appel à la méthode MoveNext retourne false. Si le dernier appel à la méthode MoveNext retourne la valeur false, l'énumérateur a atteint la fin de la collection Strokes.

La propriété Current ne déplace pas l'énumérateur. Les appels consécutifs à la propriété Current retournent le même objet jusqu'à l'appel à la méthode MoveNext ou Reset.

Un énumérateur reste valide aussi longtemps que la collection demeure inchangée. Si la collection est modifiée par l'ajout, la modification ou la suppression des éléments, l'énumérateur devient définitivement non valide. L'appel suivant à la méthode MoveNext ou Reset lève une exception InvalidOperationException (page pouvant être en anglais). Si la collection est modifiée entre l'appel à la méthode MoveNext et l'appel à la propriété Current, la propriété Current retourne l'élément défini comme sa valeur, même si l'énumérateur est déjà non valide.

Exemples

Ces exemples présentent deux façons d'énumérer la collection Strokes pour récupérer chaque objet Stroke de la collection. La collection Strokes est retournée par la propriété Ink.Strokes.

Cet exemple obtient le IEnumerator pour la collection Strokes et l'utilise pour parcourir celle-ci.

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

Cet exemple utilise l'instruction foreach, qui appelle la méthode GetEnumerator dans le code interne que le compilateur génère pour prendre en charge l'instruction.

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

Plateformes

Windows Vista

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.