Question

我有一个来自RichTextBox的自定义UserControl子类。这个类有一个依赖属性，Equation，它是双向绑定的。

当用户将项目放到控件上时，我改变了公式。这会将更改正确地传播到绑定的另一端，从而触发属性更改通知，但UI不会更改。如果我将绑定更改为另一个对象并将其返回，则显示更新的公式。

如何在不更改绑定的情况下强制刷新？现在我设置Equation = null然后返回哪个有效，但这似乎是hackish。必须有更优雅的东西。

以下是对照的相关部分。我想要发生的是在更改Equation（Equation.Components.Add（txt））之后调用OnEquationChanged回调。

public class EquationTextBox : RichTextBox
{
    protected override void OnDrop(DragEventArgs e)
    {
        if (e.Data.GetDataPresent(DataFormats.StringFormat))
        {
            string str = (string)e.Data.GetData(DataFormats.StringFormat);

            EquationText txt = new EquationText(str);
            //// Preferred /////
            Equation.Components.Add(txt);
            //// HACK /////
            Equation eqn = this.Equation;
            eqn.Components.Add(txt);
            this.Equation = null;
            this.Equation = eqn;
            ///////////////
            Console.WriteLine("Dropping " + str);
        }
    }

    public Equation Equation
    {
        get { return (Equation)GetValue(EquationProperty); }
        set { SetValue(EquationProperty, value); }
    }

    private static void onEquationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        string prop = e.Property.ToString();
        EquationTextBox txtBox = d as EquationTextBox;
        if(txtBox == null || txtBox.Equation == null)
            return;

        FlowDocument doc = txtBox.Document;
        doc.Blocks.Clear();
        doc.Blocks.Add(new Paragraph(new Run(txtBox.Equation.ToString())));
    }

    public static readonly DependencyProperty EquationProperty =
        DependencyProperty.Register("Equation",
                                    typeof(Equation),
                                    typeof(EquationTextBox),
                                    new FrameworkPropertyMetadata(null,
                                                                  FrameworkPropertyMetadataOptions.AffectsRender,
                                                                  new PropertyChangedCallback(onEquationChanged)));

    private bool mIsTextChanged;
}

}

这是双向绑定另一端的属性。由于Equation.Components.Add（txt）;

在上面的代码中调用了equation_PropertyChanged事件。

public Equation Equation
{
    get{ return mEquation; }
    set { mEquation = value; NotifyPropertyChanged(); }
}

private void equation_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    NotifyPropertyChanged("Equation");
}

private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
{
    if (PropertyChanged != null)
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}

编辑--------------------------

根据评论，我尝试使用这样的调度员（请注意，这是我第一次尝试使用调度程序）

        string str = (string)e.Data.GetData(DataFormats.StringFormat);

        EquationText txt = new EquationText(str);
        Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() =>
            {
                Equation.Components.Add(txt); 
                NotifyPropertyChanged("Equation");
            }));

但仍无UI更新。

编辑2 --------------------------

双向绑定在XAML中完成

<l:EquationTextBox x:Name="ui_txtVariableEquation" Grid.Row="0" Grid.Column="2" 
                             Grid.RowSpan="3" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"
                                   AllowDrop="True"
                                   Equation="{Binding SelectedVariableVM.Variable.Equation, Mode=TwoWay}">
                </l:EquationTextBox>

与Components对象相关的信息（在Equation类中）

public class Equation : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public Equation()
    {
        mComponents = new ObservableCollection<EquationComponent>();

        mComponents.CollectionChanged += new NotifyCollectionChangedEventHandler(components_CollectionChanged);
    }

    public Equation(string eqn) : this()
    {
        mComponents.Add(new EquationText(eqn));
    }

    public ObservableCollection<EquationComponent> Components
    {
        get{ return mComponents; }
        set{ mComponents = value; NotifyPropertyChanged();}
    }

    public override string ToString()
    {
        string str = "";
        for(int i=0; i<mComponents.Count; i++)
            str += mComponents[i].ToString();

        return str;
    }

    private void components_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        NotifyPropertyChanged("Components");
    }

    private ObservableCollection<EquationComponent> mComponents;

    private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

public class Variable : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public Variable(string name = "var", VariableType type = VariableType.UnknownType) :
        this(name, "", 0, type)
    {
    }

和......

    public class Variable : INotifyPropertyChanged
{
    public Variable(string name, string unit, object val, VariableType type)
    {
        mEquation = new Equation(name + " = " + val.ToString() + 
        mEquation.PropertyChanged += new PropertyChangedEventHandler(equation_PropertyChanged);

    }

    ...
    public Equation Equation
    {
        get{ return mEquation; }
        set { mEquation = value; NotifyPropertyChanged(); }
    }

    private void equation_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        NotifyPropertyChanged("Equation");
    }

    private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }


    private Equation mEquation;
    ...
}

在Equation类中引发事件时调用Variable.equation_PropertyChanged

Answer 1

我认为问题在于绑定产生的值实际上并不是正在改变（它仍然是同一个Equation对象）。如果DP值未更改，则不会调用DP更改处理程序。

也许，在您的DP更改处理程序中，您应该订阅新方程的PropertyChanged事件，然后在基础属性更改时重建您的文档：

private static void onEquationChanged(
    DependencyObject d,
    DependencyPropertyChangedEventArgs e)
{
    var txtBox = d as EquationTextBox;
    if (txtBox == null)
        return;

    var oldEquation = e.OldValue as Equation;
    if (oldEquation != null)
        oldEquation.PropertyChanged -= txtBox.OnEquationPropertyChanged;

    var newEquation = e.NewValue as Equation;
    if (newEquation != null)
        newEquation.PropertyChanged += txtBox.OnEquationPropertyChanged;

    txtBox.RebuildDocument();
}

private void OnEquationPropertyChanged(object sender, EventArgs e)
{
    RebuildDocument();
}

private void RebuildDocument()
{
    FlowDocument doc = this.Document;

    doc.Blocks.Clear();

    var equation = this.Equation;
    if (equation != null)
        doc.Blocks.Add(new Paragraph(new Run(equation.ToString())));
}

wpf手动刷新依赖属性

1 个答案: