Question

I’m trying to build a generic model binder that uses reflection to assign properties to a specified type of object retrieved from the BindingContext. So something like this:

public class ModelBinder : IModelBinder
{
    public object BindModel<T, K> (ControllerContext controllerContext, ModelBindingContext bindingContext)
        where T : class, new()
        where K : class
    {
        Type ObjectType = typeof(T);
        Type InterfaceType = typeof(K);
        T obj = new T();

        foreach (var Property in ObjectType.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance))
        {
            Type PropertyType = Property.PropertyType;

            // checks if property is a custom data object
            if (!(PropertyType.GetGenericArguments().Count() > 0 && PropertyType.GetGenericArguments()[0].GetInterfaces().Contains(InterfaceType)))
            {
                Property.SetValue(obj, bindingContext.ValueProvider.GetValue(Property.Name), null);   
            }
        }

        return obj;
    }

Obviously this doesn’t work as it isn’t correctly implementing the IModelBinder interface. Is something like this possible?

Edit:

To expand on why I am doing this, our objects use a lot of different custom objects. For instance, the Class object:

public class Class : ModelBase<Class>
{
    public Class () { }

    public virtual string ClassDescription { get; set; }
    public virtual string ClassName { get; set; }
    public virtual LookUp ClassType { get; set; }
    public virtual double Credits { get; set; }
    public virtual bool Documents { get; set; }
    public virtual LookUp PracticeArea { get; set; }
}

uses the LookUp class:

public class LookUp : ModelBase<LookUp>
{
    public LookUp () { }

    public virtual string DisplayName { get; set; }
    public virtual LookUpType Type { get; set; }
}

dropdowns are used for LookUps and other objects so my custom model binder for Class/Create would do something like:

LookUp ClassType = LookUp.Load(long.Parse(bindingContext.ValueProvider.GetValue("ClassType").AttemptedValue))

I don’t see how something like this can be dealt with using the DefaultModelBinder.

Answer 1

So I’ve come up with a working (for now) solution. It’s not very generic at the moment but it works for my purposes.

public class ModelBinder : DefaultModelBinder
{
    public override object BindModel (ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        var ModelType = bindingContext.ModelType;
        var Instance = Activator.CreateInstance(ModelType);
        var Form = bindingContext.ValueProvider;

        foreach (var Property in ModelType.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance))
        {
            Type PropertyType = Property.PropertyType;

            // I'm using an ORM so this checks whether or not the property is a
            // reference to another object
            if (!(PropertyType.GetGenericArguments().Count() > 0 ))
            {
                // This is the not so generic part.  It really just checks whether or 
                // not it is a custom object.  Also the .Load() method is specific
                // to the ORM
                if (PropertyType.FullName.StartsWith("Objects.Models"))
                {
                    var Load = PropertyType.GetMethod("Load", BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Static, null, new Type[] { typeof(long) }, null);
                    var Value = Load.Invoke(new object(), new object[] { long.Parse(Form.GetValue(Property.Name + ".ID").AttemptedValue) });
                    Property.SetValue(Instance, Value, null);
                }
                // checkboxes are weird and require a special case
                else if (PropertyType.Equals(typeof(bool)))
                {
                    if (Form.GetValue(Property.Name) == null)
                    {
                        Property.SetValue(Instance, false, null);
                    }
                    else if (Form.GetValue(Property.Name).Equals("on"))
                    {
                        Property.SetValue(Instance, true, null);
                    }
                }
                else
                {
                    Property.SetValue(Instance, Convert.ChangeType(bindingContext.ValueProvider.GetValue(Property.Name).AttemptedValue, PropertyType), null);
                }
            }
        }

        return Instance;
    }
}