LineSeries charts no longer work when XBinding and YBinding use property descriptors

I have been using property descriptors in my YBindings (and sometimes XBindings), which worked fine prior to version 6 (after you resolved a couple of issues long ago). However, coming back to the charting with version 6 I find this no longer works. Below is a demo. I am creating a property descriptor that encapsulated a function (square). When I use this inside a conventional property with Items for the ItemsSource it works fine (click the first button). When I use the same property descriptor directly in the YBinding it doesn't work (restart and click the second button). However, I can use the same binding for the int boxes, which get the correct values, which shows there is nothing wrong with the binding. This definitely used to work for LineSeries as well. It appears to me that DataSeries.UpdatePropertyInfo is coded to assume a string path, which is not the case when a PropertyDescriptor or DependencyProperty (rather than the wrapper) is used.

Here is the XAML

<Window x:Class="ChartPdProblem.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:ms="http://namespaces.mindscape.co.nz/wpf"        
    Title="MainWindow" Height="350" Width="525" >
<Grid>
    <Grid.RowDefinitions>
        <RowDefinition/>
        <RowDefinition Height="Auto"/>
    </Grid.RowDefinitions>
    <ms:Chart Grid.Row="0"  Name="chart1"/>
    <StackPanel Grid.Row="1" Orientation="Horizontal">
        <Button Content="Regular Property" Click="btnRegularProperty_Click" Margin="1"/>
        <Button Content="Property Descriptor" Click="btnPropertyDescriptor_Click" Margin="1"/>
        <ms:IntegerTextBox x:Name="text0" Margin="3"/>
        <ms:IntegerTextBox x:Name="text1" Margin="3"/>
        <ms:IntegerTextBox x:Name="text2" Margin="3"/>
        <ms:IntegerTextBox x:Name="text3" Margin="3"/>
        <ms:IntegerTextBox x:Name="text4" Margin="3"/>
        <ms:IntegerTextBox x:Name="text5" Margin="3"/>
    </StackPanel>
</Grid>

Code Behind (leaving out the usings, which cause problems in the rendering)

namespace ChartPdProblem { ///

/// Interaction logic for MainWindow.xaml ///

public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); }

    public class Item
    {
        public int X { get; private set; }
        public int Y { get { return (int)m_PD.GetValue(X); } }

        private PropertyDescriptor m_PD;

        public Item(int x, PropertyDescriptor pd)
        {
            X = x;
            m_PD = pd;
        }
    }

    public abstract class PdBase : PropertyDescriptor
    {
        public PdBase(string funcName)
            : base(funcName, null)
        {
        }

        public override bool IsReadOnly { get { return true; } }
        public override bool CanResetValue(object component) { return false; }
        public override void ResetValue(object component) { throw new NotImplementedException(); }
        public override void SetValue(object component, object value) { throw new NotImplementedException(); }
        public override bool ShouldSerializeValue(object component) { return false; }
    }

    public class PD<C, P> : PdBase
    {
        public PD(string funcName, Func<C, P> func)
            : base(funcName)
        {
            m_Func = func;
        }

        Func<C, P> m_Func;

        public override object GetValue(object component)
        {
            return m_Func((C)component);
        }

        public override Type ComponentType { get { return typeof(C); } }
        public override Type PropertyType { get { return typeof(P); } }
    }

    private void btnRegularProperty_Click(object sender, RoutedEventArgs e)
    {
        chart1.Series.Clear();
        LineSeries ls = new LineSeries();
        ls.XBinding = new Binding("X");
        ls.YBinding = new Binding("Y");
        PropertyDescriptor pd = new PD<int, int>("Square", x => x * x);

        ls.ItemsSource = new Item[] { new Item(0, pd), new Item(1, pd), new Item(2, pd), new Item(3, pd), new Item(4, pd), new Item(5, pd) };
        chart1.Series.Add(ls);
    }

    private void btnPropertyDescriptor_Click(object sender, RoutedEventArgs e)
    {
        chart1.Series.Clear();
        LineSeries ls = new LineSeries();

        ls.XBinding = new Binding();    // bind directly to component (int)

        PropertyDescriptor ypd = new PD<int, int>("Square", x => x * x);
        Binding yb = new Binding();
        yb.Path = new PropertyPath(ypd);
        yb.Mode = BindingMode.OneWay;
        ls.YBinding = yb;

        ls.ItemsSource = new int[] { 0, 1, 2, 3, 4, 5 };
        chart1.Series.Add(ls);

        // test same binding with int boxes
        text0.DataContext = 0;
        text1.DataContext = 1;
        text2.DataContext = 2;
        text3.DataContext = 3;
        text4.DataContext = 4;
        text5.DataContext = 5;

        text0.SetBinding(IntegerTextBox.ValueProperty, yb);
        text1.SetBinding(IntegerTextBox.ValueProperty, yb);
        text2.SetBinding(IntegerTextBox.ValueProperty, yb);
        text3.SetBinding(IntegerTextBox.ValueProperty, yb);
        text4.SetBinding(IntegerTextBox.ValueProperty, yb);
        text5.SetBinding(IntegerTextBox.ValueProperty, yb);
    }
}

}

Hello Peter

Apologies for this breaking change. What you have seen in the source code resulted in a phenomenal performance improvement. I had forgotten about the case of using a property descriptor. I'll be investigating ways to detect these scenarios tomorrow and will have it fixed for you within 2 days.

Jason Fauchelle

Hi Jason,

Thanks for looking into this. I am all for performance improvements, though performance wasn't bad to begin with! I certainly hope that handling property descriptors would not hurt performance much. I also confirmed that it currently doesn't work for dependency properties (as opposed to the CLR wrappers), and presumably it will not work for attached properties either. I also confirmed that it doesn't work for binding paths that refer to sub-properties (e.g., "Property.SubProperty"). In general I would hope that it can work for any valid binding.

Peter

Hi Jason,

After thinking about this some more I couldn't resist trying my hand at a fix, which is a replacement for DataSeries.UpdatePropertyInfo (see below). It handles all the cases I can think of, including when the binding uses a value converter, which seems to have be ignored in the current code. I think it is quite efficient for the case of property descriptors, dependency properties, and binding directly to the source object, and I would think is okay for other cases.

Peter

Here's the code:

    private void UpdatePropertyInfo(object o)
{
  _xPropertyInfo = null;
  _yPropertyInfo = null;
  if (o != null)
  {
    if (XBinding != null)
    {
        _xPropertyInfo = GetProperty(o, XBinding);
    }
    if (YBinding != null)
    {
        _yPropertyInfo = GetProperty(o, YBinding);
    }
  }
}

private PropertyInfo GetProperty(object o, Binding binding)
{
    string path = binding.Path.Path;
    if (string.IsNullOrEmpty(binding.Path.Path) || path == "(0)")
    {
        if (binding.Path.PathParameters.Count == 0)
        {   // binds to source object
            return new SelfPropertyInfo(binding);
        }
        if (binding.Path.PathParameters.Count == 1)
        {
            object parameter = binding.Path.PathParameters[0];
            if (parameter is PropertyDescriptor)
            {
                return new PropertyDescriptorInfo((PropertyDescriptor)parameter, binding);
            }
            if (parameter is DependencyProperty)
            {
                return new DependencyPropertyInfo((DependencyProperty)parameter, binding);
            }
        }
        // any other cases?
        return new BindingPropertyInfo(binding);
    }
    else if (path.Contains(".") || path.Contains("(") || path.Contains("["))
    {   // a complex path
        return new BindingPropertyInfo(binding);
    }
    else if (binding.Converter != null)
    {
        return new PropertyInfoWithConverter(o.GetType().GetProperty(path), binding);
    }
    else
    {   // just the name of a property, without converter
        return o.GetType().GetProperty(path);
    }
}

private abstract class PropertyInfoWrapper : PropertyInfo
{
    public PropertyInfoWrapper(Binding binding)
    {
        m_Binding = binding;
    }

    public Binding m_Binding;

    public abstract object GetValue(object component);

    public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
    {
        object value = GetValue(obj);
        if (m_Binding.Converter != null)
        {
            value = m_Binding.Converter.Convert(value, typeof(object), m_Binding.ConverterParameter, m_Binding.ConverterCulture);
        }
        return value;
    }

    // none of these is ever called, so no need to implement.
    public override PropertyAttributes Attributes { get { throw new NotImplementedException(); } }
    public override bool CanRead { get { throw new NotImplementedException(); } }
    public override bool CanWrite { get { throw new NotImplementedException(); } }
    public override MethodInfo[] GetAccessors(bool nonPublic) { throw new NotImplementedException(); }
    public override MethodInfo GetGetMethod(bool nonPublic) { throw new NotImplementedException(); }
    public override ParameterInfo[] GetIndexParameters() { throw new NotImplementedException(); }
    public override MethodInfo GetSetMethod(bool nonPublic) { throw new NotImplementedException(); }
    public override Type PropertyType { get { throw new NotImplementedException(); } }
    public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture) { throw new NotImplementedException(); }
    public override Type DeclaringType { get { throw new NotImplementedException(); } }
    public override object[] GetCustomAttributes(Type attributeType, bool inherit) { throw new NotImplementedException(); }
    public override object[] GetCustomAttributes(bool inherit) { throw new NotImplementedException(); }
    public override bool IsDefined(Type attributeType, bool inherit) { throw new NotImplementedException(); }
    public override string Name { get { throw new NotImplementedException(); } }
    public override Type ReflectedType { get { throw new NotImplementedException(); } }
}

private class SelfPropertyInfo : PropertyInfoWrapper
{
    public SelfPropertyInfo(Binding binding)
        : base(binding)
    {
    }

    public override object GetValue(object obj)
    {
        return obj;
    }
}

private class PropertyInfoWithConverter : PropertyInfoWrapper
{
    public PropertyInfoWithConverter(PropertyInfo propertyInfo, Binding binding)
        : base(binding)
    {
        m_PropertyInfo = propertyInfo;
    }

    private PropertyInfo m_PropertyInfo;

    public override object GetValue(object obj)
    {
        return m_PropertyInfo.GetValue(obj, null);
    }
}

private class PropertyDescriptorInfo : PropertyInfoWrapper
{
    public PropertyDescriptorInfo(PropertyDescriptor propertyDescriptor, Binding binding)
        : base(binding)
    {
        m_PropertyDescriptor = propertyDescriptor;
    }

    private PropertyDescriptor m_PropertyDescriptor;

    public override object GetValue(object obj)
    {
        return m_PropertyDescriptor.GetValue(obj);
    }
}

private class DependencyPropertyInfo : PropertyInfoWrapper
{
    public DependencyPropertyInfo(DependencyProperty dp, Binding binding)
        : base(binding)
    {
        m_DP = dp;
    }

    private DependencyProperty m_DP;

    public override object GetValue(object obj)
    {
        return ((DependencyObject)obj).GetValue(m_DP);
    }
}

private class BindingPropertyInfo : PropertyInfoWrapper
{
    private class Dummy : FrameworkElement
    {
        public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(object), typeof(Dummy));
    }

    public BindingPropertyInfo(Binding binding)
        : base(binding)
    {
        m_Binding = binding;
        m_Dummy = new Dummy();
    }

    private Binding m_Binding;
    private Dummy m_Dummy;

    public override object GetValue(object obj)
    {
        m_Dummy.DataContext = obj;
        m_Dummy.SetBinding(Dummy.ValueProperty, m_Binding);
        return m_Dummy.GetValue(Dummy.ValueProperty);
    }
}

Hello Peter

This is a very nice piece of code, thanks for posting this! My original approach was just going to use an equivalent of your BindingPropertyInfo for ALL cases apart from the basic "name of property with no converter". However, all your property info variants provide a more efficient solution for cases that don't necessarily need to use the full binding, so I've included this in the charting product. I just made a couple of changes to BindingPropertyInfo that you may be interested in: You only need to SetBinding in the constructor, rather than every time in the GetValue method - this improves the performance. Also, it looks like your BindingPropertyInfo class could cause the converter to be applied twice - first by applying the binding to the Dummy, and then again in the PropertyInfoWrapper base class. To resolve this I simply override the main GetValue method in the BindingPropertyInfo.

This will be available in the next nightly build. Let us know if there are any cases that you need that seem to have been missed and I'll add it in. Looks like this already has full coverage though.

Jason Fauchelle

Hi Jason,

Glad the code I posted is of use! I did initially try the SetBinding in the constructor, but it seemed like it didn't work, though I didn't understand why. I'll try your update. I'm sure you are right about the converter being applied twice--oops.

Peter

Hi Jason,

I downloaded and tested the latest nightly build, and I find that in the case of a complex path (where it uses BindingPropertyInfo) it does not work. The other cases work fine. When I move the SetBinding call to the GetValue (after setting DataContext) then it works fine (I also made the base _binding field protected instead of private, so BindingPropertyInfo.GetValue could access it). I found it puzzling that it doesn't work to call SetBinding in the constructor, but guessed that when the DataContext is changed maybe the binding does not update immediately, but with some lower priority. To test this I moved the SetBinding back to the constructor and inserted a "wait" after setting the DataContext in GetValue as follows:

    public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
{
  _extractor.DataContext = obj;
  Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new System.Threading.ThreadStart(delegate { }));
  return _extractor.Value;
}

With this wait it does work fine. However, I am definitely not recommending this approach as a fix! Better to just move the SetBinding in the GetValue. Perhaps there is a better way to get the binding to update _extractor.Value immediately?

Peter

Thanks Peter

I clearly didn't try this out correctly. I had forgotten one thing - by setting the DataContext of the extractor to null before setting the binding in the constructor causes it to work perfectly fine from then onwards. It's unusual that this works, but it is a technique that I've used for a long time and I think it is suitable. This allows the binding to still be set in the constructor which helps the performance a lot.

This will be fixed in the next nightly build.

Jason Fauchelle

Hi Jason,

That seems weird, but I tried it out and it indeed works. Nice tip! I was googling this question earlier, and I read several questions that this would have been the best answer to.

Peter