Partager via

Appel d'une propriété ou méthode à l'aide d'un nom de chaîne (Visual Basic)

  • Article

Dans la plupart des cas, vous pouvez découvrir les propriétés et les méthodes d’un objet au moment de la conception, et écrire du code pour les gérer. Toutefois, dans certains cas, il se peut que vous ne connaissiez pas les propriétés et méthodes d’un objet à l’avance, ou que vous souhaitiez simplement permettre à un utilisateur final de spécifier des propriétés ou d’exécuter des méthodes au moment de l’exécution.

Fonction CallByName

Prenons l’exemple d’une application cliente qui évalue les expressions entrées par l’utilisateur en passant un opérateur à un composant COM. Supposons que vous ajoutez constamment de nouvelles fonctions au composant qui nécessitent de nouveaux opérateurs. Lorsque vous utilisez des techniques d’accès aux objets standard, vous devez recompiler et redistribuer l’application cliente avant qu’elle puisse utiliser les nouveaux opérateurs. Pour éviter cela, vous pouvez utiliser la fonction CallByName pour passer les nouveaux opérateurs en tant que chaînes, sans modifier l’application.

La fonction CallByName vous permet d’utiliser une chaîne pour spécifier une propriété ou une méthode au moment de l’exécution. La signature de la fonction CallByName se présente comme suit :

Result = CallByName(Object, ProcedureName, CallType, Arguments())

Le premier argument, Object, prend le nom de l’objet sur lequel vous souhaitez agir. L’argument ProcedureName prend une chaîne qui contient le nom de la méthode ou de la procédure de propriété à appeler. L’argument CallType prend une constante qui représente le type de procédure à appeler : une méthode (Microsoft.VisualBasic.CallType.Method), une propriété lue (Microsoft.VisualBasic.CallType.Get) ou un jeu de propriétés (Microsoft.VisualBasic.CallType.Set). L’argument Arguments, qui est facultatif, représente un tableau de type Object qui contient tous les arguments de la procédure.

Vous pouvez utiliser CallByName avec des classes dans votre solution actuelle, mais il est le plus souvent utilisé pour accéder à des objets COM ou des objets à partir d’assemblys .NET Framework.

Supposons que vous ajoutez une référence à un assembly qui contient une classe nommée MathClass, qui a une nouvelle fonction nommée SquareRoot, comme indiqué dans le code suivant :

Class MathClass
    Function SquareRoot(ByVal X As Double) As Double
        Return Math.Sqrt(X)
    End Function
    Function InverseSine(ByVal X As Double) As Double
        Return Math.Atan(X / Math.Sqrt(-X * X + 1))
    End Function
    Function Acos(ByVal X As Double) As Double
        Return Math.Atan(-X / Math.Sqrt(-X * X + 1)) + 2 * Math.Atan(1)
    End Function
End Class

Votre application peut utiliser des contrôles de zone de texte pour contrôler la méthode à appeler et ses arguments. Par exemple, si TextBox1 contient l’expression à évaluer et TextBox2 est utilisé pour entrer le nom de la fonction, vous pouvez utiliser le code suivant pour appeler la fonction SquareRoot sur l’expression dans TextBox1 :

Private Sub CallMath()
    Dim Math As New MathClass
    Me.TextBox1.Text = CStr(CallByName(Math, Me.TextBox2.Text,
       Microsoft.VisualBasic.CallType.Method, TextBox1.Text))
End Sub

Si vous saisissez « 64 » dans TextBox1, « SquareRoot » dans TextBox2, puis appelez la procédure CallMath, la racine carrée du nombre dans TextBox1 est évaluée. Le code de l’exemple appelle la fonction SquareRoot (qui prend une chaîne qui contient l’expression à évaluer en tant qu’argument requis) et retourne « 8 » dans TextBox1 (la racine carrée de 64). Bien entendu, si l’utilisateur saisit une chaîne non valide dans TextBox2, si la chaîne contient le nom d’une propriété au lieu d’une méthode, ou s’il y avait un autre argument requis pour la méthode, une erreur d’exécution se produit. Vous devez ajouter un code de gestion des erreurs robuste lorsque vous utilisez CallByName pour anticiper ces erreurs ou d’autres.

Notes

Bien que la fonction CallByName puisse être utile dans certains cas, vous devez évaluer son utilité par rapport aux implications en matière de performances. L’utilisation de CallByName pour invoquer une procédure est légèrement plus lente qu’un appel lié tardivement. Si vous invoquer une fonction appelée à plusieurs reprises, par exemple à l’intérieur d’une boucle, CallByName peut gravement nuire aux performances.

Voir aussi