Question

I am creating a program where the user creates custom commands and execute them when needed. as a result I have a class similar to:

public class Command
{
    Action c { get; set; }

    // Overloaded Constructors------------------------------------

      // changes the volume                
      public Command(int volumeChange)
      {
        c = ()=>
            SomeClass.ChangeMasterVolume(volumeChange);
      }

      // Animate something
      public Command(int x, int y)
      {
        c = ()=>
            SomeClass.MoveMouse(x,y);
      }

      // etc.. there are more contructors....

   //---------------------------------------------------------


    public void ExecuteCommand()
    {
        c();
    }
}

When the user closes the application I will like to save those commands somewhere on disk. There are about 200 different commands and it will be nice if I could serialize an instance from that class. Since it contains an Action it is not possible to serialize it.

It will be nice if I don’t have to create a huge switch statement in order to determine what command to execute. What is the best way of dealing with this?

Answer 1

Sounds to me like you simply need to keep an interface around instead of a delegate.

 public interface IDoThingy
 {
      void DoStuff();
 }

 public class IncreaseVolumeThingy : IDoThingy
 {
     public int Volume { get; set; }

     public IncreaseVolumeThingy(int volume)
     {
         Volume = volume;
     }

     public void DoStuff()
     {
         SomeClass.ChangeMasterVolume(Volume);
     }
 }

 public class Command
 {
      protected IDoThingy _thingy = null;

      public Command(IDoThingy thingy)
      {
           _thingy = thingy;
      }

      public void ExecuteCommand()
      {
          _thingy.DoStuff();
      }
 }

So instead of creating a set of constructors, you simply make some form of factory based on the command specified. If the user is setting up a Increase volume command, then you new an instance of the IncreaseVolumeThingy and store it. When it is serialized, it can be recreated from state without a delegate.