I want to create a method that allows me to change arbitrary properties of classes that derive from my base class, the result should look like this: SetPropertyValue("size.height", 50); – where size is a property of my derived class and height is a property of size.

I'm almost done with my implementation but there's one final obstacle that I want to solve before moving on, to describe this I will first have to explain my implementation a bit:

• Properties that can be modified are decorated with an attribute
• There's a method in my base class that searches for all derived classes and their decorated properties
• For each property I generate a "property modifier", a class that contains 2 delegates: one to set and one to get the value of the property.
• Property Modifiers are stored in a dictionary, with the name of the property as key
• In my base class, there is another dictionary that contains all property-modifier-dictionaries, with the Type of the respective class as key.

What the SetPropertyValue method does is this:

• Get the correct property-modifier-dictionary, using the concrete type of the derived class (<- yet to solve)
• Get the property modifier of the property to change (e.g. of the property size)
• Use the get or set delegate to modify the property's value

Some example code to clarify further:

private static Dictionary<RuntimeTypeHandle, object> EditableTypes; //property-modifier-dictionary

protected void SetPropertyValue<T>(EditablePropertyMap<T> map, string property, object value) {
  var property = map[property]; // get the property modifier
  property.Set((T)this, value); // use the set delegate (encapsulated in a method)
}

In the above code, T is the Type of the actual (derived) class. I need this type for the get/set delegates. The problem is how to get the EditablePropertyMap<T> when I don't know what T is.

My current (ugly) solution is to pass the map in an overriden virtual method in the derived class:

public override void SetPropertyValue(string property, object value) {
  base.SetPropertyValue((EditablePropertyMap<ExampleType>)EditableTypes[typeof(ExampleType)], property, value);
}

What this does is: get the correct dictionary containing the property modifiers of this class using the class's type, cast it to the appropiate type and pass it to the SetPropertyValue method.

I want to get rid of the SetPropertyValue method in my derived class (since there are a lot of derived classes), but don't know yet how to accomplish that. I cannot just make a virtual GetEditablePropertyMap<T> method because I cannot infer a concrete type for T then. I also cannot acces my dictionary directly with a type and retrieve an EditablePropertyMap<T> from it because I cannot cast to it from object in the base class, since again I do not know T.

I found some neat tricks to infere types (e.g. by adding a dummy T parameter), but cannot apply them to my specific problem. I'd highly appreciate any suggestions you may have for me.