¿Quitar llamada de constructor de delegado redundante?

Question

He descargado ReSharper y me está diciendo que cambie esta línea:

dispMap.OnDraw += new EventHandler(dispMap_OnDraw); 

que ser de esta línea:

dispMap.OnDraw += dispMap_OnDraw; 

Debido a que la primera línea es una "llamada de constructor delegado redundante."

¿Es esto cierto? En el código de diseñador generado automáticamente para formularios, la sintaxis se basa en el primer fragmento de código y al escribir en dispMap.OnDraw += y presionar TAB, el IDE genera automáticamente new EventHandler(dispMap_OnDraw)

Solo tengo curiosidad acerca de este. ¿ReSharper tiene un punto?

Answer 1

Sí, esto es correcto. Lo he hecho en varios casos.

La llamada del constructor del delegado debe estar implícita; el tipo se puede inferir de OnDraw y validado contra la firma del método dispMap_OnDraw.

Además, una cita de this MSDN article parece relevante:

Debido a que el operador + = simplemente concatena la lista interna invocación de un delegado a otro, puede utilizar los botones + = para añadir un método anónimo . Tenga en cuenta que con el manejo de eventos anónimos, no puede eliminar el método de manejo de eventos utilizando el operador - = a menos que se haya agregado el método anónimo como controlador al primero almacenarlo en un delegado y luego registrar ese delegado con el evento.

creo que la instancia se crea delegado de cualquier manera, pero ya que no tiene una referencia de objeto para el delegado cuando implícitamente una instancia, no se puede quitar con el operador -=.

Answer 2

Tiene un punto. La segunda línea es la abreviatura de la primera. Dependiendo de los estándares/convenciones de codificación, puede usar cualquiera, pero el primero agrega mucho ruido.

Answer 3

funciona bien, tengo DevExpress y me dice lo mismo!

Answer 4

Si compara el IL generado en ambos casos, verá que son iguales. Aquí está ambos casos en C#, y la IL resultan en

Ejemplo C#:.

namespace EventTest 
{ 
    public class Publisher 
    { 
     public delegate void SomeEvent(object sender); 
     public event SomeEvent OnSomeEvent; 
     public event SomeEvent OnOtherEvent; 
    } 

    public class Subscriber 
    { 
     public Subscriber(Publisher p) 
     { 
      p.OnSomeEvent += new Publisher.SomeEvent(Respond); 
      p.OnOtherEvent += Respond; 
     } 

     public void Respond(object sender) 
     { 

     } 
    } 
} 

Aquí está la IL para el constructor. Preste atención a las líneas IL_000a hasta IL_0028.

.method public hidebysig specialname rtspecialname 
     instance void .ctor(class EventTest.Publisher p) cil managed 
{ 
    // Code size  48 (0x30) 
    .maxstack 8 
    IL_0000: ldarg.0 
    IL_0001: call  instance void [mscorlib]System.Object::.ctor() 
    IL_0006: nop 
    IL_0007: nop 
    IL_0008: ldarg.1 
    IL_0009: ldarg.0 
    IL_000a: ldftn  instance void EventTest.Subscriber::Respond(object) 
    IL_0010: newobj  instance void EventTest.Publisher/SomeEvent::.ctor(object, 
                      native int) 
    IL_0015: callvirt instance void EventTest.Publisher::add_OnSomeEvent(class EventTest.Publisher/SomeEvent) 
    IL_001a: nop 
    IL_001b: ldarg.1 
    IL_001c: ldarg.0 
    IL_001d: ldftn  instance void EventTest.Subscriber::Respond(object) 
    IL_0023: newobj  instance void EventTest.Publisher/SomeEvent::.ctor(object, 
                      native int) 
    IL_0028: callvirt instance void EventTest.Publisher::add_OnOtherEvent(class EventTest.Publisher/SomeEvent) 
    IL_002d: nop 
    IL_002e: nop 
    IL_002f: ret 
} 

Conclusión: No veo ningún motivo para cambiar su código, son equivalentes.