Dynamic Properties Redux

I see you've recently dealt with the issue of dynamic properties in thread http://www.mindscape.co.nz/forums/Thread.aspx?ThreadID=2786 and a year ago in thread http://www.mindscape.co.nz/forums/Thread.aspx?ThreadID=1596.  In these two other threads you enumerated three general approaches to the problem:  1) ICustomTypeDescriptor, 2) ObservableDictionary<T> of properties, and 3) Directly adding nodes.  I think the two threads thoroughly covered approaches 2 and 3, but I'm working more on approach 1.

My situation is that I've got SelectedObject set to an object of type Element that has a property DataSource of type MyNamespace.DataSource.  MyNamespace.DataSource has several derived classes, any of which may be assigned to Element.DataSource.  I want the grid user to be able to choose the type so I've added a property to Element of type DataSourceType.  When the grid user selects a value for DataSourceType, I instantiate an object of that type and assign it to Element.DataSource.  That's the glossy overview.  The simple implementation would look something like this:

namespace MyNamespace {
   public enum DataSourceType { DataSource1, DataSource2 }

   public class Element : Observable {
      public DataSource DataSource { get; set; }
      public DataSourceType DataSourceType {
         get { return (DataSourceType)Enum.Parse(  typeof(DataSourceType),
                                                   DataSource.GetType().Name); }
         set {
            string typeName="MyNamespace."+value.ToString();
            Type t=Assembly.GetAssembly(typeof(DataSource)).GetType(typeName);
            DataSource d=Activator.CreateInstance(t) as DataSource;
            DataSource=d;
            OnPropertyChanged("DataSourceType");
            OnPropertyChanged("DataSource");
         }
      }
   }

   public class DataSource : Observable {
   }

   public class DataSource1 : DataSource {
      public string Property1 { get; set; }
   }

   public class DataSource2: DataSource {
      public string Property2 { get; set; }
   }
}

When I point the PropertyGrid at an Element and change DataSourceType from DataSource1 to DataSource2, the grid immediately shows a new type string to the right of DataSourceType, but it does not immediately show Property2 instead of Property1.  I have to reassign SelectedObject to make it show Property2.

In the messy details of my real situation, I'm using the MvvmFoundation so there are VM wrappers for DataSource and Element that both implement ICustomTypeDescriptor and expose the properties of the wrapped model.  I don't think that's causing my problem because the example above exhibits the same behavior.  So what's the right way to do this?

Kevin Donn

Hmm, this is a rather nasty one.  We don't automatically reload the set of properties after a property changes, because this is likely to mess up things like focus and selection; and there's no standard way for an object to tell us that one of its properties has changed type rather than just value.  So at the moment you do need to explicitly force the grid to re-read the subproperties: we don't do it automatically.

Worse still, there isn't any particularly elegant way to invoke this re-read.  The refresh functions are currently internal, and the only way to force a refresh is to reassign SelectedObject or to collapse and re-expand the tree item corresponding to the property that has changed type (which at least avoids a complete reset of the UI).  We could expose the refresh functions more directly, but it's still not very MVVM-esque.

So I'm open to suggestions on how we could handle this.  One possibility is to allow a declaration on the grid that a particular property needs to have its children refreshed whenever it changes, e.g.

<!-- hypothetical -->
<ms:PropertyGrid>
  <ms:PropertyGrid.DynamicProperties>
    <ms:DynamicProperty Name="DataSource" />

Another is to define an event similar to PropertyChanged that objects would raise to tell us to refresh -- that would enable us to avoid a reload if you changed between two instances of DataSource1 rather than between a DataSource1 and a DataSource2, but has the downside of coupling your data object/view model to our property grid, which again is not very MVVM.

I'd welcome feedback on these options or any other suggestions you have -- obviously I know you'd like it to just happen, but that's probably not practical given that most types and properties are not dynamic and we don't want to compromise the common case in favour of the dynamic case.

Offhand, I'm pretty comfortable with the event model you described, something like TypeChanged or SchemaChanged that I can send out whenever DataSource not only changes but changes type, which would cause you to refresh the children (I hope you'd be able to leave the subtree expanded).  I'm new to MVVM but it doesn't seem to violate the spirit too badly.  Only the VM (not the model) would need to implement this behavior and the whole point of the VM is to support the view, right?

kd

Hmm, looks like I spoke too soon.  It appears that we do already support this scenario after all, without any need for an extra interface or event.  Sorry for the confusion!

If you're using a current nightly build (or anything later than build 12460, released in November 2009), then this should Just Work (TM).  So if you're on RTM, please upgrade to the latest nightly build and see if that fixes things for you.

If you're already on a recent nightly build, and it's still not working for you, let us know and we'll see if we can figure out what's going on.