Résolution de surcharge

Mise à jour : novembre 2007

Lorsque le compilateur Visual Basic rencontre un appel à une procédure défini dans plusieurs versions surchargées, il doit décider de la surcharge à appeler. Pour ce faire, il effectue les étapes suivantes :

1. Accessibilité. Il élimine toute surcharge avec un niveau d'accès qui empêche le code appelant de l'appeler.

2. Nombre de paramètres. Il élimine les surcharges qui définissent un nombre de paramètres différent de ceux spécifiés dans l'appel.

3. **Types de données des paramètres.**Le compilateur donne la préférence aux méthodes d'instance plutôt qu'aux méthodes d'extension. Si une méthode d'instance est trouvée, qui requiert que seules les conversions étendues correspondent à l'appel de procédure, toutes les méthodes d'extension sont abandonnées et le compilateur continue uniquement avec les candidats de méthode d'instance. Si aucune méthode d'instance de ce type n'est trouvée, il continue à la fois avec les méthodes d'extension et les méthodes d'instance.

   Au cours de cette étape, il élimine les surcharges dont les types de données des arguments d'appel ne sont pas convertibles en types de paramètres définis dans la surcharge.

4. Conversions restrictives. Il élimine les surcharges qui nécessitent une conversion restrictive des types des arguments d'appel vers les types des paramètres définis. Cette règle est valable que le commutateur de vérification de type (Option Strict, instruction) ait pour valeur On ou Off.

5. Moindre extension. Le compilateur prend en compte les surcharges restantes par paires. Pour chaque paire, il 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 surcharge, le compilateur élimine la seconde surcharge. En d'autres termes, il conserve la surcharge qui requiert l'extension la moins importante.

6. Candidat unique. Il continue à rassembler les surcharges par paires jusqu'à ce qu'il ne reste qu'une seule surcharge et il résout l'appel vers celle-ci. Si le compilateur ne peut pas réduire les surcharges vers un seul candidat, il génère une erreur.

L'illustration suivante montre le processus de définition de la version à appeler parmi un jeu de versions surchargées.

Résolution parmi des versions surchargées

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 parce que le type du premier argument (Short) est restreint au type du paramètre correspondant (Byte). Il élimine ensuite la troisième surcharge parce que chaque type d'argument dans la deuxième surcharge (Short et Single) est étendu au type correspondant dans la troisième surcharge (Integer et Single). La deuxième surcharge requérant une extension moins importante, le compilateur l'utilise pour l'appel.

Dans le deuxième appel, le compilateur ne peut éliminer aucune des surcharges sur la base de la restriction. Il élimine la troisième surcharge pour la même raison que dans le premier appel, parce qu'il peut appeler la deuxième surcharge moyennant une extension moins importante des types des arguments. Toutefois, le compilateur ne peut pas effectuer de résolution entre la première et la deuxième surcharges. Chaque surcharge possède un type de paramètre défini qui s'étend au type correspondant de l'autre (Byte vers Short, mais Single vers Double). Par conséquent, le compilateur génère une erreur de résolution de surcharge.

Arguments Optional et ParamArray de surcharge

Si deux surcharges d'une procédure ont des signatures identiques, mais que le dernier paramètre est déclaré Optional (Visual Basic) dans l'une et ParamArray dans l'autre, le compilateur résout un appel à cette procédure comme suit :

Voir aussi

Tâches

Procédures de dépannage

Comment : définir plusieurs versions d'une procédure

Comment : appeler une procédure surchargée

Comment : surcharger une procédure qui accepte des paramètres optionnels

Comment : surcharger une procédure qui accepte un nombre indéfini de paramètres

Concepts

Paramètres facultatifs

Tableaux de paramètres

Surcharge de procédure

Considérations sur les surcharges de procédures

Méthodes d'extension (Visual Basic)

Référence

Overloads