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

Répète un groupe d’instructions pour chaque élément d’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 Obligatoire dans l’instruction For Each.Required in the For Each statement. Facultatif dans l’instruction Next.Optional in the Next statement. Variable.Variable. Utilisé pour itérer au sein des éléments de la collection.Used to iterate through the elements of the collection.
datatype Facultatif si Option Infer est activé (valeur par défaut) ou element est déjà déclaré ; obligatoire si Option Infer est désactivé et element n’est pas déjà déclaré.Optional if Option Infer is on (the default) or element is already declared; required if Option Infer is off and element isn't already declared. Type de données de l' element.The data type of element.
group Requis.Required. Variable avec un type qui est un type de collection ou un objet.A variable with a type that's a collection type or Object. Fait référence à la collection sur laquelle les statements doivent être répétées.Refers to the collection over which the statements are to be repeated.
statements Ce paramètre est facultatif.Optional. Une ou plusieurs instructions entre For Each et Next qui s’exécutent sur chaque élément dans group.One or more statements between For Each and Next that run on each item in group.
Continue For Ce paramètre est facultatif.Optional. Transfère le contrôle au début de la boucle For Each.Transfers control to the start of the For Each loop.
Exit For Ce paramètre est facultatif.Optional. Transfère le contrôle hors de la boucle de For Each.Transfers control out of the For Each loop.
Next Requis.Required. Termine la définition de la boucle For Each.Terminates the definition of the For Each loop.

Exemple simpleSimple Example

Utilisez une boucle For Each...Next lorsque vous souhaitez répéter un ensemble d’instructions pour chaque élément d’une collection ou d’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

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 travaillez avec une collection, le concept de valeurs initiales et finales n’est pas significatif et vous ne connaissez pas nécessairement le nombre d’éléments de la collection.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 genre de cas, une boucle For Each...Next est souvent un meilleur choix.In this kind of case, a For Each...Next loop is often a better choice.

Dans l’exemple suivant, l' For Each...NextIn the following example, the For EachNext l’instruction itère au sein de 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 obtenir plus d’exemples, consultez Collections et tableaux.For more examples, see Collections and Arrays.

Boucles imbriquéesNested Loops

Vous pouvez imbriquer des boucles For Each en plaçant une boucle dans une autre.You can nest For Each loops by putting one loop within another.

L’exemple suivant illustre une For Eachimbriquée...NextThe following example demonstrates nested For EachNext Celles.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 avoir une variable element unique.When you nest loops, each loop must have a unique element variable.

Vous pouvez également imbriquer différents genres de structures de contrôle dans les deux.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.

Quitter pour et continuer pourExit For and Continue For

L’instruction Exit for force l’exécution à quitter l' For...NextThe Exit For statement causes execution to exit the ForNext effectue une boucle et transfère le contrôle à l’instruction qui suit l’instruction Next.loop and transfers control to the statement that follows the Next statement.

L’instruction Continue For transfère immédiatement le contrôle à 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 les instructions Continue For et Exit For.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 d’instructions Exit For dans une boucle For Each.You can put any number of Exit For statements in a For Each loop. Lorsqu’elle est utilisée dans des boucles For Each imbriquées, Exit For provoque l’arrêt de l’exécution de la boucle la plus profonde et transfère le contrôle au niveau supérieur d’imbrication 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 For est souvent utilisé après une évaluation d’une condition, par exemple dans une structure If...Then...Else.Exit For is often used after an evaluation of some condition, for example, in an If...Then...Else structure. Vous pouvez utiliser Exit For pour les conditions suivantes :You might want to use Exit For for the following conditions:

  • La poursuite de l’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 une Try...Catch...Finally. Vous pouvez utiliser Exit For à la fin du bloc Finally.An exception is caught in a Try...Catch...Finally. You might use Exit For at the end of the Finally block.

  • Il s’agit d’une boucle sans fin, qui est une boucle qui peut exécuter un nombre de fois très long, voire infini.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 échapper à la boucle.If you detect such a condition, you can use Exit For to escape the loop. Pour plus d’informations, consultez do... Instruction de boucle.For more information, see Do...Loop Statement.

ItérateursIterators

Vous utilisez un itérateur pour exécuter 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 accesseur Get.An iterator can be a function or a Get accessor. Elle utilise une instruction Yield pour retourner chaque élément de la collection un par un.It uses a Yield statement to return each element of the collection one at a time.

Vous appelez un itérateur à l’aide d’une instruction For Each...Next.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 une instruction Yield est atteinte dans l’itérateur, l’expression dans l’instruction Yield 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 Iterator a une instruction Yield qui se trouve à l’intérieur d’une instruction for... Next .The iterator function has a Yield statement that's inside a For…Next loop. Dans la méthode ListEvenNumbers, chaque itération du corps d’instruction For Each crée un appel à la fonction d’itérateur, qui passe à l’instruction de Yield suivante.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 yieldet iterator.For more information, see Iterators, Yield Statement, and Iterator.

Implémentation techniqueTechnical Implementation

Quand un For Each...NextWhen a For EachNext l’instruction s’exécute, Visual Basic évalue la collection 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 change 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, la boucle For Each s’arrête et le contrôle passe à l’instruction qui suit l’instruction Next.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 l' Option Infer est définie sur on (paramètre par défaut), le compilateur Visual Basic peut déduire le type de données de element.If Option Infer is on (its default setting), the Visual Basic compiler can infer the data type of element. Si elle est désactivée et element n’a pas été déclarée en dehors de la boucle, vous devez la déclarer dans l’instruction For Each.If it is off and element hasn't been declared outside the loop, you must declare it in the For Each statement. Pour déclarer explicitement le type de données de element, utilisez une clause As.To declare the data type of element explicitly, use an As clause. À moins que le type de données de l’élément ne soit défini en dehors de la construction For Each...Next, son étendue est le corps de la boucle.Unless the data type of element is defined outside the For Each...Next construct, its scope is the body of the loop. Notez que vous ne pouvez pas déclarer element à la fois à l’extérieur et à l’intérieur de la boucle.Note that you cannot declare element both outside and inside the loop.

Vous pouvez éventuellement spécifier element dans l’instruction Next.You can optionally specify element in the Next statement. Cela améliore la lisibilité de votre programme, surtout si vous avez imbriqué des boucles de For Each.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 apparaît dans l’instruction For Each correspondante.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 compliquer la lecture et le débogage de votre code.Doing this can make it more difficult to read and debug your code. La modification de la valeur de group n’affecte pas la collection ou ses éléments, qui ont été déterminés 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 imbriquez des boucles, si une instruction 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 qui se chevauche uniquement si vous spécifiez element dans chaque instruction Next.However, the compiler can detect this overlapping error only if you specify element in every Next statement.

Si votre code dépend de la traversée d’une collection dans un ordre particulier, une boucle For Each...Next 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 traversée n’est pas déterminé par Visual Basic, mais par la méthode MoveNext 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 pouvez ne pas être en mesure de prédire quel élément de la collection est le premier à être retourné dans element, ou qui est le suivant à retourner 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, par exemple For...Next ou Do...Loop.You might achieve more reliable results using a different loop structure, such as For...Next or Do...Loop.

Le Runtime doit pouvoir convertir les éléments de group en element.The runtime must be able to convert the elements in group to element. L’instruction [Option Strict] contrôle si les conversions étendues et restrictives sont autorisées (Option Strict est désactivé, sa valeur par défaut) ou si seules les conversions étendues sont autorisées (Option Strict est activé).The [Option Strict] statement controls whether both widening and narrowing conversions are allowed (Option Strict is off, its default value), or whether only widening conversions are allowed (Option Strict is on). Pour plus d’informations, consultez conversions restrictives.For more information, see Narrowing conversions.

Le 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. Le plus souvent, cela signifie que group fait référence à un objet qui implémente l’interface IEnumerable de l’espace de noms System.Collections ou de l’interface IEnumerable<T> de l’espace de noms System.Collections.Generic.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.IEnumerable définit la méthode GetEnumerator, 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 l’interface System.Collections.IEnumerator de l’espace de noms System.Collections et expose la propriété Current et les méthodes Reset et MoveNext.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 les 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 entraînent généralement des erreurs de compilation.When Option Strict is set to On, narrowing conversions ordinarily cause compiler errors. Toutefois, dans une instruction For Each, les conversions des éléments de group en element sont évaluées et exécutées au moment de l’exécution, et les erreurs du compilateur causé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’assignation de m comme valeur initiale pour n ne se compile pas lorsque Option Strict est activé, car la conversion d’une Long en 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. Toutefois, dans l’instruction For Each, aucune erreur du compilateur n’est signalée, même si l’assignation à number requiert 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 l’instruction For Each qui contient un grand nombre, une erreur d’exécution se produit lorsque ToInteger est appliqué au 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

Lorsque l’exécution d’une boucle For Each...Next démarre, 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, une exception est levée.If not, it throws an exception. Sinon, elle appelle la méthode MoveNext et la propriété Current 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’y a pas d’élément suivant, autrement dit, si la collection est vide, la boucle For Each s’arrête et le contrôle passe à l’instruction qui suit l’instruction Next.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 sur le 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 l’instruction Next, il retourne à l’instruction For Each.Each time Visual Basic encounters the Next statement, it returns to the For Each statement. Là encore, il appelle MoveNext et Current pour retourner l’élément suivant, puis il exécute le bloc ou 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’y a pas d’élément suivant ou qu’une instruction 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 permet généralement pas de modifier la collection en ajoutant, en supprimant, en remplaçant ou en réordonnant des é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 boucle For Each...Next, l’objet énumérateur devient non valide et la tentative suivante d’accès à un élément provoque une exception InvalidOperationException.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 Basic, mais plutôt par l’implémentation de l’interface IEnumerable.However, this blocking of modification isn't determined by Visual Basic, but rather by the implementation of the IEnumerable interface. Il est possible d’implémenter IEnumerable de manière à permettre la modification pendant l’itération.It is possible to implement IEnumerable in a way that allows for modification during iteration. Si vous envisagez d’effectuer une telle modification dynamique, assurez-vous que vous comprenez les caractéristiques de l’implémentation de IEnumerable sur le regroupement 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. La propriété Current de l’objet énumérateur est ReadOnlyet 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 eux-mêmes dans une boucle For Each...Next.This means that you cannot modify the elements themselves in a For Each...Next loop. Toute modification que vous effectuez affecte uniquement la copie locale à partir de Current et n’est pas reflété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 membre BackColor de chaque élément thisControl.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(thisForm As System.Windows.Forms.Form)
    For Each thisControl In thisForm.Controls
        thisControl.BackColor = System.Drawing.Color.LightBlue
    Next thisControl
End Sub

L’exemple précédent peut modifier le membre BackColor de chaque élément thisControl, bien qu’il ne puisse 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 des tableaux.Traversing Arrays. Étant donné que la classe Array implémente l’interface IEnumerable, tous les tableaux exposent la méthode GetEnumerator.Because the Array class implements the IEnumerable interface, all arrays expose the GetEnumerator method. Cela signifie que vous pouvez effectuer une itération au sein d’un tableau avec une boucle For Each...Next.This means that you can iterate through an array with a For Each...Next loop. Toutefois, vous ne pouvez lire que 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 dossier C:\ Répertoire à l’aide de la classe DirectoryInfo.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’une classe Car qui sont stockées dans une 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 méthode CompareTo 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