¿Por qué no puedo poner un delegado en una interfaz?

Question

¿Por qué no puedo agregar un delegado a mi interfaz?

Answer 1

A Delegate es un type que no se puede declarar en una interfaz. Es posible que desee utilizar un evento (si corresponde) o declarar un delegado fuera de la interfaz, pero en el mismo espacio de nombres.

Este enlace puede Ayuda- When to Use Delegates Instead of Interfaces

Answer 2

Un delegado es simplemente otro tipo, por lo que no se gana nada al ponerlo dentro de la interfaz.

No debería necesitar crear sus propios delegados. La mayoría de las veces debe usar EventHandler, Func, Predicate o Action.

¿Puedo preguntar cómo es tu delegado?

Answer 3

Puede utilizar cualquiera de estos:

public delegate double CustomerDelegate(int test); 
public interface ITest 
{ 
    EventHandler<EventArgs> MyHandler{get;set;} 
    CustomerDelegate HandlerWithCustomDelegate { get; set; } 
    event EventHandler<EventArgs> MyEvent; 
} 

Answer 4

La documentación dice claramente que se puede definir un delegado en una interfaz:

Una interfaz contiene sólo los firmas de los métodos, los delegados o eventos.

MSDN: interface (C# Reference)

Sin embargo, en los comentarios en la misma página se dice que una interfaz puede incluir firmas de métodos, propiedades y eventos indexadores.

Si intenta poner un delegado en una interfaz, el compilador dice que "las interfaces no pueden declarar tipos".

El estándar Ecma-334 (8.9 Interfaces) está de acuerdo con los comentarios en esa página y en el compilador.

Answer 5

este es un decalaration delegado TIPO ...

public delegate returntype MyDelegateType (params) 

esto no puede ser declarado en una interfaz, ya que es una declaración de tipo

sin embargo con la declaración de tipo de arriba se puede utilizar una instancia de delegado

MyDelegateType MyDelegateInstance (get; set;) 

tan delegar casos están bien, pero tipo de delegado declaraciones no son (en una interfaz)

Answer 6

Como han mencionado otros, solo puede definir delegados fuera de de la interfaz.

No hay nada malo con los delegados. personalmente creo que Func<int, double> es menos deseable que utilizan delegados:

1. No se puede nombrar a los argumentos, por lo que el significado argumento puede ser ambigua

2. Es noticia vieja que los acontecimientos no es seguro para subprocesos, por lo tanto el siguiente código no es ideal:

   if (MyFuncEvent != null) 
   { 
       MyFuncEvent(42, 42.42); 
   } 
   

   Ver: http://kristofverbiest.blogspot.com/2006/08/better-way-to-raise-events.html

   El código más seguro es:

   MyFuncEventHandler handler = MyFuncEvent; 
   if (handler != null) 
   { 
       handler(42, 42.42); 
   } 
   

3. Usted tiene que duplicar la firma del evento si desea guardarla en una variable (o puede utilizar var, lo que me gusta). Si tiene muchos argumentos, esto puede ser muy tedioso (nuevamente, siempre puede ser flojo y usar var).

   Func<int, double, string, object, short, string, object> handler = MyFuncEvent; 
   if (handler != null) 
   { 
       handler(42, 42.42, ...); 
   } 
   

Los delegados se salvan de tener que duplicar la firma del método/evento cada vez que desee asignar a un tipo variable.

Answer 7

Un método de interfaz puede aceptar un delegado como parámetro, no hay problemas. (¿Tal vez no veo el problema?) Pero si la intención es especificar una llamada saliente en la interfaz, use un evento.

Hay tantos pequeños detalles, que es mucho más fácil mostrar sólo algunas código en lugar de tratar de describir todo en prosa. (Lo siento, incluso el ejemplo de código es un poco hinchado ...)

namespace DelegatesAndEvents 
{ 
    public class MyEventArgs : EventArgs 
    { 
     public string Message { get; set; } 
     public MyEventArgs(string message) { Message = message; } 
    } 

    delegate void TwoWayCallback(string message); 
    delegate void TwoWayEventHandler(object sender, MyEventArgs eventArgs); 

    interface ITwoWay 
    { 
     void CallThis(TwoWayCallback callback); 

     void Trigger(string message); 
     event TwoWayEventHandler TwoWayEvent; 
    } 

    class Talkative : ITwoWay 
    { 
     public void CallThis(TwoWayCallback callback) 
     { 
      callback("Delegate invoked."); 
     } 

     public void Trigger(string message) 
     { 
      TwoWayEvent.Invoke(this, new MyEventArgs(message)); 
     } 

     public event TwoWayEventHandler TwoWayEvent; 
    } 

    class Program 
    { 
     public static void MyCallback(string message) 
     { 
      Console.WriteLine(message); 
     } 

     public static void OnMyEvent(object sender, MyEventArgs eventArgs) 
     { 
      Console.WriteLine(eventArgs.Message); 
     } 

     static void Main(string[] args) 
     { 
      Talkative talkative = new Talkative(); 

      talkative.CallThis(MyCallback); 

      talkative.TwoWayEvent += new TwoWayEventHandler(OnMyEvent); 
      talkative.Trigger("Event fired with this message."); 

      Console.ReadKey(); 
     } 
    } 
}