Add properties at runtime

Question

I have a class which the programmer can use to dynamically add new properties. For that it implements the ICustomTypeDescriptor to be able to override GetProperties() method.

public class DynamicProperty
{
    public object Value { get; set; }

    public Type Type { get; set; }

    public string Name { get; set; }

    public Collection<Attribute> Attributes { get; set; }
}

public class DynamicClass : ICustomTypeDescriptor
{
    // Collection to code add dynamic properties
    public KeyedCollection<string, DynamicProperty> Properties
    {
        get;
        private set;
    }

    // ICustomTypeDescriptor implementation
    PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
    {
        // Properties founded within instance
        PropertyInfo[] instanceProps = this.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);

        // Fill property collection with founded properties
        PropertyDescriptorCollection propsCollection = 
            new PropertyDescriptorCollection(instanceProps.Cast<PropertyDescriptor>().ToArray());

        // Fill property collection with dynamic properties (Properties)
        foreach (var prop in Properties)
        {
            // HOW TO?
        }

        return propsCollection;
    }
}

Is it possible to iterate over the Properties list to add each property to PropertyDescriptorCollection?

Basically I want the programmer to be able to add a DynamicProperty to a collection which will be handled by GetProperties. Something like:

new DynamicClass()
{
    Properties = {
        new DynamicProperty() {
            Name = "StringProp",
            Type = System.String,
            Value = "My string here"
        },

        new DynamicProperty() {
            Name = "IntProp",
            Type = System.Int32,
            Value = 10
        }
    }
}

Now those Properties would be setted to instance properties whenever GetPropertiesis called. Am I thinking this the right way?

Answer 1

You are already creating a collection like this:

PropertyDescriptorCollection propsCollection = 
            new PropertyDescriptorCollection(instanceProps.Cast<PropertyDescriptor>().ToArray());

But the collection you are creating only has the existing properties, not your new properties.

You need to supply a single array concatenated from the existing properties and your new properties.

Something like this:

instanceProps.Cast<PropertyDescriptor>().Concat(customProperties).ToArray()

Next problem: you need customProperties which is a collection of PropertyDescriptor. Unfortunately PropertyDescriptor is an abstract class so you don't have an easy way to create one.

We can fix this though, just define your own CustomPropertyDescriptor class by deriving from PropertyDescriptor and implementing all the abstract methods.

Something like this:

public class CustomPropertyDescriptor : PropertyDescriptor
{
    private Type propertyType;
    private Type componentType;

    public CustomPropertyDescriptor(string propertyName, Type propertyType, Type componentType)
        : base(propertyName, new Attribute[] { })
    {
        this.propertyType = propertyType;
        this.componentType = componentType;
    }

    public override bool CanResetValue(object component) { return true; }
    public override Type ComponentType { get { return componentType; } }
    public override object GetValue(object component) { return 0; /* your code here to get a value */; }
    public override bool IsReadOnly { get { return false; } }
    public override Type PropertyType { get { return propertyType; } }
    public override void ResetValue(object component) { SetValue(component, null); }
    public override void SetValue(object component, object value) { /* your code here to set a value */; }
    public override bool ShouldSerializeValue(object component) { return true; }
}

I haven't filled in the calls to get and set your properties; those calls depend on how you've implemented the dynamic properties under the hood.

Then you need to create an array of CustomPropertyDescriptor filled in with information appropriate to your dynamic properties, and concatenate it to the basic properties as I described initially.

The PropertyDescriptor not only describes your properties, it also enables client to actually get and set the values of those properties. And that's the whole point, isn't it!