For Each...Next, instruction (Visual Basic)For Each...Next Statement (Visual Basic)

Répète un groupe d’instructions pour chaque élément dans une collection.Repeats a group of statements for each element in a collection.

SyntaxeSyntax

For Each element [ As datatype ] In group  
    [ statements ]  
    [ Continue For ]  
    [ statements ]  
    [ Exit For ]  
    [ statements ]  
Next [ element ]  

ComposantsParts

TermeTerm DéfinitionDefinition
element Requis dans le For Each instruction.Required in the For Each statement. Facultatif dans la Next instruction.Optional in the Next statement. Variable.Variable. Utilisé pour itérer sur les éléments de la collection.Used to iterate through the elements of the collection.
datatype Obligatoire si element n’est pas déjà déclaré.Required if element isn't already declared. Type de données de element.Data type of element.
group Obligatoire.Required. Une variable avec un type qui est un type de collection ou d’un objet.A variable with a type that's a collection type or Object. Fait référence à la collection sur laquelle le statements doivent être répétées.Refers to the collection over which the statements are to be repeated.
statements Facultatif.Optional. Une ou plusieurs instructions entre For Each et Next qui s’exécutent sur chaque élément de group.One or more statements between For Each and Next that run on each item in group.
Continue For Facultatif.Optional. Transfère le contrôle au début de la For Each boucle.Transfers control to the start of the For Each loop.
Exit For Facultatif.Optional. Transfère le contrôle de le For Each boucle.Transfers control out of the For Each loop.
Next Obligatoire.Required. Termine la définition de la For Each boucle.Terminates the definition of the For Each loop.

Exemple simpleSimple Example

Utilisez un For Each... Next boucle lorsque vous souhaitez répéter un ensemble d’instructions pour chaque élément d’une collection ou un tableau.Use a For Each...Next loop when you want to repeat a set of statements for each element of a collection or array.

Conseil

A pour... L’instruction suivante fonctionne bien lorsque vous pouvez associer chaque itération d’une boucle à une variable de contrôle et déterminer les valeurs initiale et finale de cette variable.A For...Next Statement works well when you can associate each iteration of a loop with a control variable and determine that variable's initial and final values. Toutefois, lorsque vous êtes confronté à une collection, le concept de valeurs initiales et finales n’est pas significatif, et vous ne connaissez pas forcément la collection est le nombre d’éléments.However, when you are dealing with a collection, the concept of initial and final values isn't meaningful, and you don't necessarily know how many elements the collection has. Dans ce type de cas, un For Each... Next boucle est souvent un meilleur choix.In this kind of case, a For Each...Next loop is often a better choice.

Dans l’exemple suivant, la For Each...NextIn the following example, the For EachNext instruction effectue une itération dans tous les éléments d’une collection de listes.statement iterates through all the elements of a List collection.

' Create a list of strings by using a
' collection initializer.
Dim lst As New List(Of String) _
    From {"abc", "def", "ghi"}

' Iterate through the list.
For Each item As String In lst
    Debug.Write(item & " ")
Next
Debug.WriteLine("")
'Output: abc def ghi

Pour plus d’exemples, consultez Collections et tableaux.For more examples, see Collections and Arrays.

Boucles imbriquéesNested Loops

Vous pouvez imbriquer For Each boucles en plaçant une boucle à l’intérieur d’une autre.You can nest For Each loops by putting one loop within another.

L’exemple suivant illustre des structures For Each...NextThe following example demonstrates nested For EachNext structures.structures.

' Create lists of numbers and letters
' by using array initializers.
Dim numbers() As Integer = {1, 4, 7}
Dim letters() As String = {"a", "b", "c"}

' Iterate through the list by using nested loops.
For Each number As Integer In numbers
    For Each letter As String In letters
        Debug.Write(number.ToString & letter & " ")
    Next
Next
Debug.WriteLine("")
'Output: 1a 1b 1c 4a 4b 4c 7a 7b 7c 

Lorsque vous imbriquez des boucles, chaque boucle doit posséder un unique element variable.When you nest loops, each loop must have a unique element variable.

Vous pouvez également imbriquer des différents types de structures de contrôle dans d’autres.You can also nest different kinds of control structures within each other. Pour plus d’informations, consultez Structures de contrôle imbriquées.For more information, see Nested Control Structures.

Pour et continuez pourExit For and Continue For

Le Exit For instruction provoque l’exécution quitter le For...NextThe Exit For statement causes execution to exit the ForNext boucle et les transfère le contrôle à l’instruction qui suit la Next instruction.loop and transfers control to the statement that follows the Next statement.

La Continue For instruction transfère le contrôle immédiatement à l’itération suivante de la boucle.The Continue For statement transfers control immediately to the next iteration of the loop. Pour plus d’informations, consultez instruction Continue.For more information, see Continue Statement.

L’exemple suivant montre comment utiliser le Continue For et Exit For instructions.The following example shows how to use the Continue For and Exit For statements.

Dim numberSeq() As Integer =
    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

For Each number As Integer In numberSeq
    ' If number is between 5 and 7, continue
    ' with the next iteration.
    If number >= 5 And number <= 8 Then
        Continue For
    End If

    ' Display the number.
    Debug.Write(number.ToString & " ")

    ' If number is 10, exit the loop.
    If number = 10 Then
        Exit For
    End If
Next
Debug.WriteLine("")
' Output: 1 2 3 4 9 10

Vous pouvez placer n’importe quel nombre de Exit For instructions dans un For Each boucle.You can put any number of Exit For statements in a For Each loop. Lorsqu’il est utilisé dans imbriqués For Each boucles, Exit For quitte le contrôle le plus profond et transfère au niveau d’imbrication supérieur suivant.When used within nested For Each loops, Exit For causes execution to exit the innermost loop and transfers control to the next higher level of nesting.

Exit Forest souvent utilisé après l’évaluation d’une condition, par exemple, dans un If... Then... Else structure.Exit For is often used after an evaluation of some condition, for example, in an If...Then...Else structure. Vous souhaiterez peut-être utiliser Exit For dans les cas suivants :You might want to use Exit For for the following conditions:

  • Pour continuer à effectuer une itération est inutile ou impossible.Continuing to iterate is unnecessary or impossible. Cela peut être dû à une valeur erronée ou une demande d’arrêt.This might be caused by an erroneous value or a termination request.

  • Une exception est interceptée dans un Try... Catch... Finally. Vous pouvez utiliser Exit For à la fin de la Finally bloc.An exception is caught in a Try...Catch...Finally. You might use Exit For at the end of the Finally block.

  • Il existe une boucle infinie, ce qui est une boucle qui pourrait exécuter un importantes ou infini même le nombre de fois.There an endless loop, which is a loop that could run a large or even infinite number of times. Si vous détectez une telle condition, vous pouvez utiliser Exit For pour abandonner la boucle.If you detect such a condition, you can use Exit For to escape the loop. Pour plus d’informations, consultez faire... Instruction de boucle.For more information, see Do...Loop Statement.

IteratorsIterators

Vous utilisez un itérateur pour effectuer une itération personnalisée sur une collection.You use an iterator to perform a custom iteration over a collection. Un itérateur peut être une fonction ou un Get accesseur.An iterator can be a function or a Get accessor. Il utilise un Yield instruction pour retourner chaque élément de la collection un à la fois.It uses a Yield statement to return each element of the collection one at a time.

Vous appelez un itérateur en utilisant un For Each...Next instruction.You call an iterator by using a For Each...Next statement. Chaque itération de la boucle For Each appelle l’itérateur.Each iteration of the For Each loop calls the iterator. Quand un Yield instruction est atteint dans l’itérateur, l’expression dans la Yield instruction est retournée et l’emplacement actuel dans le code est conservé.When a Yield statement is reached in the iterator, the expression in the Yield statement is returned, and the current location in code is retained. L’exécution est redémarrée à partir de cet emplacement la prochaine fois que l’itérateur est appelé.Execution is restarted from that location the next time that the iterator is called.

L’exemple suivant utilise une fonction d’itérateur.The following example uses an iterator function. La fonction d’itérateur a un Yield instruction qui se trouve dans un pour... Suivant boucle.The iterator function has a Yield statement that's inside a For…Next loop. Dans le ListEvenNumbers (méthode), chaque itération de la For Each corps de l’instruction crée un appel à la fonction d’itérateur, qui passe à la prochaine Yield instruction.In the ListEvenNumbers method, each iteration of the For Each statement body creates a call to the iterator function, which proceeds to the next Yield statement.

Public Sub ListEvenNumbers()
    For Each number As Integer In EvenSequence(5, 18)
        Debug.Write(number & " ")
    Next
    Debug.WriteLine("")
    ' Output: 6 8 10 12 14 16 18
End Sub

Private Iterator Function EvenSequence(
ByVal firstNumber As Integer, ByVal lastNumber As Integer) _
As System.Collections.Generic.IEnumerable(Of Integer)

    ' Yield even numbers in the range.
    For number = firstNumber To lastNumber
        If number Mod 2 = 0 Then
            Yield number
        End If
    Next
End Function

Pour plus d’informations, consultez itérateurs, instruction Yield, et itérateur.For more information, see Iterators, Yield Statement, and Iterator.

Implémentation techniqueTechnical Implementation

Lorsqu’un For Each...NextWhen a For EachNext instruction s’exécute, Visual Basic évalue la collection qu’une seule fois, avant le démarrage de la boucle.statement runs, Visual Basic evaluates the collection only one time, before the loop starts. Si votre bloc d’instructions modifie element ou group, ces modifications n’affectent pas l’itération de la boucle.If your statement block changes element or group, these changes don't affect the iteration of the loop.

Lorsque tous les éléments de la collection ont été assignés successivement à element, le For Each boucle s’arrête et le contrôle passe à l’instruction qui suit la Next instruction.When all the elements in the collection have been successively assigned to element, the For Each loop stops and control passes to the statement following the Next statement.

Si element n’a pas été déclarée en dehors de cette boucle, vous devez la déclarer dans le For Each instruction.If element hasn't been declared outside this loop, you must declare it in the For Each statement. Vous pouvez déclarer le type de element explicitement en utilisant un As instruction, ou vous pouvez compter sur l’inférence de type pour assigner le type.You can declare the type of element explicitly by using an As statement, or you can rely on type inference to assign the type. Dans les deux cas, la portée de element est le corps de la boucle.In either case, the scope of element is the body of the loop. Toutefois, vous ne pouvez pas déclarer element à la fois à l’extérieur et à l’intérieur de la boucle.However, you cannot declare element both outside and inside the loop.

Vous pouvez éventuellement spécifier element dans la Next instruction.You can optionally specify element in the Next statement. Cela améliore la lisibilité de votre programme, surtout si vous avez imbriqué For Each boucles.This improves the readability of your program, especially if you have nested For Each loops. Vous devez spécifier la même variable que celle qui s’affiche dans le For Each instruction.You must specify the same variable as the one that appears in the corresponding For Each statement.

Vous souhaiterez peut-être éviter de modifier la valeur de element à l’intérieur d’une boucle.You might want to avoid changing the value of element inside a loop. Cela peut rendre plus difficile à lire et déboguer votre code.Doing this can make it more difficult to read and debug your code. Modification de la valeur de group n’affecte pas la collection ou ses éléments qui ont été déterminées lors de la première entrée de la boucle.Changing the value of group doesn't affect the collection or its elements, which were determined when the loop was first entered.

Lorsque vous êtes imbrication de boucles, si un Next d’un niveau d’imbrication externe est rencontrée avant la Next d’un niveau interne, le compilateur signale une erreur.When you're nesting loops, if a Next statement of an outer nesting level is encountered before the Next of an inner level, the compiler signals an error. Toutefois, le compilateur peut détecter cette erreur de chevauchement uniquement si vous spécifiez element dans chaque Next instruction.However, the compiler can detect this overlapping error only if you specify element in every Next statement.

Si votre code dépend du parcours d’une collection dans un ordre particulier, un For Each... Next boucle n’est pas le meilleur choix, sauf si vous connaissez les caractéristiques de l’objet énumérateur exposé par la collection.If your code depends on traversing a collection in a particular order, a For Each...Next loop isn't the best choice, unless you know the characteristics of the enumerator object the collection exposes. L’ordre de parcours n’est pas déterminé par Visual Basic, mais par le MoveNext méthode de l’objet énumérateur.The order of traversal isn't determined by Visual Basic, but by the MoveNext method of the enumerator object. Par conséquent, vous ne pouvez peut-être pas prédire quel élément de la collection est le premier à être retournée dans element, ou qui est le suivant renvoyé après un élément donné.Therefore, you might not be able to predict which element of the collection is the first to be returned in element, or which is the next to be returned after a given element. Vous pouvez obtenir des résultats plus fiables à l’aide d’une structure de boucle différente, comme For... Next ou Do... Loop.You might achieve more reliable results using a different loop structure, such as For...Next or Do...Loop.

Type de données de element doit être tel que le type de données des éléments de group peut être converti en il.The data type of element must be such that the data type of the elements of group can be converted to it.

Type de données de group doit être un type référence qui fait référence à une collection ou un tableau qui est énumérable.The data type of group must be a reference type that refers to a collection or an array that's enumerable. Plus souvent, cela signifie que group fait référence à un objet qui implémente le IEnumerable interface de la System.Collections espace de noms ou le IEnumerable<T> interface de le System.Collections.Generic espace de noms.Most commonly this means that group refers to an object that implements the IEnumerable interface of the System.Collections namespace or the IEnumerable<T> interface of the System.Collections.Generic namespace. System.Collections.IEnumerabledéfinit le GetEnumerator (méthode), qui retourne un objet énumérateur pour la collection.System.Collections.IEnumerable defines the GetEnumerator method, which returns an enumerator object for the collection. L’objet énumérateur implémente la System.Collections.IEnumerator interface de la System.Collections espace de noms et expose le Current propriété et la Reset et MoveNext méthodes.The enumerator object implements the System.Collections.IEnumerator interface of the System.Collections namespace and exposes the Current property and the Reset and MoveNext methods. Visual Basic utilise pour parcourir la collection.Visual Basic uses these to traverse the collection.

conversions restrictivesNarrowing Conversions

Lorsque Option Strict a la valeur On, les conversions restrictives provoquent ordinairement des erreurs du compilateur.When Option Strict is set to On, narrowing conversions ordinarily cause compiler errors. Dans un For Each instruction, toutefois, les conversions à partir des éléments dans group à element sont évaluées et exécutées au moment de l’exécution, et les erreurs du compilateur provoquées par les conversions restrictives sont supprimées.In a For Each statement, however, conversions from the elements in group to element are evaluated and performed at run time, and compiler errors caused by narrowing conversions are suppressed.

Dans l’exemple suivant, l’affectation de m comme valeur initiale pour n ne se compile pas lorsque Option Strict est activé, car la conversion d’un Long à un Integer est une conversion restrictive.In the following example, the assignment of m as the initial value for n doesn't compile when Option Strict is on because the conversion of a Long to an Integer is a narrowing conversion. Dans le For Each instruction, toutefois, aucune erreur du compilateur n’est signalée, même si l’assignation à number nécessite la même conversion de Long à Integer.In the For Each statement, however, no compiler error is reported, even though the assignment to number requires the same conversion from Long to Integer. Dans le For Each se produit une erreur d’exécution de l’instruction qui contient un grand nombre, lorsque ToInteger est appliqué à un grand nombre.In the For Each statement that contains a large number, a run-time error occurs when ToInteger is applied to the large number.

Option Strict On

Module Module1
    Sub Main()
        ' The assignment of m to n causes a compiler error when 
        ' Option Strict is on.
        Dim m As Long = 987
        'Dim n As Integer = m

        ' The For Each loop requires the same conversion but
        ' causes no errors, even when Option Strict is on.
        For Each number As Integer In New Long() {45, 3, 987}
            Console.Write(number & " ")
        Next
        Console.WriteLine()
        ' Output: 45 3 987

        ' Here a run-time error is raised because 9876543210
        ' is too large for type Integer.
        'For Each number As Integer In New Long() {45, 3, 9876543210}
        '    Console.Write(number & " ")
        'Next

        Console.ReadKey()
    End Sub
End Module

Appels IEnumeratorIEnumerator Calls

Lors de l’exécution d’un For Each... Next commence, Visual Basic vérifie que group fait référence à un objet de collection valide.When execution of a For Each...Next loop starts, Visual Basic verifies that group refers to a valid collection object. Si ce n’est pas le cas, elle lève une exception.If not, it throws an exception. Sinon, elle appelle la MoveNext (méthode) et le Current propriété de l’objet énumérateur pour retourner le premier élément.Otherwise, it calls the MoveNext method and the Current property of the enumerator object to return the first element. Si MoveNext indique qu’il n’existe aucun élément suivant, autrement dit, si la collection est vide, le For Each boucle s’arrête et le contrôle passe à l’instruction qui suit la Next instruction.If MoveNext indicates that there is no next element, that is, if the collection is empty, the For Each loop stops and control passes to the statement following the Next statement. Dans le cas contraire, Visual Basic définit element au premier élément et exécute le bloc d’instructions.Otherwise, Visual Basic sets element to the first element and runs the statement block.

Chaque fois que Visual Basic rencontre le Next instruction, il renvoie à la For Each instruction.Each time Visual Basic encounters the Next statement, it returns to the For Each statement. Il appelle de nouveau MoveNext et Current pour retourner l’élément suivant, puis exécute le bloc soit arrête la boucle en fonction du résultat.Again it calls MoveNext and Current to return the next element, and again it either runs the block or stops the loop depending on the result. Ce processus se poursuit jusqu'à ce que MoveNext indique qu’il n’existe aucun élément suivant ou Exit For est rencontrée.This process continues until MoveNext indicates that there is no next element or an Exit For statement is encountered.

Modification de la Collection.Modifying the Collection. L’objet énumérateur retourné par GetEnumerator ne vous permettent de modifier la collection par l’ajout, de suppression, de remplacement ou de réorganisation d’éléments.The enumerator object returned by GetEnumerator normally doesn't let you change the collection by adding, deleting, replacing, or reordering any elements. Si vous modifiez la collection après avoir lancé une For Each... Next boucle, l’objet énumérateur devienne non valide, et la prochaine tentative d’accéder à un élément provoque une InvalidOperationException exception.If you change the collection after you have initiated a For Each...Next loop, the enumerator object becomes invalid, and the next attempt to access an element causes an InvalidOperationException exception.

Toutefois, ce blocage de modification n’est pas déterminé par Visual BasicVisual Basic, mais plutôt par l’implémentation de la IEnumerable interface.However, this blocking of modification isn't determined by Visual BasicVisual Basic, but rather by the implementation of the IEnumerable interface. Il est possible d’implémenter IEnumerable d’une manière qui autorise la modification pendant l’itération.It is possible to implement IEnumerable in a way that allows for modification during iteration. Si vous comptez effectuer cette modification dynamique, assurez-vous que vous comprenez les caractéristiques de la IEnumerable implémentation sur la collection que vous utilisez.If you are considering doing such dynamic modification, make sure that you understand the characteristics of the IEnumerable implementation on the collection you are using.

Modification des éléments de la Collection.Modifying Collection Elements. Le Current la propriété de l’objet énumérateur est ReadOnly, et retourne une copie locale de chaque élément de la collection.The Current property of the enumerator object is ReadOnly, and it returns a local copy of each collection element. Cela signifie que vous ne pouvez pas modifier les éléments dans un For Each... Next boucle.This means that you cannot modify the elements themselves in a For Each...Next loop. Toute modification apportée affecte uniquement la copie locale de Current et n’est pas répercutée dans la collection sous-jacente.Any modification you make affects only the local copy from Current and isn't reflected back into the underlying collection. Toutefois, si un élément est un type référence, vous pouvez modifier les membres de l’instance vers laquelle il pointe.However, if an element is a reference type, you can modify the members of the instance to which it points. L’exemple suivant modifie le BackColor membre de chaque thisControl élément.The following example modifies the BackColor member of each thisControl element. Toutefois, vous ne pouvez pas modifier thisControl lui-même.You cannot, however, modify thisControl itself.

Sub lightBlueBackground(ByVal thisForm As System.Windows.Forms.Form)  
    For Each thisControl As System.Windows.Forms.Control In thisForm.Controls  
        thisControl.BackColor = System.Drawing.Color.LightBlue  
    Next thisControl  
End Sub  

L’exemple précédent peut modifier le BackColor membre de chaque thisControl élément, bien qu’il ne peut pas modifier thisControl lui-même.The previous example can modify the BackColor member of each thisControl element, although it cannot modify thisControl itself.

Parcours de tableaux.Traversing Arrays. Étant donné que la Array la classe implémente le IEnumerable interface, tous les tableaux exposent le GetEnumerator (méthode).Because the Array class implements the IEnumerable interface, all arrays expose the GetEnumerator method. Cela signifie que vous pouvez itérer au sein d’un tableau avec un For Each... Next boucle.This means that you can iterate through an array with a For Each...Next loop. Toutefois, vous pouvez uniquement lire les éléments du tableau.However, you can only read the array elements. Vous ne pouvez pas les modifier.You cannot change them.

ExempleExample

L’exemple suivant répertorie tous les dossiers dans le répertoire C:\ à l’aide de la DirectoryInfo classe.The following example lists all the folders in the C:\ directory by using the DirectoryInfo class.

Dim dInfo As New System.IO.DirectoryInfo("c:\")
For Each dir As System.IO.DirectoryInfo In dInfo.GetDirectories()
    Debug.WriteLine(dir.Name)
Next

ExempleExample

L’exemple suivant illustre une procédure de tri d’une collection.The following example illustrates a procedure for sorting a collection. L’exemple trie les instances d’un Car classe qui sont stockés dans un List<T>.The example sorts instances of a Car class that are stored in a List<T>. La classe Car implémente l’interface IComparable<T>, ce qui implique l’implémentation de la méthode CompareTo.The Car class implements the IComparable<T> interface, which requires that the CompareTo method be implemented.

Chaque appel à la CompareTo méthode effectue une comparaison unique qui est utilisée pour le tri.Each call to the CompareTo method makes a single comparison that's used for sorting. Le code écrit par l’utilisateur dans la méthode CompareTo retourne une valeur pour chaque comparaison de l’objet actuel avec un autre objet.User-written code in the CompareTo method returns a value for each comparison of the current object with another object. La valeur retournée est inférieure à zéro si l’objet actuel est inférieur à l’autre objet, supérieure à zéro l’objet actuel est supérieur à l’autre et égale à zéro s’ils sont égaux.The value returned is less than zero if the current object is less than the other object, greater than zero if the current object is greater than the other object, and zero if they are equal. Cela vous permet de définir dans le code les critères définissant « supérieur à », « inférieur à » et « égal à ».This enables you to define in code the criteria for greater than, less than, and equal.

Dans la méthode ListCars, l’instruction cars.Sort() trie la liste.In the ListCars method, the cars.Sort() statement sorts the list. Cet appel à la méthode Sort de List<T> entraîne l’appel automatique de la méthode CompareTo pour les objets Car dans List.This call to the Sort method of the List<T> causes the CompareTo method to be called automatically for the Car objects in the List.

Public Sub ListCars()

    ' Create some new cars.
    Dim cars As New List(Of Car) From
    {
        New Car With {.Name = "car1", .Color = "blue", .Speed = 20},
        New Car With {.Name = "car2", .Color = "red", .Speed = 50},
        New Car With {.Name = "car3", .Color = "green", .Speed = 10},
        New Car With {.Name = "car4", .Color = "blue", .Speed = 50},
        New Car With {.Name = "car5", .Color = "blue", .Speed = 30},
        New Car With {.Name = "car6", .Color = "red", .Speed = 60},
        New Car With {.Name = "car7", .Color = "green", .Speed = 50}
    }

    ' Sort the cars by color alphabetically, and then by speed
    ' in descending order.
    cars.Sort()

    ' View all of the cars.
    For Each thisCar As Car In cars
        Debug.Write(thisCar.Color.PadRight(5) & " ")
        Debug.Write(thisCar.Speed.ToString & " ")
        Debug.Write(thisCar.Name)
        Debug.WriteLine("")
    Next

    ' Output:
    '  blue  50 car4
    '  blue  30 car5
    '  blue  20 car1
    '  green 50 car7
    '  green 10 car3
    '  red   60 car6
    '  red   50 car2
End Sub

Public Class Car
    Implements IComparable(Of Car)

    Public Property Name As String
    Public Property Speed As Integer
    Public Property Color As String

    Public Function CompareTo(ByVal other As Car) As Integer _
        Implements System.IComparable(Of Car).CompareTo
        ' A call to this method makes a single comparison that is
        ' used for sorting.

        ' Determine the relative order of the objects being compared.
        ' Sort by color alphabetically, and then by speed in
        ' descending order.

        ' Compare the colors.
        Dim compare As Integer
        compare = String.Compare(Me.Color, other.Color, True)

        ' If the colors are the same, compare the speeds.
        If compare = 0 Then
            compare = Me.Speed.CompareTo(other.Speed)

            ' Use descending order for speed.
            compare = -compare
        End If

        Return compare
    End Function
End Class

Voir aussiSee Also

CollectionsCollections
For...Next (instruction)For...Next Statement
Structures de boucleLoop Structures
While...End While (instruction)While...End While Statement
Do...Loop (instruction)Do...Loop Statement
Conversions étendues et restrictivesWidening and Narrowing Conversions
Initialiseurs d’objets : types nommés et anonymesObject Initializers: Named and Anonymous Types
Initialiseurs de collectionCollection Initializers
TableauxArrays