C＃通用类型; 无法绑定到属性或列

Question

So I have this Generic typed class that uses System.Reflection to get all public variables from a Class and render those as Controls.

However I need to be able to use these variables as DataBindings for the Controls so when the controls receive input, that input saves to the corresponding variables.

This is what I have so far but I'm getting a 'Cannot bind to the property or column' error.

The Class:

public class ComponentControl<T> where T : Component
{
   private T component;

   public ComponentControl(T component)
   {
      this.component = component;
   }
}

The part that wont work:

foreach (var f in type.GetFields().Where(f => f.IsPublic))
{
   TextBox control = new TextBox();
   Binding binding = new Binding("Text", component, f.Name, false, DataSourceUpdateMode.OnPropertyChanged);
   control.DataBindings.Add(binding);
}

Answer 1

I think you can only bind to properties of a custom object, not fields. This seems a bit overkill but if there's an easier way I'm sure someone will correct me..

Assuming you don't want to change your fields to properties, and you really want to use binding, you could generate a kind of DTO to bind to instead. For example, here is how you would bind, so use proxyType instead of your actual type.

ComponentControl<int> component = new ComponentControl<int>() { A = "A", B = 1, C = 2 };
Type type = component.GetType();            
dynamic proxyType = DynamicProxyGenerator.GetInstanceFor<ComponentControl<int>>(component);            

foreach (var f in type.GetFields().Where(f => f.IsPublic))
{
    TextBox control = new TextBox();
    Binding binding = new Binding("Text", proxyType, f.Name, false, DataSourceUpdateMode.OnPropertyChanged);

    control.DataBindings.Add(binding);
}

And here is the code for DynamicProxyGenerator which generates that..

public static class DynamicProxyGenerator
{
    public static object GetInstanceFor<T>(T toBind)
    {
        Type typeOfT = typeof(T);

        AssemblyName assName = new AssemblyName("testAssembly");
        var assBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assName, AssemblyBuilderAccess.RunAndSave);            
        var moduleBuilder = assBuilder.DefineDynamicModule("dynamicModule", "dynamicBinder.dll");
        var typeBuilder = moduleBuilder.DefineType(typeOfT.Name + "Proxy", TypeAttributes.Public | TypeAttributes.Class);            
        FieldBuilder bindingSourceField = typeBuilder.DefineField("BindingSource", typeOfT, FieldAttributes.Public);            

        foreach (FieldInfo toCopyField in typeOfT.GetFields()) 
        {
            PropertyBuilder propBuilder = typeBuilder.DefineProperty(toCopyField.Name, System.Reflection.PropertyAttributes.None, toCopyField.FieldType, null);                             

            MethodBuilder getter = typeBuilder.DefineMethod("get_" + toCopyField.Name,  MethodAttributes.Public, toCopyField.FieldType, Type.EmptyTypes);                
            ILGenerator getIL = getter.GetILGenerator();
            getIL.Emit(OpCodes.Ldarg_0);
            getIL.Emit(OpCodes.Ldfld, bindingSourceField);
            getIL.Emit(OpCodes.Ldfld, toCopyField);
            getIL.Emit(OpCodes.Ret);
            propBuilder.SetGetMethod(getter);

            MethodBuilder setter = typeBuilder.DefineMethod("set_" + toCopyField.Name,  MethodAttributes.Public, null, new Type[] { toCopyField.FieldType });
            ILGenerator setIL = setter.GetILGenerator();
            setIL.Emit(OpCodes.Ldarg_0);
            setIL.Emit(OpCodes.Ldfld, bindingSourceField);
            setIL.Emit(OpCodes.Ldarg_1);                
            setIL.Emit(OpCodes.Stfld, toCopyField);
            setIL.Emit(OpCodes.Ret);
            propBuilder.SetSetMethod(setter);                
        }

        Type constructedType = typeBuilder.CreateType();
        dynamic instance = Activator.CreateInstance(constructedType);
        instance.BindingSource = toBind;

        return instance;
    }
}  

So what this does is create a new type on the fly that would look like this, which you can use as the binding source to act as a go between for the control and your object.

public class ComponentControlProxy
{
    public ComponentControl<int> BindingSource;

    public string A 
    {
        get 
        {
            return BindingSource.A;
        }
        set 
        {
            BindingSource.A = value;
        }
    }

    .. etc
}