Variação nos delegados (C#)

  • Artigo

O .NET Framework 3.5 introduziu o suporte à variância para correspondência de assinaturas de método com tipos delegados em todos os delegados em C#. Isso significa que você pode atribuir aos delegados não apenas métodos que tenham assinaturas correspondentes, mas também métodos que retornem mais tipos derivados (covariância) ou que aceitem parâmetros que tenham menos tipos derivados (contravariância) do que os especificados pelo tipo delegado. Isso inclui delegados genéricos e não genéricos.

Por exemplo, considere o código a seguir, que tem duas classes e dois delegados: genérico e não genérico.

public class First { }  
public class Second : First { }  
public delegate First SampleDelegate(Second a);  
public delegate R SampleGenericDelegate<A, R>(A a);

Ao criar delegados dos SampleDelegate tipos ou SampleGenericDelegate<A, R> , você pode atribuir qualquer um dos seguintes métodos a esses delegados.

// Matching signature.  
public static First ASecondRFirst(Second second)  
{ return new First(); }  
  
// The return type is more derived.  
public static Second ASecondRSecond(Second second)  
{ return new Second(); }  
  
// The argument type is less derived.  
public static First AFirstRFirst(First first)  
{ return new First(); }  
  
// The return type is more derived
// and the argument type is less derived.  
public static Second AFirstRSecond(First first)  
{ return new Second(); }

O exemplo de código a seguir ilustra a conversão implícita entre a assinatura do método e o tipo delegado.

// Assigning a method with a matching signature
// to a non-generic delegate. No conversion is necessary.  
SampleDelegate dNonGeneric = ASecondRFirst;  
// Assigning a method with a more derived return type
// and less derived argument type to a non-generic delegate.  
// The implicit conversion is used.  
SampleDelegate dNonGenericConversion = AFirstRSecond;  
  
// Assigning a method with a matching signature to a generic delegate.  
// No conversion is necessary.  
SampleGenericDelegate<Second, First> dGeneric = ASecondRFirst;  
// Assigning a method with a more derived return type
// and less derived argument type to a generic delegate.  
// The implicit conversion is used.  
SampleGenericDelegate<Second, First> dGenericConversion = AFirstRSecond;

Para obter mais exemplos, consulte Usando variância em delegados (C#) e Usando variância para Func e delegados genéricos de ação (C#).

Variância nos parâmetros de tipo genéricos

No .NET Framework 4 ou posterior, você pode habilitar a conversão implícita entre delegados, para que delegados genéricos que tenham tipos diferentes especificados por parâmetros de tipo genéricos possam ser atribuídos uns aos outros, se os tipos forem herdados uns dos outros, conforme exigido pela variância.

Para habilitar a conversão implícita, você deve declarar explicitamente parâmetros genéricos em um delegado como covariante ou contravariante usando a in palavra-chave ou out .

O exemplo de código a seguir mostra como você pode criar um delegado que tem um parâmetro de tipo genérico covariante.

// Type T is declared covariant by using the out keyword.  
public delegate T SampleGenericDelegate <out T>();  
  
public static void Test()  
{  
    SampleGenericDelegate <String> dString = () => " ";  
  
    // You can assign delegates to each other,  
    // because the type T is declared covariant.  
    SampleGenericDelegate <Object> dObject = dString;
}

Se você usar apenas o suporte de variância para corresponder assinaturas de método com tipos delegados e não usar as in palavras-chave e out , poderá achar que, às vezes, pode instanciar delegados com expressões ou métodos lambda idênticos, mas não pode atribuir um delegado a outro.

No exemplo de código a seguir, SampleGenericDelegate<String> não pode ser explicitamente convertido em SampleGenericDelegate<Object>, embora String herde Object. Você pode corrigir esse problema marcando o parâmetro T genérico com a out palavra-chave.

public delegate T SampleGenericDelegate<T>();  
  
public static void Test()  
{  
    SampleGenericDelegate<String> dString = () => " ";  
  
    // You can assign the dObject delegate  
    // to the same lambda expression as dString delegate  
    // because of the variance support for
    // matching method signatures with delegate types.  
    SampleGenericDelegate<Object> dObject = () => " ";  
  
    // The following statement generates a compiler error  
    // because the generic type T is not marked as covariant.  
    // SampleGenericDelegate <Object> dObject = dString;  
  
}

Delegados genéricos que têm parâmetros de tipo variante no .NET

O .NET Framework 4 introduziu o suporte à variância para parâmetros de tipo genéricos em vários delegados genéricos existentes:

Para obter mais informações e exemplos, consulte Usando variância para Func e Delegados Genéricos de Ação (C#).

Declarando parâmetros de tipo de variante em delegados genéricos

Se um delegado genérico tiver parâmetros de tipo genérico covariante ou contravariante, ele pode ser referido como um delegado genérico variante.

Você pode declarar uma covariante de parâmetro de tipo genérico em um delegado genérico usando a out palavra-chave. O tipo covariante pode ser usado apenas como um tipo de retorno de método e não como um tipo de argumentos de método. O exemplo de código a seguir mostra como declarar um delegado genérico covariante.

public delegate R DCovariant<out R>();

Você pode declarar uma contravariante de parâmetro de tipo genérico em um delegado genérico usando a in palavra-chave. O tipo contravariante pode ser usado apenas como um tipo de argumentos de método e não como um tipo de retorno de método. O exemplo de código a seguir mostra como declarar um delegado genérico contravariante.

public delegate void DContravariant<in A>(A a);

Importante

ref, ine os parâmetros em C# não podem ser marcados como variantes out .

Também é possível suportar variância e covariância no mesmo delegado, mas para parâmetros de tipo diferentes. Isso é mostrado no exemplo a seguir.

public delegate R DVariant<in A, out R>(A a);

Instanciando e invocando delegados genéricos de variantes

Você pode instanciar e invocar delegados variantes da mesma forma que instancia e invoca delegados invariantes. No exemplo a seguir, o delegado é instanciado por uma expressão lambda.

DVariant<String, String> dvariant = (String str) => str + " ";  
dvariant("test");

Combinando Delegados Genéricos de Variantes

Não combine delegados variantes. O Combine método não suporta conversão de delegados de variante e espera que os delegados sejam exatamente do mesmo tipo. Isso pode levar a uma exceção de tempo de execução quando você combina delegados usando o Combine método ou usando o + operador, conforme mostrado no exemplo de código a seguir.

Action<object> actObj = x => Console.WriteLine("object: {0}", x);  
Action<string> actStr = x => Console.WriteLine("string: {0}", x);  
// All of the following statements throw exceptions at run time.  
// Action<string> actCombine = actStr + actObj;  
// actStr += actObj;  
// Delegate.Combine(actStr, actObj);

Variância em parâmetros de tipo genéricos para tipos de valor e referência

A variância para parâmetros de tipo genéricos é suportada apenas para tipos de referência. Por exemplo, DVariant<int> não pode ser convertido implicitamente em DVariant<Object> ou DVariant<long>, porque inteiro é um tipo de valor.

O exemplo a seguir demonstra que a variância em parâmetros de tipo genéricos não é suportada para tipos de valor.

// The type T is covariant.  
public delegate T DVariant<out T>();  
  
// The type T is invariant.  
public delegate T DInvariant<T>();  
  
public static void Test()  
{  
    int i = 0;  
    DInvariant<int> dInt = () => i;  
    DVariant<int> dVariantInt = () => i;  
  
    // All of the following statements generate a compiler error  
    // because type variance in generic parameters is not supported  
    // for value types, even if generic type parameters are declared variant.  
    // DInvariant<Object> dObject = dInt;  
    // DInvariant<long> dLong = dInt;  
    // DVariant<Object> dVariantObject = dVariantInt;  
    // DVariant<long> dVariantLong = dVariantInt;
}

Consulte também