C# dynamic classes

I'm talking about something similar to dynamic. This didn't answer my question, hence this question. I want to have a class that I can add properties to at runtime. It needs to be inherited from the type object.

I've seen inheriting from DynamicObject, but it didn't state how to add properties at run-time. Could some light be shed on this for me pls开发者_高级运维?

I have a class like this:

public class SomeModel : DynamicObject {
       public string SomeMandatoryProperty {get; set;}
}

I'd like to add all properties from another class to this class at runtime. So eg.

SomeModel m = new SomeModel();
m = someOtherClass;
string hi = m.otherClassProp; //Property from other class is added.
string mandatory = m.SomeMandatoryProperty; //From the mandatory property set previously.

I think you are looking for ExpandoObject:

The ExpandoObject class enables you to add and delete members of its instances at run time and also to set and get values of these members. This class supports dynamic binding, which enables you to use standard syntax like sampleObject.sampleMember instead of more complex syntax like sampleObject.GetAttribute("sampleMember").

dynamic manager;

manager = new ExpandoObject();
manager.Name = "Allison Brown";
manager.Age = 42;
manager.TeamSize = 10;

You should be able to make use of ExpandoObject instead. An ExpandoObject can have members added or removed at runtime and has very nice support if you want to convert to XML etc.

From MSDN Documentation:

    dynamic employee, manager;

    employee = new ExpandoObject();
    employee.Name = "John Smith";
    employee.Age = 33;

    manager = new ExpandoObject();
    manager.Name = "Allison Brown";
    manager.Age = 42;
    manager.TeamSize = 10;

You'd want to use the ExpandoObject as you can dynamically add properties as needed. There isn't however a direct way to populate an instance with the values from another object easily. You'll have to add it manually using reflection.

Do you want to write a wrapper object where you could add properties to while still accessing the inner? You may want to consider it that way you don't have to manage two copies of values between two different object instances. I wrote a test class to wrap string objects to demonstrate how you can do this (similar to how the ExpandoObject works). It should give you an idea on how you can do this for your types.

class DynamicString : DynamicObject
{
    static readonly Type strType = typeof(string);
    private string instance;
    private Dictionary<string, object> dynProperties;
    public DynamicString(string instance)
    {
        this.instance = instance;
        dynProperties = new Dictionary<string, object>();
    }
    public string GetPrefixString(string prefix)
    {
        return String.Concat(prefix, instance);
    }
    public string GetSuffixString(string suffix)
    {
        return String.Concat(instance, suffix);
    }
    public override string ToString()
    {
        return instance;
    }
    public override bool TryConvert(ConvertBinder binder, out object result)
    {
        if (binder.Type != typeof(string))
            return base.TryConvert(binder, out result);
        result = instance;
        return true;
    }
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        var method = strType.GetMethod(binder.Name, args.Select(a => a.GetType()).ToArray());
        if (method == null)
        {
            result = null;
            return false;
        }
        result = method.Invoke(instance, args);
        return true;
    }
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        var members = strType.GetMember(binder.Name);
        if (members.Length > 0)
        {
            var member = members.Single();
            switch (member.MemberType)
            {
            case MemberTypes.Property:
                result = ((PropertyInfo)member).GetValue(instance, null);
                return true;
                break;
            case MemberTypes.Field:
                result = ((FieldInfo)member).GetValue(instance);
                return true;
                break;
            }
        }
        return dynProperties.TryGetValue(binder.Name, out result);
    }
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        var ret = base.TrySetMember(binder, value);
        if (ret) return true;
        dynProperties[binder.Name] = value;
        return true;
    }
}

If you want to be adventurous, you can define your own meta objects to handle the bindings. You could end up with reusable meta objects for different types and simplify your code immensely. I've been playing with this for a while and have this so far. It doesn't handle dynamically adding properties yet. I won't be working on this any further but I'll just leave it here for reference.

class DynamicString : DynamicObject
{
    class DynamicStringMetaObject : DynamicMetaObject
    {
        public DynamicStringMetaObject(Expression parameter, object value)
            : base(parameter, BindingRestrictions.Empty, value)
        {
        }
        public override DynamicMetaObject BindConvert(ConvertBinder binder)
        {
            if (binder.Type == typeof(string))
            {
                var valueType = Value.GetType();
                return new DynamicMetaObject(
                    Expression.MakeMemberAccess(
                        Expression.Convert(Expression, valueType),
                        valueType.GetProperty("Instance")),
                    BindingRestrictions.GetTypeRestriction(Expression, valueType));
            }
            return base.BindConvert(binder);
        }
        public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
        {
            System.Diagnostics.Trace.WriteLine(String.Format("BindGetMember: {0}", binder.Name));
            var valueType = Value.GetType();
            var self = Expression.Convert(Expression, valueType);
            var valueMembers = valueType.GetMember(binder.Name);
            if (valueMembers.Length > 0)
            {
                return BindGetMember(self, valueMembers.Single());
            }
            var members = typeof(string).GetMember(binder.Name);
            if (members.Length > 0)
            {
                var instance =
                    Expression.MakeMemberAccess(
                        self,
                        valueType.GetProperty("Instance"));
                return BindGetMember(instance, members.Single());
            }
            return base.BindGetMember(binder);
        }
        private DynamicMetaObject BindGetMember(Expression instance, MemberInfo member)
        {
            return new DynamicMetaObject(
                Expression.Convert(
                    Expression.MakeMemberAccess(instance, member),
                    typeof(object)),
                BindingRestrictions.GetTypeRestriction(Expression, Value.GetType())
            );
        }
    }
    public string Instance { get; private set; }
    public DynamicString(string instance)
    {
        Instance = instance;
    }
    public override DynamicMetaObject GetMetaObject(Expression parameter)
    {
        return new DynamicStringMetaObject(parameter, this);
    }
    public override string ToString()
    {
        return Instance;
    }
    public string GetPrefixString(string prefix)
    {
        return String.Concat(prefix, Instance);
    }
    public string GetSuffixString(string suffix)
    {
        return String.Concat(Instance, suffix);
    }
}