Winui 3中的样式二传手绑定

Question

winui 3是否支持样式设置器中的绑定？我为导航视图定义了一种样式，第三行是：这是：

<Setter Property="CompactPaneLength" Value="{Binding CurrentCompactPaneLength}" />

这会产生指定的铸件无效。在运行时例外。包含NavigationView的页面的DataContext是页面的ViewModel。 navigationview.compactpanelength和currentCompactpaneLength是双重和公共和CurrentCompactpaneLength是一个可观察的Obibject（来自communityToolkit.mvvm.componentmodel）。

WINUI 3（SDK 1.1.2）的源代码包括各种设置器，例如

<Setter Target="PaneContentGrid.Width" Value="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=CompactPaneLength}" />

在代码工作中进行绑定，如果是必要的，则进行了绑定。但是XAML也不工作吗？

Answer 1

显然，在Winui 3中尚不支持二传手中的一般绑定，尽管这是一个备受要求的功能。解决方法是创建一个带有依赖关系的助手类，每当属性被更改/设置时，它都会调用变更处理程序。然后，更改处理程序可以在代码中创建所需的绑定。对 clemens 建议UWP以前的建议。这是一个示例助手类：

internal class BindingHelper
{
    #region CompactPaneLengthBindingPath
    public static readonly DependencyProperty CompactPaneLengthBindingPathProperty = DependencyProperty.RegisterAttached(
            "CompactPaneLengthBindingPath", typeof(string), typeof(BindingHelper), new PropertyMetadata(null, BindingPathChanged));
            
    public static string GetCompactPaneLengthBindingPath(DependencyObject obj)
    {
        return (string)obj.GetValue(CompactPaneLengthBindingPathProperty);
    }
    
    public static void SetCompactPaneLengthBindingPath(DependencyObject obj, string value)
    {
        obj.SetValue(CompactPaneLengthBindingPathProperty, value);
    }
    #endregion
        
    #region HeightBindingPath
    // another DP is defined here (all of them are strings)
        
    #region ForegroundBindingPath
    // and a third one, etc.
        

    // ===================== Change Handler: Creates the actual binding

    private static void BindingPathChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
    {
        if (e.NewValue is string source)                                                                // source property (could add DataContext by setting Value="source@datacontext" for example)
        {
            DependencyProperty target;                                                                  // which property is the target of the binding?
            if (e.Property == CompactPaneLengthBindingPathProperty) target = NavigationView.CompactPaneLengthProperty;
            else if (e.Property == HeightBindingPathProperty) target = FrameworkElement.HeightProperty;
            else if (e.Property == ForegroundBindingPathProperty) target = Control.ForegroundProperty;
            else throw new System.Exception($"BindingHelper: Unknown target ({nameof(e.Property)}");    // don't know this property
        
            obj.ClearValue(target);                                                                     // clear previous bindings (and value)
            BindingOperations.SetBinding(obj, target,                                                   // set new binding (and value)
               new Binding { Path = new PropertyPath(source), Mode = BindingMode.OneWay });
        }
    }

请注意，所有依赖关系均为字符串类型，目标类型可以是您正在使用的控件的任何祖先类型。例如，heightbindingpathproperty可以与任何Frameworkelement一起使用。

像这样的二阶，使用样式的助手，这样：

<Style x:Key="MyNavigationView" TargetType="controls:NavigationView" >
    <Setter Property="local:BindingHelper.CompactPaneLengthBindingPath" Value="CurrentCompactPaneLength" />
</Style>

我希望这会有所帮助。

Answer 2

今天早上，我对Winui的无意义限制将无尽的挫败感重定向到动机能量中，以制定通用解决方案。其他答案很棒，但这更可扩展：

public class SmartSetter
{
    /// <summary>
    /// The target <see cref="DependencyProperty"/> name, e.g.,
    /// <c>Background</c>. For an attached property, ensure the 
    /// <see cref="PropertyOwner"/> property is set, since this
    /// class doesn't have access to XAML namespaces. I would've
    /// loved to subclass Setter, but, sealed. Who'd have guessed.
    /// </summary>
    public string Property
    {
        get;
        set;
    }

    /// <summary>
    /// References the DependencyProperty owner when attached
    /// properties are targeted. Otherwise the owner is assumed
    /// to be the type of the FrameworkElement being styled.
    /// </summary>
    public Type PropertyOwner
    {
        get;
        set;
    }

    /// <summary>
    /// A BindingBase. In XAML, use normal binding notation, e.g.,
    /// <c>"{Binding RelativeSource={RelativeSource Mode=Self}, Path=SomeOtherProperty}"</c>
    /// </summary>
    public BindingBase Binding
    {
        get;
        set;
    }

    internal DependencyProperty ResolveProperty(Type ownerType)
    {
        if (_resolvedProperty != null)
            return _resolvedProperty;

        // The DP for WinUI types is exposed in reflection as a property, but for custom types it's a field. 

        var dpProp = type.GetProperty(
            $"{propertyName}Property", 
            BindingFlags.Static
                | BindingFlags.FlattenHierarchy
                | BindingFlags.Public);
        if (dpProp != null)
            return _resolvedProperty = dpProp.GetValue(null) as DependencyProperty;

        var dpField = type.GetField(
            $"{propertyName}Property",
            BindingFlags.Static
                | BindingFlags.FlattenHierarchy
                | BindingFlags.Public);
        if (dpField != null)
            return _resolvedProperty  = dpField.GetValue(null) as DependencyProperty;

        return null;
    }

    DependencyProperty _resolvedProperty;
}

/// <summary>
/// Provides a workaround for WinUI 3's omission of a means to
/// set bindings in Style Setters. In the main Style, assign an instance of 
/// <see cref="SmartStyle"/>, which includes a collection of <see cref="SmartSetter"/>s.
/// to the <see cref="SmartStyle.StyleProperty"/> attached property. 
/// </summary>
[ContentProperty(Name = nameof(Setters))]
public class SmartStyle
{
    Collection<SmartSetter> _setters;

    public Collection<SmartSetter> Setters => _setters ?? (_setters = new Collection<SmartSetter>());

    #region SmartStyle Style attached property
    public static readonly DependencyProperty StyleProperty = DependencyProperty.RegisterAttached(
        "Style",
        typeof(SmartStyle),
        typeof(SmartStyle),
        new PropertyMetadata(
            (SmartStyle)null,
            (obj, args) =>
            {
                if (!(obj is FrameworkElement fe) || !(args.NewValue is SmartStyle style))
                    return;
                foreach (var s in style.Setters)
                {
                    if (string.IsNullOrEmpty(s.Property) || s.Binding == null)
                        continue;
                    var dp = s.ResolveProperty(fe.GetType());
                    if (dp == null)
                        continue;
                    BindingOperations.SetBinding(obj, dp, s.Binding);
                }
            }));
    public static SmartStyle GetStyle(DependencyObject obj)
    {
        return (SmartStyle)obj.GetValue(StyleProperty);
    }
    public static void SetStyle(DependencyObject obj, SmartStyle style)
    {
        obj.SetValue(StyleProperty, style);
    }
    #endregion
}

用法：

<Style TargetType="Button"
       x:Key="SolidBackgroundButtonStyle">
    <Setter Property="local:SmartStyle.Style">
        <Setter.Value>
            <local:SmartStyle>
                <local:SmartSetter Property="BorderBrush"
                                   Binding="{Binding 
                                      RelativeSource={RelativeSource Mode=Self}, 
                                      Path=Background}" />
            </local:SmartStyle>
        </Setter.Value>
    </Setter>
</Style>

顺便说一句，它起作用的事实 - smartsetter.binding给出了bindingbase实例> bindingbase 实例，并且未实际评估绑定。在应用样式之前 - 告诉您Microsoft竭尽全力为setter做相反的事情，从而导致了这个问题，原因是我无法开始理解。

更新 - 我决定将此和另一个解决方法变成一个小项目。参见 https://github.com/peter0302/winui.redemption/empertion/