Partager via

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

Lorsque vous affectez une méthode à un délégué, la covariance et la contravariance offrent une flexibilité pour la mise en correspondance d’un type délégué avec une signature de méthode. La covariance permet à une méthode d’avoir un type de retour qui est plus dérivé que celui défini dans le délégué. La contravariance permet une méthode qui a des types de paramètres qui sont moins dérivés que ceux du type délégué.

Exemple 1 : Covariance

Descriptif

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

Code

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

Descriptif

Cet exemple montre comment les délégués peuvent être utilisés avec des méthodes qui ont des paramètres dont les types sont des types de base du type de paramètre de signature de délégué. Avec la contravariance, vous pouvez maintenant utiliser un gestionnaire d’événements plutôt que des gestionnaires distincts. L’exemple suivant utilise deux délégués :

  • Délégué KeyEventHandler qui définit la signature de l’événement Button.KeyDown . Sa signature est :

    public delegate void KeyEventHandler(object sender, KeyEventArgs e)

  • Délégué MouseEventHandler qui définit la signature de l’événement Button.MouseClick . Sa signature est :

    public delegate void MouseEventHandler(object sender, MouseEventArgs e)

L’exemple définit un gestionnaire d’événements avec le paramètre EventArgs et l’utilise pour gérer les événements Button.KeyDown et Button.MouseClick. Cela peut se faire car EventArgs est un type de base pour à la fois KeyEventArgs et MouseEventArgs.

Code

// Event handler 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