Question

I’m currently working on a simple Client/Server model which sends packets within TCP packets (like HTTP) and the commands are basically ints (the first 4 bytes of each packet) and I’d like to work out an efficient way of how to process these commands.

The most obvious answer would be to write thousands of if’s or do one huge switch statement with thousand cases, but isn’t there any better way?

I’d like to create an array of events and then just raise the corresponding index so each int refers to one event which is named (such as MessageReceived). I’d also save time I think, so how could I work this out?

EDIT: The Server handles multiple connections, one for each client that is connected, so creating seperate connections for each command(s) isn’t that useful in my case.

Answer 1

Sound like a job for enums!

enum YourEnum   
{
  DoThis,
  DoThat
}

YourEnum foo = (YourEnum)yourInt;

Visual studio can even create your entire switch statement using the built in snippets and your code becomes very readable.

switch(foo)

becomes

switch(foo)
{
  case YourEnum.DoThis:
    break;
  case YourEnum.DoThat:
    break;
  default:
    break;
}

Update 1

This is a little scary from a maintainability point of view, but if you created a class like:

public class ActionProcessor
{
  public void Process(int yourInt)
  {
    var methods = this.GetType().GetMethods();
    if (methods.Length > yourInt)
    {
      methods[yourInt].Invoke(this, null);
    }
  }

  public DoThis()
  {
  }

  public DoThat()
  {
  }

or a little nicer but harder to maintain:

[AttributeUsageAttribute(AttributeTargets.Method, 
                         Inherited = false, 
                         AllowMultiple = false)]
public sealed class AutoActionAttribute : Attribute
{ 
  public AutoActionAttibute(int methodID)
  {
    this.MethodID = methodID;
  }
  public int MethodID { get; set; }
}

public class ActionProcessor
{
  public void Process(int yourInt)
  {
    var method = this.GetType().GetMethods()
      .Where(x => x.GetCustomAttribute(typeof(AutoActionAttribute), 
                                       false) != null
                  && x.GetCustomAttribute(typeof(AutoActionAttribute), 
                                       false).MethodID == yourInt)
      .FirstOrDefault();

    if (method != null)
    {
      method.Invoke(this, null);
    }
  }

  [AutoAction(1)]
  public DoThis()
  {
  }

  [AutoAction(2)]
  public DoThat()
  {
  }
}

Update 2 (Coding what I think Josh C. was talking about)

// Handles all incoming requests.
public class GenericProcessor
{
  public delegate void ActionEventHandler(object sender, ActionEventArgs e);

  public event ActionEventHandler ActionEvent;

  public ProcessAction(int actionValue)
  {
    if (this.ActionEvent != null)
    {
      this.ActionEvent(this, new ActionEventArgs(actionValue));
    }
  }
}

// Definition of values for request
// Extend as needed
public class ActionEventArgs : EventArgs
{
  public ActionEventArgs(int actionValue)
  {
    this.ActionValue = actionValue;
  }

  public virtual int ActionValue { get; private set; }
}

This you create the SomeActionProcessor that is responsible for some value:

// Handles a specific (or multiple) requests
public class SomeActionProcessor
{
  public void HandleActionEvent(object sender, ActionEventArgs e)
  {
    if (e.ActionValue == 1)
    {
      this.HandleAction();
    }
  }

  private void HandleAction()
  {
  }
}

Then create the classes and wire them up:

GenericProcessor gp = new GenericProcessor();
SomeActionProcessor sap = new SomeActionProcessor();
gp.ActionEvent += sap.HandleActionEvent;

The fire away and sending the generic processor requests:

gp.ProcessAction(1);