Identificateur unique commutable en C#

Question

Je suis en train de mettre en place un système pour envoyer des messages entre différentes parties d'un programme que j'écris. Il y a quelques types de messages génériques ainsi que certains spécifiques à chaque partie du programme. Je voudrais éviter la pourriture de la hiérarchie inhérente à la dérivation d'une classe de message de base pour chaque type, donc j'encapsule ce type dans un int ou ushort. Ensuite, je centralise les différents types avec un espace de noms "Messages", et une classe statique avec un tas de constantes. Cependant, je suis tombé sur la question d'avoir à maintenir une liste de numéros uniques pour chaque section différente:

namespace Messages 
{ 
    public static class Generic 
    { 
     public const Int32 Unknown = 0; 
     public const Int32 Initialize = 1; 
     ... 
     public const Int32 Destroy = 10; 
    } 
} 

Ensuite ailleurs

namespace Messages 
{ 
    public static class Graphics 
    { 
     public const Int32 Unknown = 0; 
     public const Int32 AddGraphic = 11; // <-- ? 
    } 
} 

Ayant cette 11 arbitraire semble difficile, surtout si j'ai plusieurs ceux-ci, le maintien et la mise à jour pour s'assurer qu'il n'y a pas de collisions semble être une douleur. Y a-t-il une solution facile pour s'assurer que chaque référence à ceci est unique? J'ai essayé d'utiliser readonly statique, en les initialisant d'une fonction Unique.ID() dans un constructeur statique, mais si je le fais, je suis incapable de basculer() sur le type Message transmis, comme il est dit "Un type constant est attendu" pour chaque cas.

Answer 1

Y a-t-il une raison pour laquelle vous n'utilisez pas d'énumérations?

public enum MessageTypes 
{ 
    Unknown, 
    Initialize, 
    ... 
} 

- Edit:

Élaborant sur mon commentaire, tenez compte

enum MessageType 
{ 
    Update, 
    Delete, 
    Destroy 
} 

MessageType t = ...; 

switch(t){ 
    case MessageType.Update: 
     DoUpdate(); 
    } 
} 

Versus:

interface IActionable 
{ 
    void Do(); 
} 


public abstract class ActionableBase : IActionable 
{ 
    // some other things 

    public abstract void Do(); 
} 


public class UpdateAction : ActionableBase 
{ 
    public override void Do() 
    { 
     // Update Code 
    } 
} 

... 

IActionable a = ...; 
a.Do(); 

Answer 2

Vous pouvez utiliser une plage de numéros pour chaque classe. Définissez un numéro de base pour la classe et ajoutez 0, 1, 2, etc. à ce numéro de base.

Answer 3

Si vous voulez les garder numérique est une façon de les diviser en différentes grandeurs:

namespace Messages 
{ 
    public static class Generic 
    { 
     // these messages are 3-figure numbers 
     public const Int32 Unknown = 0; 
     public const Int32 Initialize = 101; 
     ... 
     public const Int32 Destroy = 110; 
    } 

    public static class Graphics 
    { 
     // these messages are 4-figure numbers 
     public const Int32 Unknown = 0; 
     public const Int32 AddGraphic = 1001; // <-- ? 
     // and so on... 
    } 

} 

Ensuite, vous devez juste vous assurer que vous gardez dans les limites pour chaque type de message.

Answer 4

Ce n'est pas automatique, mais il peut être un peu plus facile à maintenir puis de copier les valeurs partout:

public enum Generic 
    { 
     Unknown = 0, 
     Initialize = 1, 
     Destroy = 10 
    } 

    public enum Graphics 
    { 
     AddGraphic = Generic.Destroy + 1 
    } 

Ainsi, vous pouvez avoir tous vos énumérations spécifiques commencer par la valeur d'une ENUM précédente définir et les construire comme ça.

Dans vos objets réels, vous pouvez les stocker sous forme d'int et convertir simplement la valeur enum à l'int approprié. Bien qu'il semble que l'héritage soit inévitable dans ce cas, il existe une hiérarchie naturelle dans votre modèle de données.

Answer 5

Je vous suggère de rechercher la différence entre 'command' & 'message', ceci pourrait vous aider à arriver à la conclusion que l'utilisation de nombres magiques \ enums dans les messages est une mauvaise idée.

Idéalement, vous voulez créer des «commandes» qui sont observées et actionnées par les auditeurs ...

HTH

Ollie

Answer 6

Si vous avez vraiment, vraiment envie de le faire, vous pouvez créer un Enum privé générique qui contient toutes les valeurs possibles.

Vous pouvez ensuite exposer ces valeurs à travers vos classes séparées en tant que propriétés en lecture seule qui exposent les énumérations en tant qu'Int32 - par ex.

namespace Messages 
{ 
    private enum AllMessageTypes 
    { 
     Update, 
     Delete, 
     Destroy, 
     AddGraphic 
    } 

    public static class Generic 
    { 
     public Int32 Update 
     { 
      get { return (Int32)AllMessageTypes.Update; } 
     } 
     ... 
    } 

    public static class Graphics 
    { 
     public Int32 AddGraphic 
     { 
      get { return (Int32)AllMessageTypes.AddGraphic ; } 
     } 
    } 
} 

Cependant, je vous recommande de revoir votre solution. Cela semble poser des problèmes (comme je suis sûr que les gens vont commenter)