Méthodes d'extension (Visual Basic)

Une méthode d'extension peut uniquement être une procédure Sub ou Function. Vous ne pouvez pas définir une propriété d'extension, un champ ou un événement. Toutes les méthodes d'extension doivent être marquées avec l'attribut d'extension, <Extension()>, à partir de l'espace de noms System.Runtime.CompilerServices.

Le premier paramètre d'une définition de méthode d'extension spécifie le type de données étendu par la méthode. Lorsque la méthode est exécutée, le premier paramètre est lié à l'instance du type de données qui appelle la méthode.

Description

Imports System.Runtime.CompilerServices

Module StringExtensions

    <Extension()> 
    Public Sub Print(ByVal aString As String)
        Console.WriteLine(aString)
    End Sub

End Module

Module Class1

    Sub Main()

        Dim example As String = "Hello"
        ' Call to extension method Print.
        example.Print()

        ' Call to instance method ToUpper.
        example.ToUpper()
        example.ToUpper.Print()

    End Sub

End Module

<Extension()> 
Public Sub PrintAndPunctuate(ByVal aString As String, 
                             ByVal punc As String)
    Console.WriteLine(aString & punc)
End Sub

Code

Imports System.Runtime.CompilerServices

Module StringExtensions

    <Extension()> 
    Public Sub Print(ByVal aString As String)
        Console.WriteLine(aString)
    End Sub

    <Extension()> 
    Public Sub PrintAndPunctuate(ByVal aString As String, 
                                 ByVal punc As String)
        Console.WriteLine(aString & punc)
    End Sub

End Module

Imports ConsoleApplication2.StringExtensions
Module Module1

    Sub Main()

        Dim example As String = "Example string"
        example.Print()

        example = "Hello"
        example.PrintAndPunctuate(".")
        example.PrintAndPunctuate("!!!!")

    End Sub
End Module

Commentaires

Vous pouvez définir une méthode d'extension pour la plupart des types qui peuvent être représentés dans une liste de paramètres Visual Basic, notamment les éléments suivants :

• Classes (types référence)

• Structures (types valeur)

• Interfaces

• Délégués

• Arguments ByRef et ByVal

• Paramètres de méthode générique

• Tableaux

Étant donné que le premier paramètre spécifie le type de données étendu par la méthode d'extension, il est requis et ne peut pas être facultatif. Pour cette raison, les paramètres Optional et ParamArray ne peuvent pas être le premier paramètre de la liste de paramètres.

Les méthodes d'extension ne sont pas prises en compte dans la liaison tardive. Dans l'exemple suivant, l'instruction anObject.PrintMe() lève une exception MissingMemberException qui correspond à celle levée si la deuxième définition de méthode d'extension PrintMe est supprimée.

Option Strict Off
Imports System.Runtime.CompilerServices

Module Module4

    Sub Main()
        Dim aString As String = "Initial value for aString"
        aString.PrintMe()

        Dim anObject As Object = "Initial value for anObject"
        ' The following statement causes a run-time error when Option
        ' Strict is off, and a compiler error when Option Strict is on.
        'anObject.PrintMe()
    End Sub

    <Extension()> 
    Public Sub PrintMe(ByVal str As String)
        Console.WriteLine(str)
    End Sub

    <Extension()> 
    Public Sub PrintMe(ByVal obj As Object)
        Console.WriteLine(obj)
    End Sub

End Module

Les méthodes d'extension fournissent une façon pratique et puissante d'étendre un type existant. Toutefois, pour les utiliser correctement, certains points doivent être considérés. Ces considérations s'appliquent principalement aux auteurs de bibliothèques de classes, mais elles peuvent affecter n'importe quelle application utilisant des méthodes d'extension.

La plupart du temps, les méthodes d'extension que vous ajoutez aux types que vous ne possédez pas sont plus vulnérables que les méthodes d'extension ajoutées aux types que vous contrôlez. Plusieurs événements peuvent se produire dans les classes que vous ne possédez pas, pouvant interférer avec vos méthodes d'extension.

• Si un membre d'instance accessible existe avec une signature compatible avec les arguments dans l'instruction d'appel, sans conversions restrictives requises d'un argument en un paramètre, la méthode d'instance sera utilisée de préférence à toute méthode d'extension. Par conséquent, si une méthode d'instance appropriée est ajoutée à une classe à un moment donné, un membre d'extension existant auquel vous vous conformez peut devenir inaccessible.

• L'auteur d'une méthode d'extension ne peut pas empêcher d'autres programmeurs d'écrire des méthodes d'extension en conflit qui peuvent être prioritaires sur l'extension d'origine.

• Vous pouvez améliorer la robustesse en plaçant les méthodes d'extension dans leur propre espace de noms. Les consommateurs de votre bibliothèque peuvent ensuite inclure ou exclure un espace de noms, ou réaliser une sélection parmi les espaces de noms, de manière séparée pour le reste de la bibliothèque.

• Il peut être plus sûr d'étendre les interfaces plutôt que d'étendre les classes, notamment si vous ne possédez pas l'interface ou la classe. Une modification dans une interface affecte chaque classe implémentée. Par conséquent, l'auteur peut être moins tenté d'ajouter ou de modifier les méthodes dans une interface. Toutefois, si une classe implémente deux interfaces qui ont des méthodes d'extension avec la même signature, aucune méthode d'extension n'est visible.

• Étendez le type le plus spécifique possible. Dans une hiérarchie de types, si vous sélectionnez un type à partir duquel d'autres types sont dérivés, l'introduction de méthodes d'instance ou d'autres méthodes d'extension peuvent interférer avec les vôtres.

Lorsqu'une méthode d'instance dans la portée a une signature qui est compatible avec les arguments d'une instruction appelante, la méthode d'instance est choisie dans la préférence à toute méthode d'extension. La méthode d'instance a même la priorité si la méthode d'extension est une meilleure correspondance. Dans l'exemple suivant, ExampleClass contient une méthode d'instance nommée ExampleMethod qui a un paramètre de type Integer. La méthode d'extension ExampleMethod étend ExampleClasset a un paramètre de type Long.

Class ExampleClass
    ' Define an instance method named ExampleMethod.
    Public Sub ExampleMethod(ByVal m As Integer)
        Console.WriteLine("Instance method")
    End Sub
End Class

<Extension()> 
Sub ExampleMethod(ByVal ec As ExampleClass, 
                  ByVal n As Long)
    Console.WriteLine("Extension method")
End Sub

Le premier appel à ExampleMethod dans le code suivant appelle la méthode d'extension, parce que arg1 est de type Long et est compatible uniquement avec le paramètre Long dans la méthode d'extension. Le deuxième appel à ExampleMethod a un argument Integer, arg2, et il appelle la méthode d'instance.

Sub Main()
    Dim example As New ExampleClass
    Dim arg1 As Long = 10
    Dim arg2 As Integer = 5

    ' The following statement calls the extension method.
    example.exampleMethod(arg1)
    ' The following statement calls the instance method.
    example.exampleMethod(arg2)
End Sub

Maintenant inversez les types de données des paramètres dans les deux méthodes :

Class ExampleClass
    ' Define an instance method named ExampleMethod.
    Public Sub ExampleMethod(ByVal m As Long)
        Console.WriteLine("Instance method")
    End Sub
End Class

<Extension()> 
Sub ExampleMethod(ByVal ec As ExampleClass, 
                  ByVal n As Integer)
    Console.WriteLine("Extension method")
End Sub

Cette fois, le code dans Main appelle la méthode d'instance les deux fois. C'est parce que arg1 et arg2 ont une conversion étendue à Long, et que la méthode d'instance est prioritaire sur la méthode d'extension dans les deux cas.

Sub Main()
    Dim example As New ExampleClass
    Dim arg1 As Long = 10
    Dim arg2 As Integer = 5

    ' The following statement calls the instance method.
    example.ExampleMethod(arg1)
    ' The following statement calls the instance method.
    example.ExampleMethod(arg2)
End Sub

Par conséquent, une méthode d'extension ne peut pas remplacer une méthode d'instance existante. Toutefois, lorsqu'une méthode d'extension porte le même nom qu'une méthode d'instance, les deux méthodes sont accessibles tant que les signatures ne sont pas en conflit. Par exemple, si la classe ExampleClass contient une méthode nommée ExampleMethod qui ne prend pas d'arguments, une méthode d'extension portant le même nom mais avec une signature différente est autorisée, comme illustré dans le code ci-après.

Imports System.Runtime.CompilerServices

Module Module3

    Sub Main()
        Dim ex As New ExampleClass
        ' The following statement calls the extension method.
        ex.ExampleMethod("Extension method")
        ' The following statement calls the instance method.
        ex.ExampleMethod()
    End Sub

    Class ExampleClass
        ' Define an instance method named ExampleMethod.
        Public Sub ExampleMethod()
            Console.WriteLine("Instance method")
        End Sub
    End Class

    <Extension()> 
    Sub ExampleMethod(ByVal ec As ExampleClass, 
                  ByVal stringParameter As String)
        Console.WriteLine(stringParameter)
    End Sub

End Module

La sortie de ce code est la suivante :

Extension method

Instance method

La situation est plus simple avec des propriétés : si une méthode d'extension a le même nom qu'une propriété de la classe qu'elle étend, la méthode d'extension n'est pas visible et n'est pas accessible.

Lorsque deux méthodes d'extension ayant des signatures identiques se trouvent dans la portée et sont accessibles, la méthode prioritaire sera appelée. La priorité d'une méthode d'extension est basée sur le mécanisme utilisé pour placer la méthode dans la portée. La liste suivante présente la hiérarchie de priorité par ordre décroissant.

1. Méthodes d'extension définies au sein du module actuel.

2. Méthodes d'extension définies au sein de types de données dans l'espace de noms actuel ou dans l'un de ses parents, les espaces de noms enfants étant prioritaires sur les espaces de noms parents.

3. Méthodes d'extension définies dans les importations de type dans le fichier en cours.

4. Méthodes d'extension définies dans les importations d'espaces de noms dans le fichier en cours.

5. Méthodes d'extension définies dans les importations de type au niveau du projet.

6. Méthodes d'extension définies dans les importations d'espaces de noms au niveau du projet.

Si la priorité ne résout pas l'ambiguïté, vous pouvez utiliser le nom qualifié complet pour spécifier la méthode que vous appelez. Si la méthode Print dans l'exemple précédent est définie dans un module nommé StringExtensions, le nom qualifié complet est StringExtensions.Print(example) au lieu de example.Print().

Référence

Concepts