Switchable Unique Identifier in C#

Question

I'm implementing a system to send Messages between different parts of a program I'm writing. There are some generic message types as well as some specific to each part of the program. I would like to avoid the hierarchy rot inherent in deriving from a base message class for each type, So i'm encapsulating this type in an int or ushort. Then, I centralize the different types with a "Messages" namespace, and a static class with a bunch of constants. However, I ran into the issue of having to maintain a list of unique numbers for each different section:

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

Then elsewhere

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

Having that arbitrary 11 seems difficult, especially if I have several of these, maintaining and updating to make sure there are no collisions seems to be a pain. Is there an easy solution in order to make sure each reference to this is unique? I tried using static readonly, initializing them off of a Unique.ID() function in a static constructor, but if I do that I am unable to switch() over the passed Message type, as it says "A constant type is expected" for each case.

Answer 1

Is there some reason you aren't using enums?

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

-- Edit:

Elaborating on my comment, Consider

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

You can use a number range for each class. Define a base number for the class and add 0, 1, 2, etc to that base number.

Answer 3

If you want to keep them numeric one way is to divide them into different magnitudes:

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...
    }

}

Then you just need to make sure that you keep within the boundaries for each type of message.

Answer 4

This isn't automatic, but it may be a bit easier to maintain then copying the values everywhere:

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

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

So, you can have all of your specific enums start with the value from a previous enum set and build them up like that.

In your actual objects, you could store them as int's and just convert whatever enum value to the appropriate int.

Although, it seems that inheritance may be inevitable in this case since there is a natural hierarchy in your data model.

Answer 5

I suggest you lookup the difference between 'command' & 'message', this might help you come to the conclusion that the use of magic numbers\enums inside messages is a bad idea.

Ideally you want to create 'commands' that are observed and actioned by listeners...

HTH

Ollie

Answer 6

If you really, really want to do this, you can create one generic private Enum that holds all of the possible values.

You can then expose those values through your separate classes as read-only properties that expose the enums as Int32s - e.g.

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 ; }
        }
    }
}

However - I'd recommend you redesign your solution. This seems to be asking for trouble (as I'm sure people will comment on)