Usando variação em delegações (C# e Visual Basic)

Quando você atribui um método a um delegado, covariância e /contravariância fornecem flexibilidade para correspondência de um tipo delegate com uma assinatura de método. Covariância permite um método para ter o tipo de retorno que seja mais derivado que definiu o delegado. / Contravariância permite um método que possui tipos de parâmetro que são menos derivados que não estejam no tipo delegate.

Exemplo 1: covariância

Descrição

Este exemplo demonstra como os delegados podem ser usados com métodos que têm tipos de retorno que derivam do tipo de retorno na assinatura do delegado. O tipo de dados retornado por DogsHandler é do tipo Dogs, que é derivada da Mammals tipo definido no delegado.

Código

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;
    }
}

Exemplo 2: / contravariância

Descrição

Este exemplo demonstra como os delegados podem ser usados com os métodos que possuem parâmetros de um tipo que são tipos base do tipo de parâmetro de assinatura do delegado. Com/contravariância, você pode usar um manipulador de eventos, em vez de manipuladores separados. Por exemplo, você pode criar um manipulador de eventos que aceita um EventArgs parâmetro de entrada e usá-lo com um Button.MouseClick eventos que envia um MouseEventArgs tipo como um parâmetro e também com um TextBox.KeyDown eventos que envia um KeyEventArgs parâmetro.

Código

' 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;

}

Consulte também

Referência

Usando variação para delegações genéricas Func e Action (C# e Visual Basic)

Conceitos

Variação em delegações (C# e Visual Basic)