Class derive from Collection

Hi

I have  a question...

I have a class  which is derive from ObservableCollection<item>.
The structure seems like this.

class MyClass : ObservableCollection<Item>
{
     MyClass()
     {
          Add(new Item("item1");
          Add(new Item("item2");
          Add(new Item("item3");
     }

     string Property1 { get;set; }
     bool Property2 { get;set; }
     OtherClass Property3 { get;set; }
}

Currently, PropertyEditor just show Items property from MyClass. (which are item1, item2, and item3)
I need to show my other properties (Property1, Property2, and Property3) in my PropertyEditor.

How is the best approach for that.

Thanks before.

That's a bit of a tricky one.  We deliberately do not show properties of collection objects (that is, any object that implements IList or IDictionary) because we don't want spurious properties such as Count appearing in the grid.

One possible workaround is to implement ICustomTypeDescriptor on MyClass, but this will require you to synthesise pseudo-properties for the collection elements (e.g. separate Item1, Item2 and Item3 properties) (because PropertyDescriptor doesn't support indexed properties), and will deny you the add/remove behaviour.

If this is not acceptable then we will need to tweak the grid to allow properties of collection types to "opt in" to being displayed.  Let us know if you need us to do this.

Can you provide a simple example using ICustomTypeDescriptor please.
Which method from ICustomTypeDescriptor should I implement and how.

Thanks.

Well, you should implement all methods from ICustomTypeDescriptor, but for most of them you would just delegate to the equivalent TypeDescriptor method.  For example:

AttributeCollection ICustomTypeDescriptor.GetAttributes()
{
  return TypeDescriptor.GetAttributes(this, true);
}

The only substantive implementations are the GetProperties() methods, and your implementation will look something like this:

public PropertyDescriptorCollection GetProperties()
{
  Type thisType = GetType();

  List<PropertyDescriptor> descriptors = new List<PropertyDescriptor>();

  foreach (PropertyInfo property in thisType.GetProperties())
  {
    if (property.GetIndexParameters().Length == 0 && property.DeclaringType == thisType /* don't want inherited properties like Count */)
    {
      PropertyDescriptor descriptor = TypeDescriptor.CreateProperty(GetType(), property.Name, property.PropertyType /* ignoring attributes for now */);
      descriptors.Add(descriptor);
    }
    else if (property.GetIndexParameters().Length == 1)
    {
      for (int i = 0; i < Count; ++i)
      {
        PropertyDescriptor descriptor = new IndexedPropertyDescriptor(property, i);
        descriptors.Add(descriptor);
      }
    }
  }

  return new PropertyDescriptorCollection(descriptors.ToArray(), true);
}

This needs a helper class which I have called IndexedPropertyDescriptor which represents the "fake" properties that wrap the collection items:

private class IndexedPropertyDescriptor : PropertyDescriptor
{
  private PropertyInfo _property;
  private object[] _index;

  public IndexedPropertyDescriptor(PropertyInfo property, int index)
    : base(property.Name + index.ToString(), new Attribute[0] /* copping out */)
  {
    _property = property;
    _index = new object[] { index };
  }

  public override bool CanResetValue(object component)
  {
    return false;
  }

  public override Type ComponentType
  {
    get { return typeof(MyClass); }
  }

  public override object GetValue(object component)
  {
    return _property.GetValue(component, _index);
  }

  public override bool IsReadOnly
  {
    get { return false; }
  }

  public override Type PropertyType
  {
    get { return typeof(string); }
  }

  public override void ResetValue(object component)
  {
    throw new NotImplementedException();
  }

  public override void SetValue(object component, object value)
  {
    _property.SetValue(component, value, _index);
  }

  public override bool ShouldSerializeValue(object component)
  {
    return false;
  }
}

(I know this looks bloaty but most of it is abstract class implementation boilerplate.)

A couple of caveats on this:

* It is not currently responsive to changes made to the collection through code.  That is, it will not raise PropertyChanged events for the synthesised ItemX properties.  (And the property grid isn't smart enough to marry up the CollectionChanged events to the synthesised properties.)  Similarly, if things get added to or removed from the collection, that won't cause the type descriptor to update.

* As previously mentioned, the grid will no longer see this as a collection (because the custom type descriptor takes priority), and therefore won't offer add/remove UI.

* As indicated in the comments, I have skipped propagating attributes from the real properties to the PropertyDescriptors.  In a real implementation you would probably want to address this.

So this may not be suitable for your requirements, but it should provide a basis for evaluating the approach.  If the approach isn't suitable, let us know if not and we will see what we can do. 

Previously I used
     myPropertyGrid.SelectedObject = _myClass;
to show my class.

Now I tried
     myPropertyGrid.SelectedObjects = new object[]{ _myClass };
and it's working well