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.