Partager via

Résolution de surcharge (Visual Basic)

  • Article

Le compilateur Visual Basic doit décider quelle surcharge appeler lorsqu'une procédure est définie dans plusieurs versions surchargées. Il décide en effectuant les étapes suivantes :

  1. Accessibilité. Il élimine toute surcharge dont le niveau d'accès empêche le code appelant de l'appeler.
  2. Nombre de paramètres. Il élimine toute surcharge qui définit un nombre différent de paramètres que ceux fournis dans l’appel.
  3. Types de données de paramètre. Le compilateur donne une préférence aux méthodes d’instance par rapport aux méthodes d’extension. S'il trouve une méthode d'instance qui ne nécessite que des conversions d'élargissement pour correspondre à l'appel de la procédure, toutes les méthodes d'extension sont abandonnées. Le compilateur continue avec uniquement les candidats de méthode d’instance. Si aucune méthode d’instance de ce type n’est trouvée, elle continue avec les méthodes d’instance et d’extension. Dans cette étape, elle élimine toute surcharge pour laquelle les types de données des arguments appelants ne peuvent pas être convertis en types de paramètres définis dans la surcharge.
  4. Conversions de rétrécissement. Elle élimine toute surcharge nécessitant une conversion étroite des types d’arguments appelants vers les types de paramètres définis. Cette étape a lieu si le commutateur de vérification de type (Option Strict Statement) est On ou Off.
  5. Élargissement minimal. Le compilateur considère les surcharges restantes par paires. Pour chaque paire, elle compare les types de données des paramètres définis. Si les types de l’une des surcharges s’étendent tous aux types correspondants dans l’autre, le compilateur élimine ce dernier. C'est-à-dire qu'elle retient la surcharge qui nécessite le moins d'élargissement.
  6. Priorité de résolution des surcharges. Le compilateur supprime toute surcharge ayant une valeur de OverloadResolutionPriorityAttribute inférieure à la plus élevée parmi les surcharges candidates. Toute surcharge sans cet attribut est affectée à la valeur par défaut de zéro.
  7. Candidat unique. Il continue d'appairer les surcharges jusqu'à ce qu'il n'en reste plus qu'une, et il résout l'appel vers cette surcharge. Si le compilateur ne peut pas réduire les surcharges à un seul candidat, il génère une erreur.

L’illustration suivante montre le processus qui détermine lequel d’un ensemble de versions surchargées à appeler.

diagramme de flux du processus de résolution de surcharge

L’exemple suivant illustre ce processus de résolution de surcharge.

Overloads Sub z(ByVal x As Byte, ByVal y As Double)
End Sub
Overloads Sub z(ByVal x As Short, ByVal y As Single)
End Sub
Overloads Sub z(ByVal x As Integer, ByVal y As Single)
End Sub

Dim r, s As Short
Call z(r, s)
Dim p As Byte, q As Short
' The following statement causes an overload resolution error.
Call z(p, q)

Dans le premier appel, le compilateur élimine la première surcharge, car le type du premier argument (Short) se limite au type du paramètre correspondant (Byte). Il élimine ensuite la troisième surcharge, car chaque type d’argument dans la deuxième surcharge (Short et Single) s’étend sur le type correspondant dans la troisième surcharge (Integer et Single). La deuxième surcharge nécessitant moins d'élargissement, le compilateur l'utilise pour l'appel.

Dans le second appel, le compilateur ne peut éliminer aucune des surcharges en se basant sur le rétrécissement. Il élimine la troisième surcharge pour la même raison que dans le premier appel, car elle peut appeler la deuxième surcharge avec moins d’élargissement des types d’arguments. Toutefois, le compilateur ne peut pas faire la distinction entre la première et la deuxième surcharge. Chacun a un type de paramètre défini qui s’élargit au type correspondant dans l’autre (Byte à Short, mais Single à Double). Le compilateur génère donc une erreur de résolution de surcharge.

Arguments Optional et ParamArray surchargés

Si deux surcharges d’une procédure ont des signatures identiques, sauf que le dernier paramètre est déclaré facultatif dans un et ParamArray dans l’autre, le compilateur résout un appel à cette procédure comme suit :

Si l'appel fournit le dernier argument sous la forme Le compilateur résout l'appel à la surcharge déclarant le dernier argument comme
Aucune valeur (argument omis) Optional
Valeur unique Optional
Deux valeurs ou plus dans une liste séparée par des virgules ParamArray
Tableau de toute longueur (y compris un tableau vide) ParamArray

Voir aussi