如何转换绑定至非DependencyProperty属性的值？是否有更优方案？

在标记了x:Name="self"的自定义UserControl中，有以下简化XAML代码：

<Ellipse>
    <Ellipse.RenderTransform >
        <TranslateTransform X="{Binding ElementName=self, Path=PixelOffset}"/>
    </Ellipse.RenderTransform>
</Ellipse>

<controls:CallbackControl DataContext="{Binding Path=Value}" Callback="{Binding ElementName=self, Path=PixelOffsetCallback, Mode=OneTime}" />

核心痛点：TranslateTransform.X并非依赖属性，无法直接使用带参数的转换器或多绑定，但业务需要结合DataContext里的Value和控件实际宽度计算PixelOffset。

你已经实现了CallbackControl作为解决方案，相关代码如下：

现有实现方案 #

CallbackControl定义 #

public class CallbackControl : FrameworkElement
{
    public CallbackControl()
    {
        this.Visibility = Visibility.Collapsed;
        this.DataContextChanged += Callback_DataContextChanged;
    }

    private void Callback_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        Callback?.Invoke(this.DataContext);
    }

    public static readonly DependencyProperty CallbackProperty = DependencyProperty.Register(
        nameof(Callback), typeof(Action<object>), typeof(CallbackControl), new PropertyMetadata(default(Action<object>)));

    public Action<object> Callback
    {
        get { return (Action<object>)GetValue(CallbackProperty); }
        set { SetValue(CallbackProperty, value); }
    }
}

自定义UserControl逻辑 #

public MyUserControl() //构造函数
{
    PixelOffsetCallback = this.PixelOffsetCallbackImpl; //InitializeComponent前赋值

    InitializeComponent();

    this.SizeChanged += MyUserControl_SizeChanged;
    
    //其他代码
}

private void MyUserControl_SizeChanged(object sender, SizeChangedEventArgs e)
{
    PixelOffsetCallbackImpl(PropertyProvider?.Value);
}

private void PixelOffsetCallbackImpl(object value)
{
    PixelOffset = this.ActualWidth * (double) value; 
}

public Action<object> PixelOffsetCallback { get; }

private double _pixelOffset;
public double PixelOffset
{
    get => _pixelOffset;
    private set => SetField(ref _pixelOffset, value); //已实现INotifyPropertyChanged
}

更简便的替代实现方式 #

方案1：合并监听逻辑，去掉额外控件 #

直接在自定义UserControl中监听DataContext和SizeChanged事件，省去CallbackControl的定义，逻辑更集中：

public MyUserControl()
{
    InitializeComponent();
    //监听DataContext变化
    DataContextChanged += (s, e) => UpdatePixelOffset();
    //监听控件尺寸变化
    SizeChanged += (s, e) => UpdatePixelOffset();
}

private void UpdatePixelOffset()
{
    if (PropertyProvider?.Value is double value)
    {
        PixelOffset = ActualWidth * value;
    }
}

private double _pixelOffset;
public double PixelOffset
{
    get => _pixelOffset;
    private set => SetField(ref _pixelOffset, value); //INotifyPropertyChanged实现
}

方案2：用多绑定+转换器直接计算偏移 #

虽然TranslateTransform.X不是依赖属性，但可以给Ellipse的RenderTransform绑定一个作为依赖属性的TranslateTransform实例，再通过多绑定给这个实例的X赋值：

1. 在自定义UserControl中添加依赖属性：

public static readonly DependencyProperty OffsetTransformProperty =
    DependencyProperty.Register(nameof(OffsetTransform), typeof(TranslateTransform), typeof(MyUserControl), new PropertyMetadata(new TranslateTransform()));

public TranslateTransform OffsetTransform
{
    get => (TranslateTransform)GetValue(OffsetTransformProperty);
    set => SetValue(OffsetTransformProperty, value);
}

2. 实现多值转换器：

public class OffsetConverter : IMultiValueConverter
{
    public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
    {
        if (values.Length != 2 || !(values[0] is double width) || !(values[1] is double value))
            return 0.0;
            
        return width * value;
    }

    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

3. XAML中配置绑定：

<UserControl.Resources>
    <local:OffsetConverter x:Key="OffsetConverter" />
</UserControl.Resources>

<Ellipse RenderTransform="{Binding ElementName=self, Path=OffsetTransform}" />

4. 在后台代码中设置多绑定：

public MyUserControl()
{
    InitializeComponent();
    //给OffsetTransform.X设置多绑定
    var multiBinding = new MultiBinding { Converter = new OffsetConverter() };
    multiBinding.Bindings.Add(new Binding { ElementName = "self", Path = new PropertyPath("ActualWidth") });
    multiBinding.Bindings.Add(new Binding { Path = new PropertyPath("Value") });
    BindingOperations.SetBinding(OffsetTransform, TranslateTransform.XProperty, multiBinding);
}

方案3：用行为（Behavior）复用逻辑 #

如果需要在多个控件中复用该偏移计算逻辑，可以借助WPF行为组件：

1. 引用Microsoft.Xaml.Behaviors.Wpf NuGet包
2. 定义行为类：

public class UpdateOffsetBehavior : Behavior<MyUserControl>
{
    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.DataContextChanged += OnContextChanged;
        AssociatedObject.SizeChanged += OnSizeChanged;
    }

    protected override void OnDetaching()
    {
        AssociatedObject.DataContextChanged -= OnContextChanged;
        AssociatedObject.SizeChanged -= OnSizeChanged;
        base.OnDetaching();
    }

    private void OnContextChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        UpdateOffset();
    }

    private void OnSizeChanged(object sender, SizeChangedEventArgs e)
    {
        UpdateOffset();
    }

    private void UpdateOffset()
    {
        if (AssociatedObject.PropertyProvider?.Value is double value)
        {
            AssociatedObject.PixelOffset = AssociatedObject.ActualWidth * value;
        }
    }
}

3. 在XAML中添加行为：

<i:Interaction.Behaviors>
    <local:UpdateOffsetBehavior />
</i:Interaction.Behaviors>

内容的提问来源于stack exchange，提问作者mike