Question

我在尝试在代码中设置短时间的绑定时注意到了这一点。事实上，我只想通过绑定获得价值。所以我设置绑定，获取目标属性的值并立即清除绑定。一切都很好，直到为绑定设置具有模式FindAncestor的RelativeSource。在这种情况下，target属性返回其默认值。

经过一些调试后，我发现FindAncestor绑定的BindingExpression的属性Status设置为Unattached。对于其他类型的绑定，BindingExpression.Status设置为Active。

我写了一些代码来说明这一点。

Window1.xaml

<Window x:Class="Wpf_SetBindingInCode.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        x:Name="Window"
        Title="Window1"
        Height="300" Width="300"
        DataContext="DataContext content">
    <StackPanel>
        <Button Content="Set binding" Click="SetBindingButtonClick"/>
        <TextBlock x:Name="TextBlock1"/>
        <TextBlock x:Name="TextBlock2"/>
        <TextBlock x:Name="TextBlock3"/>
    </StackPanel>
</Window>

Window1.xaml.cs

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

    private void SetBindingButtonClick(object sender, RoutedEventArgs e)
    {
        Binding bindingToRelativeSource = new Binding("DataContext")
        {
            RelativeSource = new RelativeSource { Mode = RelativeSourceMode.FindAncestor, AncestorType = typeof(Window1) },
        };
        Binding bindingToElement = new Binding("DataContext")
        {
            ElementName = "Window"
        };
        Binding bindingToDataContext = new Binding();

        BindingOperations.SetBinding(TextBlock1, TextBlock.TextProperty, bindingToRelativeSource);
        BindingOperations.SetBinding(TextBlock2, TextBlock.TextProperty, bindingToElement);
        BindingOperations.SetBinding(TextBlock3, TextBlock.TextProperty, bindingToDataContext);

        Trace.WriteLine("TextBlock1.Text = \"" + TextBlock1.Text + "\"");
        Trace.WriteLine("TextBlock2.Text = \"" + TextBlock2.Text + "\"");
        Trace.WriteLine("TextBlock3.Text = \"" + TextBlock3.Text + "\"");

        var bindingExpressionBase1 = BindingOperations.GetBindingExpressionBase(TextBlock1, TextBlock.TextProperty);
        var bindingExpressionBase2 = BindingOperations.GetBindingExpressionBase(TextBlock2, TextBlock.TextProperty);
        var bindingExpressionBase3 = BindingOperations.GetBindingExpressionBase(TextBlock3, TextBlock.TextProperty);

        Trace.WriteLine("bindingExpressionBase1.Status = " + bindingExpressionBase1.Status);
        Trace.WriteLine("bindingExpressionBase2.Status = " + bindingExpressionBase2.Status);
        Trace.WriteLine("bindingExpressionBase3.Status = " + bindingExpressionBase3.Status);
    }
}

上面的代码产生以下输出：

TextBlock1.Text = ""
TextBlock2.Text = "DataContext content"
TextBlock3.Text = "DataContext content"
bindingExpressionBase1.Status = Unattached
bindingExpressionBase2.Status = Active
bindingExpressionBase3.Status = Active

但是尽管如此，表单上的所有三个TextBlock都有预期值 - “DataContext content”。

所以我的问题是：

为什么RelativeSourceMode.FindAncestor绑定不提供在调用BindingOperations.SetBinding（...）之后立即调用值？
有没有办法强制这种绑定来更新目标属性？我试着调用bindingExpression.UpdateTarget（） - 它不能像预期的那样工作。

Answer 1

这是设计的。为了理解原因，我们来看看代码。

当Expression设置为DependencyProperty的值时，Expression.OnAttach被调用（source）。此方法在BindingExpressionBase类（source）：

中被覆盖

internal sealed override void OnAttach(DependencyObject d, DependencyProperty dp)
{
    if (d == null)
        throw new ArgumentNullException("d");
    if (dp == null)
        throw new ArgumentNullException("dp");

    Attach(d, dp);
}

internal void Attach(DependencyObject target, DependencyProperty dp)
{
    // make sure we're on the right thread to access the target
    if (target != null)
    {
        target.VerifyAccess();
    }

    IsAttaching = true;
    AttachOverride(target, dp);
    IsAttaching = false;
}

AttachOverride方法也是虚拟的，并且在BindingExpression（source）中被覆盖。

internal override bool AttachOverride(DependencyObject target, DependencyProperty dp)
{
    if (!base.AttachOverride(target, dp))
        return false;

    // listen for InheritanceContext change (if target is mentored)
    if (ParentBinding.SourceReference == null || ParentBinding.SourceReference.UsesMentor)
    {
        DependencyObject mentor = Helper.FindMentor(target);
        if (mentor != target)
        {
            InheritanceContextChangedEventManager.AddHandler(target, OnInheritanceContextChanged);
            UsingMentor = true;

            if (TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.Attach))
            {
                TraceData.Trace(TraceEventType.Warning,
                                    TraceData.UseMentor(
                                        TraceData.Identify(this),
                                        TraceData.Identify(mentor)));
                }
            }
        }

        // listen for lost focus
        if (IsUpdateOnLostFocus)
        {
            Invariant.Assert(!IsInMultiBindingExpression, "Source BindingExpressions of a MultiBindingExpression should never be UpdateOnLostFocus.");
            LostFocusEventManager.AddHandler(target, OnLostFocus);
        }

        // attach to things that need tree context.  Do it synchronously
        // if possible, otherwise post a task.  This gives the parser et al.
        // a chance to assemble the tree before we start walking it.
        AttachToContext(AttachAttempt.First);
        if (StatusInternal == BindingStatusInternal.Unattached)
        {
            Engine.AddTask(this, TaskOps.AttachToContext);

            if (TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.AttachToContext))
            {
                TraceData.Trace(TraceEventType.Warning,
                                    TraceData.DeferAttachToContext(
                                        TraceData.Identify(this)));
        }
    }

    GC.KeepAlive(target);   // keep target alive during activation (bug 956831)
    return true;
}

在列出的代码中，我们可以看到所有操作BindingExpression仍然可以Unattached。让我们看看为什么在我们的情况下如此。为此，我们需要确定状态的变化位置。这可以通过IL Spy来完成，它显示状态在AttachToContext（source）中发生了变化。

// try to get information from the tree context (parent, root, etc.)
// If everything succeeds, activate the binding.
// If anything fails in a way that might succeed after further layout,
// just return (with status == Unattached).  The binding engine will try
// again later. For hard failures, set an error status;  no more chances.
// During the "last chance" attempt, treat all failures as "hard".
void AttachToContext(AttachAttempt attempt)
{
    // if the target has been GC'd, just give up
    DependencyObject target = TargetElement;
    if (target == null)
        return;     // status will be Detached

    bool isExtendedTraceEnabled = TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.AttachToContext);
    bool traceObjectRef = TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.SourceLookup);

    // certain features should never be tried on the first attempt, as
    // they certainly require at least one layout pass
    if (attempt == AttachAttempt.First)
    {
        // relative source with ancestor lookup
        ObjectRef or = ParentBinding.SourceReference;
        if (or != null && or.TreeContextIsRequired(target))
        {
            if (isExtendedTraceEnabled)
            {
                TraceData.Trace(TraceEventType.Warning,
                                    TraceData.SourceRequiresTreeContext(
                                        TraceData.Identify(this),
                                        or.Identify()));
            }

            return;
        }
    }

在评论中说，某些功能需要至少一个布局传递，其中一个是RelativeSource祖先查找（source）。

internal bool TreeContextIsRequired(DependencyObject target)
{
    return ProtectedTreeContextIsRequired(target);
}

/// <summary> true if the ObjectRef really needs the tree context </summary>
protected override bool ProtectedTreeContextIsRequired(DependencyObject target)
{
    return  (   (_relativeSource.Mode == RelativeSourceMode.FindAncestor
        ||  (_relativeSource.Mode == RelativeSourceMode.PreviousData)));
}

因为RelativeSource BindingExpression Unattached UpdateLayout需要树上下文。因此，属性值不会立即更新。

在任何UIElement上调用BindingExpression以强制更新布局并附加{{1}}。

为什么绑定到祖先会比通过其名称绑定到元素或绑定到DataContext后变得活跃？

1 个答案: