¿Por qué un delegado de .NET no se declara estático?

Question

Cuando intento compilar lo siguiente:

public static delegate void MoveDelegate (Actor sender, MoveDirection args); 

recibo, como un error: "El modificador 'estático' no es válido para el presente artículo."

Estoy implementando esto en un singleton, con una clase separada que llama al delegado. El problema es que cuando uso la instancia singleton dentro de la otra clase para llamar al delegado (del identificador, no del tipo), no puedo hacer eso por la razón que sea, incluso cuando declaro que el delegado no es estático. Obviamente, solo puedo referirme a él a través del tipo directamente si y solo si el delegado es estático.

¿Cuál es el razonamiento detrás de esto? Estoy usando MonoDevelop 2.4.2.

actualización

Después de probar una de las sugerencias con el siguiente código:

public void Move(MoveDirection moveDir) 
{ 
    ProcessMove(moveDir); 
} 

public void ProcessMove(MoveDirection moveDir) 
{ 
    Teleporter.MoveMethod mm = new Teleporter.MoveMethod(Move); 
    moveDelegate(this, moveDir); 
} 

He recibido un error de procesamiento, que establece que el MoveMethod debe ser un tipo, y no una identificador.

Answer 1

Prueba esto:

public delegate void MoveDelegate(object o); 
public static MoveDelegate MoveMethod; 

Así el método de variables se pueden definir estática. La palabra clave static no tiene ningún significado para la definición delegate, al igual que las definiciones enum o const.

Un ejemplo de cómo asignar el método de campo estático:

public class A 
{ 
    public delegate void MoveDelegate(object o); 
    public static MoveDelegate MoveMethod; 
} 

public class B 
{ 
    public static void MoveIt(object o) 
    { 
    // Do something 
    }  
} 

public class C 
{ 
    public void Assign() 
    { 
    A.MoveMethod = B.MoveIt; 
    } 

    public void DoSomething() 
    { 
    if (A.MoveMethod!=null) 
     A.MoveMethod(new object()); 
    } 
} 

Answer 2

Usted está declarando un tipo delegate. No tiene sentido declararlo como static. Sin embargo, puede declarar una instancia de su tipo delegate como static.

public delegate void BoringDelegate(); 


internal class Bar { 
    public static BoringDelegate NoOp; 
    static Bar() { 
     NoOp =() => { }; 
    } 
} 

Answer 3

defina su delegado, en su clase estática declare una variable de instancia para él.

public delegate void MoveDelegate (Actor sender, MoveDirection args); 

public static MyClass 
{ 
    public static MoveDelegate MoveDelegateInstance; 
} 

Answer 4

declaración de delegado es en realidad una declaración de tipo. No puede ser estático, al igual que no puede definir una enumeración o estructura estática.

Sin embargo, prefiero usar una interfaz en lugar de raw delegate.

Considere esto:

public interface IGameStrategy { 
    void Move(Actor actor, MoveDirection direction); 
} 

public class ConsoleGameStrategy : IGameStrategy { 
    public void Move(Actor actor, MoveDirection direction) 
    { 
     // basic console implementation 
     Console.WriteLine("{0} moved {1}", actor.Name, direction); 
    } 
} 

public class Actor { 
    private IGameStrategy strategy; // hold a reference to strategy 

    public string Name { get; set; }  

    public Actor(IGameStrategy strategy) 
    { 
     this.strategy = strategy; 
    } 

    public void RunForrestRun() 
    { 
     // whenever I want to move this actor, I may call strategy.Move() method 

     for (int i = 0; i < 10; i++) 
      strategy.Move(this, MoveDirection.Forward); 
    } 
} 

En su código de llamada:

var strategy = new ConsoleGameStrategy(); 

// when creating Actors, specify the strategy you want to use 
var actor = new Actor(strategy) { Name = "Forrest Gump" }; 
actor.RunForrestRun(); // will write to console 

Este similares en espíritu a Strategy design pattern y le permite desacoplar Actor movimiento de la estrategia de implementación real (consola, gráfico, cualquiera que sea) Es posible que luego se requieran otros métodos de estrategia que lo hagan una mejor opción que un delegado.

Finalmente, puede usar un Inversion of Control framework para inyectar automáticamente la instancia de estrategia correcta en sus clases Actor, por lo que no es necesario inicializar manualmente.

Answer 5

Una declaración de delegado básicamente declara un firma de método, que solo incluye información sobre sus parámetros y el tipo de devolución. Y dado que el mismo delegado puede apuntar a métodos estáticos y de instancia, no tiene sentido hacer que la firma del método sea estática o instancia.

Una vez que haya declarado su delegado como:

public delegate void MoveDelegate (Actor sender, MoveDirection args); 

que significa que cualquier delegado de este tipo debe apuntar a un método que acepta uno Actor parámetro, uno MoveDirection parámetro y devuelve void, independientemente de si el método es estático o instancia. Puede declarar el delegado en el ámbito del espacio de nombres o dentro de una clase (del mismo modo que declararía una clase anidada).

Así que después de declarar la MoveDelegate algún lugar, puede la creación de campos y variables de ese tipo:

private MoveDelegate _myMoveDelegate; 

y recordar que el método debe tener una firma juego:

// parameters and return type must match! 
public void Move(Actor actor, MoveDirection moveDir) 
{ 
    ProcessMove (moveDir); 
} 

public static void MoveStatic(Actor actor, MoveDirection moveDir) 
{ 
    ProcessMove (moveDir); 
} 

entonces puede asignar este método a un delegado en otro lugar:

private void SomeOtherMethod() 
{ 
    // get a reference to the Move method 
    _myMoveDelegate = Move; 

    // or, alternatively the longer version: 
    // _myMoveDelegate = new MoveDelegate(Move); 

    // works for static methods too 
    _myMoveDelegate = MoveStatic; 

    // and then simply call the Move method indirectly 
    _myMoveDelegate(someActor, someDirection); 
} 

Es útil saber que .NET (a partir de la versión v3.5) proporciona algunos predefinidos delegados genéricos (Action y Func) que pueden ser utilizados en lugar de declarar sus propios delegados:

// you can simply use the Action delegate to declare the 
// method which accepts these same parameters 
private Action<Actor, MoveDirection> _myMoveDelegate; 

El uso de estos delegados es en mi humilde opinión más legible, ya que puede identificar inmediatamente la firma de los parámetros mirando al propio delegado (mientras que en su caso es necesario buscar la declaración).

Answer 6

public static delegate void MoveDelegate (Actor sender, MoveDirection args); 

Déjeme decirle lo que sucedió cuando se declaró un delegado

El compilador crea una clase, en este caso llamado MoveDelegate, y se extiende con System.MulticastDelegate.

Dado que no se puede extender ningún tipo no estático por tipo estático.

Este es el motivo por el que el compilador no permite la declaración de delegado estática. Pero aún puede tener una referencia de delegado estática.