Question

In my app, I have deal with several different “parameters”, which derive from IParameter interface, and also ParamBase abstract base class. I currently have two different parameter types, call them FooParameter and BarParameter, which both derive from ParamBase. Obviously, I can treat them both as IParameters when I need to deal with them generically, or detect their specific type when I need to handle their specific functionality.

My question lies in specific FooParameters. I currently have a few specific ones with their own classes which derive from FooParameter, we’ll call them FP12, FP13, FP14, etc. These all have certain characteristics, which make me treat them differently in the UI. (Most have names associated with the individual bits, or ranges of bits). Note that these specific, derived FP’s have no additional data associated with them, only properties (which refer to the same data in different ways) or methods.

Now, I’d like to keep all of these parameters in a Dictionary<String, IParameter> for easy generic access. The problem is, if I want to refer to a specific one with the special GUI functions, I can’t write:
FP12 fp12 = (FP12)paramList["FP12"] because you can’t downcast to a derived type (rightfully so). But in my case, I didn’t add any data, so the cast would theoretically work.

What type of programming model should I be using instead? Thanks!

Answer 1

There’s nothing really wrong with this approach, except for maybe storing the parameters in a dictionary. What is the purpose of doing that? Especially if you key them on their class name.

I would just use a List<IParameter> and have a control go through the collection and pick the right subclass out of there.

m_Parameters = new List<IParameter>();
//This control needs FP12
foreach(var param in Parameters) {
  var fp12 = param as FP12;
  if (fp12 != null) {
    //do something with the param.
    break;
  }
}

After writing the above I think I finally understand what you are trying to do. If you want to perform an operation that is available on FP12 on any subclass of FooParameter then you need to take that operation out of FooParameter altogether. Since your parameter is data and that data is the same across different subclasses of FooParameter, it makes sense to only have one implementation of FooParameter (“data” class) and multiple “operation” classes.

//The one implementation of IParameter for all FooParameters
public class FooParameter : IParameter {
  string Data1 {get;set;}
}

//base class for Foo Operation, only stores FooParameter 
public class FooOperationBase {
  protected readonly FooParameter m_Param;
  public FooOperationBase (FooParameter param) {
    m_Param = param;
  } 
}

//specific operations on FooParameter go in this class
public class FooOperation12 : FooOperationBase {
  public FooOperation12(FooParameter param) : base(param) {}

  public void DoSomeOperation() {
    return m_Param.Data1 + " transformed";
  }
}