co- y contravarianza errores en .NET 4.0

Question

un comportamiento extraño con la C# 4.0 co- y contravarianza apoyo:

using System; 

class Program { 
    static void Foo(object x) { } 
    static void Main() { 
    Action<string> action = _ => { }; 

    // C# 3.5 supports static co- and contravariant method groups 
    // conversions to delegates types, so this is perfectly legal: 
    action += Foo; 

    // since C# 4.0 much better supports co- and contravariance 
    // for interfaces and delegates, this is should be legal too: 
    action += new Action<object>(Foo); 
    } 
} 

resultados de las TI con ArgumentException: Delegates must be of the same type.

extraño, ¿verdad? ¿Por qué Delegate.Combine() (que se ha llamado al realizar la operación += en los delegados) no es compatible con co y contravariancia en tiempo de ejecución?

Además, he encontrado que el tipo de delegado de BCL System.EventHandler<TEventArgs> no tiene una anotación contravariante en su parámetro genérico TEventArgs! ¿Por qué? Es perfectamente legal, el tipo TEventArgs se usa solo en la posición de entrada. Tal vez no hay ninguna anotación contravariante porque oculta muy bien el error con el Delegate.Combine()? ;)

p.s. Todo esto afecta al VS2010 RC y versiones posteriores.

Answer 1

Resumen de la historia larga: la combinación de delegados es todo arruinado con respecto a la varianza. Descubrimos esto tarde en el ciclo. Estamos trabajando con el equipo de CLR para ver si podemos encontrar la forma de que funcionen todos los escenarios comunes sin romper la compatibilidad con versiones anteriores, etc., pero lo que sea que se nos ocurra probablemente no llegue a la versión 4.0. Con suerte lo solucionaremos en algún service pack. Pido disculpas por las molestias.

Answer 2

Covarianza y contravarianza especifica la relación de herencia entre los tipos genéricos. Cuando tiene covarianza & contravariancia, las clases G<A> y G<B> pueden estar en alguna relación de herencia dependiendo de qué A y B sea. Puede beneficiarse de esto cuando llame a métodos genéricos.

Sin embargo, el método Delegate.Combine no es genérico y el documentation clearly says cuando se produce la excepción:

ArgumentException - Tanto un y b no son null referencia (Nothing en Visual Basic), y a y b no son instancias del mismo tipo de delegado.

Ahora, Action<object> y Action<string> son sin duda las instancias de un tipo de delegado diferentes (aunque relacionados a través de relación de herencia), por lo que de acuerdo a la documentación, se lanzará una excepción. Parece razonable que el método Delegate.Combine sea compatible con este escenario, pero eso es solo una posible propuesta (obviamente, esto no era necesario hasta ahora, porque no se pueden declarar delegados heredados, por lo que antes de la co/contravariancia, ningún delegado tenía una relación de herencia) .

Answer 3

Una dificultad con la combinación de delegados es que a menos que uno especifique qué operando se supone que es el subtipo y cuál es supertipo, no está claro qué tipo debe ser el resultado. Es posible escribir una fábrica de envoltura que convierta a cualquier delegado con un número especificado de argumentos y patrones de byval/byref en un supertipo, pero llamar a esa fábrica varias veces con el mismo delegado produciría diferentes contenedores (esto podría causar estragos en anulación de la suscripción al evento). Uno podría crear alternativamente versiones de Delegate.Combine lo que obligaría al delegado del lado derecho al tipo del delegado izquierdo (como beneficio adicional, la devolución no tendría que ser encasillada), pero uno tendría que escribir una versión especial de delegate.remove para tratar con él.

Answer 4

Esta solución fue publicada originalmente por cdhowie para mi pregunta: Delegate conversion breaks equality and unables to disconnect from event pero parece resolver el problema de la covarianza y la contravarianza en el contexto de los delegados de multidifusión.

primero necesita un método de ayuda:

public static class DelegateExtensions 
{ 
    public static Delegate ConvertTo(this Delegate self, Type type) 
    { 
     if (type == null) { throw new ArgumentNullException("type"); } 
     if (self == null) { return null; } 

     if (self.GetType() == type) 
      return self; 

     return Delegate.Combine(
      self.GetInvocationList() 
       .Select(i => Delegate.CreateDelegate(type, i.Target, i.Method)) 
       .ToArray()); 
    } 

    public static T ConvertTo<T>(this Delegate self) 
    { 
     return (T)(object)self.ConvertTo(typeof(T)); 
    } 
} 

Cuando usted tiene un delegado:

public delegate MyEventHandler<in T>(T arg); 

Usted puede utilizarlo mientras que la combinación de los delegados simplemente mediante la conversión de un delegado hacerlo tipo deseado:

MyEventHandler<MyClass> handler = null; 
handler += new MyEventHandler<MyClass>(c => Console.WriteLine(c)).ConvertTo<MyEventHandler<MyClass>>(); 
handler += new MyEventHandler<object>(c => Console.WriteLine(c)).ConvertTo<MyEventHandler<MyClass>>(); 

handler(new MyClass()); 

También es compatible con la desconexión del evento de la misma manera, mediante el uso de ConvertTo() método. A diferencia del uso de una lista personalizada de delegados, esta solución ofrece seguridad de subprocesos de fábrica.

Código completo con algunas muestras se pueden encontrar aquí:? http://ideone.com/O6YcdI