Pourquoi un .NET délégué ne pas être déclaré statique?

Lorsque j'essaie de compiler les suivantes:

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

Je reçois, comme une erreur: "Le modificateur" statique " n'est pas valide pour cet élément."

Je me suis mise en œuvre de ce à l'intérieur d'un singleton, avec une catégorie distincte qui appelle le délégué. Le problème est que lorsque j'utilise l'instance du singleton dans l'autre classe pour appeler le délégué (à partir de l'identifiant, pas le type), je ne peux pas le faire pour quelque raison que ce soit, même lorsque je déclare le délégué des non-statique. Évidemment, je ne peut que se référer à celui-ci via le type directement si et seulement si le délégué est statique.

Quel est le raisonnement derrière cela? Je suis à l'aide de MonoDevelop 2.4.2.

mise à jour

Après avoir essayé l'une des suggestions avec le code suivant:

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

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

J'ai reçu une erreur de traitement, qui stipule que le MoveMethod doivent être d'un type, et pas un identificateur.

Je pense qu'un petit exemple de code va vous aider à expliquer le problème. J'ai lu, deuxième alinéa, cinq fois et ont encore aucune idée de ce que et comment vous voulez accomplir.
Quel est le but de la mm variable dans le ProcessMove méthode? Si certains délégué (statique ou instance) est affecté à moveDelegate, puis de l'appel d' moveDelegate va appeler le délégué désigné, comme il se doit.
Je pense que les interfaces sont mieux pour cela. Merci de voir ma réponse

InformationsquelleAutor zeboidlund | 2011-07-26

c#compiler-errors delegates

32

Essayez ceci:
```
public delegate void MoveDelegate(object o);
public static MoveDelegate MoveMethod;
```
De sorte que la méthode de la variable peut être définie statique. Le mot-clé static n'a pas de sens pour le delegate définition , tout comme enum ou const définitions.

Un exemple de la façon d'attribuer la méthode statique-champ:
```
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()); 
  }
}
```
- Je ne suis pas tout à fait la suite. Est censé être un champ public, ou une méthode? Si c'est un champ, est-il censé faire référence à une instance d'un délégué? Quand j'essaie de le référencer dans ma classe, j'obtiens une erreur :/.
- J'ai ajouté un exemple. Comme vous pouvez le voir, la méthode statique variable-fonctionne comme un champ statique.
- L'énoncé "tout comme enum ou des définitions de constantes" ne semble pas correcte. const est par défaut statique dans la nature, donc nous ne pouvons pas avoir statique pour des champs de type const. L'exemple donné est bon.
- Salut C. Zonnenberg, Est-il obligatoire en C# pour la méthode B.MoveIt être statique? Et pourquoi?
InformationsquelleAutor Chaim Zonnenberg
8

De déclarer une delegate type. Il ne ferait aucun sens de le déclarer comme static. Vous pouvez déclarer une instance de votre delegate type static, si.
```
public delegate void BoringDelegate();


internal class Bar {
    public static BoringDelegate NoOp;
    static Bar() {
        NoOp = () => { };
    }
}
```
- Il pourrait "faire sens" et, en fait, être très utile d'être en mesure de déclarer un delegate qui ne peut jamais représenter une méthode d'instance, c'est à dire qui ne serait pas géré __thiscall, mais plutôt un nécessairement statique méthode gérée (sur un statique ou d'une instance de la classe). Tel un "délégué" type aurait pas Delegate.Target de la propriété, et c'est les instances aurait aucune disposition pour le stockage d'un this objet... peut-être une classe de base pour les Delegate type? L'avantage serait émettant call au lieu de callvirt dans l'IL, ce qui pourrait également éviter d'empiler une valeur null this valeur.
InformationsquelleAutor jason
5

Un délégué de la déclaration déclare essentiellement un signature de la méthode, qui ne comprend que des informations sur ses paramètres et le type de retour. Et depuis le même délégué peut point à la fois statiques et méthodes d'instance, il n'est pas judicieux de faire de la signature de la méthode elle-même en statique ou en instance.

Une fois que vous avez déclaré votre délégué:
```
public delegate void MoveDelegate (Actor sender, MoveDirection args);
```
cela signifie que tous les délégués de ce type doit point une méthode qui accepte un Actor paramètre, on MoveDirection paramètre, et retourne void, indépendamment du fait que la méthode est statique ou de l'instance. Vous pouvez déclarer le délégué à la portée espace de noms, ou à l'intérieur d'une classe (comme vous le feriez déclarer une classe imbriquée).

Donc, après avoir déclaré le MoveDelegate quelque part, vous pouvez créer des champs et des variables de ce type:
```
private MoveDelegate _myMoveDelegate;
```
et n'oubliez pas que la méthode doit avoir un correspondant signature:
```
//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);
}
```
ensuite, vous pouvez affecter cette méthode à un délégué à un autre endroit:
```
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);
}
```
Il est utile de savoir que .NET (à partir de la version v3.5) fournit quelques prédéfinis générique délégués (Action et Func) qui peut être utilisé au lieu de déclarer vos propres délégués:
```
//you can simply use the Action delegate to declare the
//method which accepts these same parameters
private Action<Actor, MoveDirection> _myMoveDelegate;
```
À l'aide de ces délégués est à mon humble avis plus lisible, puisque vous pouvez identifier immédiatement des paramètres de la signature de regarde le délégué lui-même (alors que, dans votre cas, il suffit de regarder pour la déclaration).
- Vos commentaires sur la signature d'un délégué sont ok, mais sans rapport avec la question de savoir si le délégué exemple représente un statique vs. exemple méthode. Que pourrait ce que l'OP a été atteint pour les... au moins c'est comment je me suis retrouvé sur cette page. Peut-être que votre réponse pourrait mentionner le fait que les deux instances du même type délégué peut représenter méthodes avec sensiblement la même signature, mais où l'on est statique et l'autre instance. C'est une différence importante qui doit être comprise, en dépit de C#d'efforts pour l'obscurcir. Voir mon autre commentaire pour d'autres motivations.
- Je viens de trouver une discussion de la (impie, à mon humble avis) relation entre le statique vs instance délégués à msdn.microsoft.com/en-us/library/z84bd3st(v=vs. 110).aspx. Il y a un très bon exemple de code en bas.
- peut-être que je devrais mettre à jour la réponse, mais la vérité est que les délégués dans .NET peut point d'instance et des méthodes statiques, et stocke les informations sur la cible à l'interne. En fait, il y a plusieurs façons différentes de ce magasin, comme expliqué ici, sous les "Différents types de délégués". Type interne du délégataire permettra de déterminer la façon dont les paramètres seront organisées sur la pile par la Gigue afin de correspondre à la cible de la signature, tout en permettant d'appeler le code de manière transparente passer des paramètres à un délégué.
- Le moteur d'exécution différence entre l'instance et les méthodes statiques est fondamentalement dans l'implicite this paramètre, c'est à dire le exemple de référence pour la méthode d'instance. Dans le cas le plus simple (fermé type délégué), les délégués pointant vers des méthodes d'instance aura l'instance dans son _target terrain, tandis que les délégués pointant vers des méthodes statiques qui aura le premier paramètre qui y sont stockées. .NET utilise habituellement (au moins c'était d') fermé instance de délégués et de ouvrir statique délégués, ce qui signifie qu'en général, la méthode d'instance appels (par l'intermédiaire d'un délégué) sont plus rapides parce qu'ils n'ont pas besoin d'un thunk shuffle.
- Oui, et de mon point est que tout cela est beaucoup trop fonctionnelle de variation de réunir en un seul opaque véhicule. Je suis le seul à en plaidant pour que le plus en vue de l'exposer les distinctions qui existent déjà, et que vous en fait corroborer (c.f. "Les différents types de délégués", pour ce qui de mon point de vue pourrait boutade, "Où?!..."). Statique vs instance de distinction pour les délégués, et un régime administratif, permettrait de mieux sensibiliser et de prévenir douloureux, mais commun à des erreurs de codage, le pire étant la façon statique lambdas sont silencieusement promu exemple, lorsqu'un local, par inadvertance, tombe dans la fermeture.
InformationsquelleAutor Groo
2

Délégué déclaration est en fait une déclaration de type. Il ne peut pas être statique, tout comme vous ne pouvez pas définir une statique enum ou de la structure.

Cependant, je préfère utiliser une interface au lieu de raw délégué.

Considérez ceci:
```
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);
    }
}
```
Dans votre code d'appel:
```
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
```
Ce même esprit de Stratégie de modèle de conception et vous permet de découpler Actor mouvement à partir de la mise en œuvre effective de la stratégie (console, graphique, peu importe). Autre stratégie méthodes peuvent être exigés par la suite ce qui en fait un meilleur choix qu'un délégué.

Enfin, vous pouvez utiliser un Inversion du cadre de Contrôle de la pour injecter automatiquement stratégie correcte instance dans votre Actor classes, donc il n'est pas nécessaire pour l'initialisation manuelle.
- Je suis en train d'écrire un texte basé sur le moteur de jeu qui me permet de créer des objets et de les déplacer autour de la carte, l'affichage de leurs coordonnées objet de la console. C'est à faire avant que l'interface graphique, graphiques, etc. est ajouté. J'en suis au point où j'ai décidé de créer un téléporteur classe, j'ai fait un singleton, à utiliser pour déplacer n'importe quel objet à une destination spécifique. Pour l'instant je garde les choses simples: MoveDirection.En avant, ou MoveDirection.En arrière. Si vous voulez que je poste source, laissez-moi savoir.
- Je préfère aller avec les interfaces (si j'ai reçu votre problème de droit). Veuillez voir mon edit.
InformationsquelleAutor Dan Abramov

définir votre délégué, dans votre classe statique déclarer une variable d'instance pour elle.

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

public static MyClass
{
     public static MoveDelegate MoveDelegateInstance;
}

InformationsquelleAutor Darryl Braaten

-1
```
public static delegate void MoveDelegate (Actor sender, MoveDirection args);
```
Laissez-moi vous dire ce qui s'est passé lorsque vous avez déclaré un délégué

Le compilateur crée une classe, dans ce cas appelé MoveDelegate, et l'étend avec System.MulticastDelegate.

Puisque vous ne pouvez pas étendre non statique type par type statique.

C'est la raison pourquoi le compilateur ne permet pas de délégué statique déclaration.
Mais encore, vous pouvez avoir délégué statique de référence.

InformationsquelleAutor Sudhakar Pandey

Vous devez vous connecter pour publier un commentaire.