Dynamically Bound Dictionary to Windows Grid

• Download source code - 11.4 KB

I had wanted to bind a Windows form DataGridView DataSource to a list of Dictionary types, and initially attempted to use a DynamicObject as an adapter. This would have been nice because then I would just need to write the DynamicObject code to look up in the dictionary. Never did get this to work. Think it is a serious oversight the Microsoft has not supported binding to DynamicObject instances, but we have to live with it. I did implement the interface with a Table, but this required conversion of the dictionary to fields in a row. Somebody pointed me to another solution, and it does have certain advantages, and probably a whole lot less overhead than using a table. It uses the ICustomTypeDescriptor. The ICustomTypeDescriptor provides an interface that supplies dynamic custom type information for an object.

All that is needed is to create a class that inherits from ICustomTypeDescriptor, which provides a variable for the Dictionary, and returns a customized PropertyDescriptor that will look up the value in the dictionary of the class inheriting from ICustomTypeDescriptor. The PropertyDescriptor does pretty much all the work:

  public class DictionaryTypeDescriptor : ICustomTypeDescriptor
  {
    private readonly Dictionary<string, object> _properties = 
            new Dictionary<string, object>();
    public object this[string name]
    {
      get { return _properties.ContainsKey(name) ? _properties[name] : null; }
      set { _properties[name] = value; }
    }
    #region ICustomTypeDescriptor Members
    public AttributeCollection GetAttributes()
    {
      return AttributeCollection.Empty;
    }
    public string GetClassName()
    {
      return TypeDescriptor.GetClassName(this, true);
    }
    public string GetComponentName()
    {
      return TypeDescriptor.GetComponentName(this, true);
    }
    public TypeConverter GetConverter()
    {
      return null;
    }
    public EventDescriptor GetDefaultEvent()
    {
      return null;
    }
    public PropertyDescriptor GetDefaultProperty()
    {
      return null;
    }
    public object GetEditor(Type editorBaseType)
    {
      return null;
    }
    public EventDescriptorCollection GetEvents(Attribute[] attributes)
    {
      return EventDescriptorCollection.Empty;
    }
    public EventDescriptorCollection GetEvents()
    {
      return EventDescriptorCollection.Empty;
    }
    public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
    {
      return new PropertyDescriptorCollection(
        _properties.Keys.Select(key => new DictionaryDescriptor(key)).ToArray());
    }
    public PropertyDescriptorCollection GetProperties()
    {
      return GetProperties(null);
    }
    public object GetPropertyOwner(PropertyDescriptor pd)
    {
      return this;
    }
    #endregion
 
    class DictionaryDescriptor : PropertyDescriptor
    {
      public DictionaryDescriptor(string name) : base(name, null) { }
      public override bool CanResetValue(object component)
      {
        return true;
      }
      public override Type ComponentType
      {
        get { return typeof(DictionaryTypeDescriptor); }
      }
      public override object GetValue(object component)
      {
        return ((DictionaryTypeDescriptor)component)[Name];
      }
      public override void SetValue(object component, object value)
      {
        ((DictionaryTypeDescriptor)component)[Name] = value;
      }
      public override bool IsReadOnly
      {
        get { return false; }
      }
      public override Type PropertyType
      {
        get { return typeof(object); }
      }
      public override void ResetValue(object component)
      {
        ((DictionaryTypeDescriptor)component)._properties.Remove(Name);
      }
      public override bool ShouldSerializeValue(object component)
      {
        return ((DictionaryTypeDescriptor)component)._properties.ContainsKey(Name);
      }
    }
  }

Using this code is very simple. In the code behind the form I have the following:

   public partial class DynamicallyBoundForm : Form
  {
    public DynamicallyBoundForm()
    {
      InitializeComponent();
 
      var obj1 = new DictionaryTypeDescriptor();
      obj1["test1"] = 100;
      obj1["test2"] = 200;
      obj1["test3"] = 300;
      var objects = new List<DictionaryTypeDescriptor>() { obj1 };
      dataGrid.DataSource = objects;
    }
  }

I made a few changes for this example from what I implemented: I made class completely dynamic so that fields could be added as needed. Also, in my code I provide a dictionary of Dictionary<string, string>.

History

10/02/12: Added source code.