Custom WPF PropertyGrid Editor Ignores custom range validation error message

Hi Alexander,

This actually helped me get it working. Specifically the solution provided Here: (Q557363).

My real project does not allow me to implement an extra view model layer in between and therefor it's not a viable option for my use case. The normal RangeAttribute is obviously also not usable, as it does not allow me to provide the unit conversion in the error message. I could have chosen to implement this directly in the CustomErrorTooltipConverter (see code below) as well, but I like the flexibility of configuring my validation annotations with this specifically targeted and well defined attribute that uses its own default ErrorMessage format.

For other wanderers that have similar requirements I'll try to briefly explain how it all ties together:

MainWindow:

MainWindow.xaml defines the PropertyGridControl and references the SharedResource that defines the custom editor templates used.

The backend code binds the PropertyGridControl to our Entity. It also sets up the custom editor for the Height property as well.

XAML
<Window
    x:Class="WpfApplication1.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:dxprg="http://schemas.devexpress.com/winfx/2008/xaml/propertygrid"
    Title="MainWindow"
    Width="525"
    Height="350">

    <Window.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="SharedResources.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Window.Resources>

    <Grid>

        <dxprg:PropertyGridControl
            Name="Pg"
            AllowCommitOnValidationAttributeError="True"
            ShowCategories="Hidden"
            ShowEditorButtons="True"
            ShowMenuButtonInRows="False"
            ShowProperties="All"
            ShowToolPanel="False"
            UseCollectionEditor="True" />
    </Grid>
</Window>

C#
using DevExpress.Mvvm.DataAnnotations;
using WpfApplication1.Units;

namespace WpfApplication1;

public partial class MainWindow
{

    public MainWindow()
    {
        InitializeComponent();

        MetadataLocator.Default = MetadataLocator
            .Create()
            .AddMetadata<EntityMetadata>();

        Pg.SelectedObject = new Entity();
    }

    public class EntityMetadata
    {
        public static void BuildMetadata(MetadataBuilder<Entity> builder)
        {
            builder
                .Property(e => e.Height)
                .PropertyGridEditor("UnitsAwareInputEditor")
                ;
        }
    }

    public static string UnitsFormatString => UnitSystemProvider.FromDiContainer == UnitSystem.Imperial
        ? $"##0.### {UnitSets.Length.ImperialAbbreviation}"
        : $"##0.# {UnitSets.Length.MetricAbbreviation}";
}

Entity.cs:

This is the entity model we are binding the Property Grid to

Code
using System.Diagnostics;
using WpfApplication1.Attributes;

namespace WpfApplication1;

public class Entity
{
    private double _height;
    private double _width;

    [UnitRange(400, 800)] // this uses the default error message
    public double Width
    {
        get => _width;
        set
        {
            _width = value;
            Debug.WriteLine($"Width value stored as {_width}");
        }
    }

    [UnitRange(100, 400, ErrorMessage = "'{0}' should be between {1} and {2}{3}")] // this uses a custom error message
    public double Height
    {
        get => _height;
        set
        {
            _height = value;
            Debug.WriteLine($"Height value stored as {_height}");
        }
    }
}

UnitRangeAttribute.cs

This is the custom range attribute we can use to do our customized validation

Code
using System;
using System.ComponentModel.DataAnnotations;
using WpfApplication1.Units;

namespace WpfApplication1.Attributes;

[AttributeUsage(AttributeTargets.Property)]
public class UnitRangeAttribute : ValidationAttribute
{
    private readonly UnitSystem _unitSystem = UnitSystemProvider.FromDiContainer;
    private readonly double _minimum;
    private readonly double _maximum;

    public UnitRangeAttribute(double minimum, double maximum)
    {
        _minimum = minimum;
        _maximum = maximum;

        ErrorMessage = $"Value for {{0}} is not in the expected range {Minimum}{Abbrev} - {Maximum}{Abbrev}";
    }

    public double Minimum => UnitSets.Length.FromMetric(_minimum, _unitSystem);
    public double Maximum => UnitSets.Length.FromMetric(_maximum, _unitSystem);
    public string Abbrev => UnitSets.Length.GetAbbreviation(_unitSystem);

    public override bool IsValid(object value)
    {
        if (value is not double doubleValue)
            throw new ArgumentException("Value must be a double");

        double enteredValue = UnitSets.Length.FromMetric(doubleValue, _unitSystem);

        return enteredValue >= Minimum && enteredValue <= Maximum;
    }

    public override string FormatErrorMessage(string name)
    {
        return string.Format(ErrorMessageString, name, Minimum, Maximum, Abbrev);
    }
}

SharedResource.xaml:

This file contains the templates for the custom control. It makes heavy use of converters to get the required custom behavior. They depend on the UnitRangeAttribute to provide the correct value representations.

XAML
<ResourceDictionary
    x:Class="WpfApplication1.SharedResources"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:converters="clr-namespace:WpfApplication1.Converters"
    xmlns:dxe="http://schemas.devexpress.com/winfx/2008/xaml/editors"
    xmlns:dxprg="http://schemas.devexpress.com/winfx/2008/xaml/propertygrid"
    xmlns:local="clr-namespace:WpfApplication1">

    <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary>
            <DataTemplate x:Key="CustomErrorTooltipTemplate">
                <TextBlock Text="{Binding Converter={converters:CustomErrorTooltipConverter}, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=dxe:SpinEdit}}" />
            </DataTemplate>

            <DataTemplate x:Key="UnitsAwareInputEditorTemplate">
                <dxe:SpinEdit
                    HorizontalAlignment="Stretch"
                    HorizontalContentAlignment="Left"
                    EditValue="{Binding Value, Converter={converters:LengthUnitConverter}}"
                    ErrorToolTipContentTemplate="{DynamicResource CustomErrorTooltipTemplate}"
                    Mask="{Binding UnitsFormatString, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type local:MainWindow}}}"
                    MaskType="Numeric"
                    MaskUseAsDisplayFormat="True"
                    MaxValue="{Binding Converter={converters:RangeAttributeConverter}, ConverterParameter=Max}"
                    MinValue="{Binding Converter={converters:RangeAttributeConverter}, ConverterParameter=Min}"
                    ShowBorder="False" />
            </DataTemplate>

            <DataTemplate x:Key="UnitsAwareInputEditor">
                <dxprg:PropertyDefinition
                    CellTemplate="{DynamicResource UnitsAwareInputEditorTemplate}"
                    ExpandButtonVisibility="Visible"
                    IsReadOnly="False"
                    PostOnEditValueChanged="False" />
            </DataTemplate>

        </ResourceDictionary>
    </ResourceDictionary.MergedDictionaries>
</ResourceDictionary>

Converters

Last but not least, the converters that tie the whole thing together.

LengthUnitConverter:

Converts the input value to the required UnitSystem. The actual conversion is done in a dedicated UnitSet class that you'll find in the attached download.

C#
using System;
using System.Globalization;
using System.Windows.Data;
using System.Windows.Markup;
using WpfApplication1.Units;

namespace WpfApplication1.Converters;

/// <summary>
///     Converter to convert double values to and from values, stored in mm to 
///     specified unit system (metric or imperial)
/// </summary>
[ValueConversion(typeof(double), typeof(double), ParameterType = typeof(UnitSystem))]
public class LengthUnitConverter : MarkupExtension, IValueConverter
{
    /// <summary>
    ///     Convert value a double value in in the the specified or current application unitsystem
    /// </summary>
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (TryConvertToDouble(value, out double dblValue, culture) == false)
            throw new ArgumentException("Value must be a double or convertible to a double");

        // if a valid unit system is not provided, we'll resolve it from our DI container
        if (parameter is not UnitSystem unitSystem)
            unitSystem = UnitSystemProvider.FromDiContainer;

        return UnitSets.Length.FromMetric(dblValue, unitSystem);
    }

    /// <summary>
    ///     Convert input back to double value in metric units
    /// </summary>
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (TryConvertToDouble(value, out double dblValue, culture) == false)
            throw new ArgumentException("Value must be a double or convertible to a double");

        if (parameter is not UnitSystem unitSystem)
            // a valid unit system is not provided, we'll assume metric
            unitSystem = UnitSystemProvider.FromDiContainer;

        return UnitSets.Length.AsMetric(dblValue, unitSystem);
    }

    private static bool TryConvertToDouble(object value, out double dblValue, CultureInfo culture)
    {
        try
        {
            dblValue = System.Convert.ToDouble(value, culture);
            return true;
        }
        catch
        {
            dblValue = double.NaN;
            return false;
        }
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return this;
    }
}

RangeAttributeConverter:

This converter is used to provide the unit system specific MinValue and MaxValue values for the SpinEdit control,

C#
using DevExpress.Xpf.PropertyGrid;
using System;
using System.Globalization;
using System.Reflection;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;
using WpfApplication1.Attributes;

namespace WpfApplication1.Converters;

/// <summary>
///     This converter makes sure that validation happens in the correct units system
/// </summary>
public class RangeAttributeConverter : MarkupExtension, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is not RowData row) return DependencyProperty.UnsetValue;
        object entity = row.Parent.Value;

        var rangeAttr = entity?.GetType()
            .GetProperty(row.FullPath)?
            .GetCustomAttribute<UnitRangeAttribute>();

        if (rangeAttr != null)
        {
            return parameter?.ToString() == "Min" ? rangeAttr.Minimum : rangeAttr.Maximum;
        }

        return DependencyProperty.UnsetValue;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        => throw new NotSupportedException();

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return this;
    }
}

CustomErrorTooltipConverter:

Provides the formatted error message ToolTip, taken from the UnitRangeAttribute

C#
using DevExpress.Xpf.Editors;
using DevExpress.Xpf.PropertyGrid;
using System;
using System.Reflection;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;
using WpfApplication1.Attributes;

namespace WpfApplication1.Converters;

[ValueConversion(typeof(SpinEdit), typeof(string))]
public class CustomErrorTooltipConverter : MarkupExtension, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        if (value is not SpinEdit se || se.DataContext is not RowData row)
            return DependencyProperty.UnsetValue;

        object entity = row.Parent.Value;

        UnitRangeAttribute rangeAttr = entity?.GetType()
            .GetProperty(row.FullPath)?
            .GetCustomAttribute<UnitRangeAttribute>();

        return rangeAttr != null
            ? rangeAttr.FormatErrorMessage(row.Header)
            : DependencyProperty.UnsetValue;
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return value;
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return this;
    }
}

Hope anyone finds this useful. Please find the attached solution with the complete example attached.

I am happy to hear that you found a solution. Thank you for sharing it.
Alexander