Utilisation de la variance dans les délégués (C# et Visual Basic)

Lorsque vous assignez une méthode à un délégué, la covariance et la contravariance fournissent la flexibilité pour faire correspondre un type délégué à une signature de méthode. La covariance autorise les méthodes comportant un type de retour qui est plus dérivé que celui défini dans le délégué. La contravariance autorise les méthodes comportant des types de paramètres qui sont moins dérivés que ceux du type délégué.

Exemple 1 : Covariance

Description

Cet exemple montre comment les délégués peuvent être utilisés avec les méthodes ayant des types de retour dérivés du type de retour dans la signature du délégué. Le type de données retourné par DogsHandler est du type Dogs qui dérive du type Mammals défini dans le délégué.

Code

Class Mammals
End Class 

Class Dogs
    Inherits Mammals
End Class 
Class Test
    Public Delegate Function HandlerMethod() As Mammals
    Public Shared Function MammalsHandler() As Mammals
        Return Nothing 
    End Function 
    Public Shared Function DogsHandler() As Dogs
        Return Nothing 
    End Function 
    Sub Test()
        Dim handlerMammals As HandlerMethod = AddressOf MammalsHandler
        ' Covariance enables this assignment. 
        Dim handlerDogs As HandlerMethod = AddressOf DogsHandler
    End Sub 
End Class

class Mammals{}
class Dogs : Mammals{}

class Program
{
    // Define the delegate. 
    public delegate Mammals HandlerMethod();

    public static Mammals MammalsHandler()
    {
        return null;
    }

    public static Dogs DogsHandler()
    {
        return null;
    }

    static void Test()
    {
        HandlerMethod handlerMammals = MammalsHandler;

        // Covariance enables this assignment.
        HandlerMethod handlerDogs = DogsHandler;
    }
}

Exemple 2 : Contravariance

Description

Cet exemple montre comment les délégués peuvent être utilisés avec les méthodes ayant des paramètres d'un type qui sont les types de base du type de paramètre de la signature du délégué. Avec la contravariance, vous pouvez utiliser un gestionnaire d'événements au lieu de gestionnaires séparés. Par exemple, vous pouvez créer un gestionnaire d'événements qui accepte un paramètre d'entrée EventArgs et l'utilise avec un événement Button.MouseClick qui envoie un type MouseEventArgs comme un paramètre, et également avec un événement TextBox.KeyDown qui envoie un paramètre KeyEventArgs.

Code

' Event hander that accepts a parameter of the EventArgs type. 
Private Sub MultiHandler(ByVal sender As Object,
                         ByVal e As System.EventArgs)
    Label1.Text = DateTime.Now
End Sub 

Private Sub Form1_Load(ByVal sender As System.Object,
    ByVal e As System.EventArgs) Handles MyBase.Load

    ' You can use a method that has an EventArgs parameter, 
    ' although the event expects the KeyEventArgs parameter. 
    AddHandler Button1.KeyDown, AddressOf MultiHandler

    ' You can use the same method  
    ' for the event that expects the MouseEventArgs parameter. 
    AddHandler Button1.MouseClick, AddressOf MultiHandler
End Sub

// Event hander that accepts a parameter of the EventArgs type. 
private void MultiHandler(object sender, System.EventArgs e)
{
    label1.Text = System.DateTime.Now.ToString();
}

public Form1()
{
    InitializeComponent();

    // You can use a method that has an EventArgs parameter, 
    // although the event expects the KeyEventArgs parameter. 
    this.button1.KeyDown += this.MultiHandler;

    // You can use the same method  
    // for an event that expects the MouseEventArgs parameter. 
    this.button1.MouseClick += this.MultiHandler;

}

Voir aussi

Référence

Utilisation de la variance pour les délégués génériques Func et Action (C# et Visual Basic)

Concepts

Variance dans les délégués (C# et Visual Basic)