Showing Results of Calculation while typing c# (something like deepbinding in Java(FX))

Question

i'm looking for a possibility to Update a TextBox TextProperty while typing in an other Textbox. I got a Couple of Double Properties, all entered via Textboxes and i got 1 ReadOnly Property using the Double Properties for doing some Math and returning the result. I want that result to be displayed in a ReadOnly TextBox (WPF) and it should update automatically when typing/changing an Input Parameter TextBox.

As i worked with JavaFX the last years i could use a deepbinding to do that:

DoubleBinding calcBind = new DoubleBinding(){
     {
          super.bind(PropA, PropB, PropC);
     }
          @Override
          protected double computeValue(){
              return (PropA * PropB / PropC)

          }
     };

The Dependencies statet with super.bind(...) are automatically checked if they changed and the result is automatically updated.

Now i'm just lookin for a possibility to realize that in C#

As said i am using a couple of properties. Also INotifyPropertyChanged is implemented. So PropA, B and C stating OnPropertyChanged("PropA") when set. The Calculation is done in a Readonly Property like

public Double MathProp
{
    get
    {
         return PropA*PropB/PropC;
    }
}

I am Binding it via Code to a TextBox TextProperty.

Binding mathBinding = new Binding
{
    Source = ObjectHolding.MathProp,
    Path = new PropertyPath("MathProp"),
    UpdateSourceTrigger = UpdateSourceTrigger.Explicit,
    Mode = BindingMode.OnyWay
};

TextBox txtMathBox = new TextBox();
txtMathBox.SetBinding(TextBox.TextProperty, mathBinding);

I used the Explicit Trigger to do it the "BruteForce"-Way and updating it manually when a KeyEvent occurs. But its just not working very well and i dont like that way of resolving the problmen. There has to be a more elegant way. I hope u could point me in the right direction. I thought about using a converter instead of a ReadOnly Property to do the calculations. But i am not converting i am just doing some math and not changing the types.

Would be glad if u got some hints for me.

Thanks

Answer 1

Ok, let me split this into parts:

As i worked with JavaFX the last years

Forget java.

java's approach is tremendously inferior (just as everything else in java), due to the tight coupling that occurs between your UI and the application logic behind it.

If you're working with WPF, it is strongly recommended that you leave behind any and all approaches you might have learned from archaic, legacy technologies and understand and embrace The WPF Mentality (this is getting very repetitive).

Basically, in WPF you don't put "calculations" or other code that doesn't really belong into the UI into UI-related classes. Instead, you create a proper ViewModel which is completely agnostic from the UI and contains whatever data you need to display, and the logic you need to perform on it, and then simply use DataBinding to populate the XAML-defined UI with such data.

So, basically, this is the correct way to do what you're trying to achieve, as per your comments, in WPF:

public class ViewModel : INotifyPropertyChanged
{
    private double _value1;
    private double _value2;
    private double _result;

    public double Value1
    {
        get { return _value1; }
        set
        {
            _value1 = value;
            OnPropertyChanged();
            OnPropertyChanged("Result");
        }
    }

    public double Value2
    {
        get { return _value2; }
        set
        {
            _value2 = value;
            OnPropertyChanged();
            OnPropertyChanged("Result");
        }
    }

    public double Result
    {
        get { return Value1*Value2; }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        var handler = PropertyChanged;
        if (handler != null) 
            handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

XAML:

<Window x:Class="WpfApplication4.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel>
        <TextBox Text="{Binding Value1, UpdateSourceTrigger=PropertyChanged}"/>
        <TextBox Text="{Binding Value2, UpdateSourceTrigger=PropertyChanged}"/>
        <TextBox Text="{Binding Result, Mode=OneWay}" IsReadOnly="True"/>
    </StackPanel>
</Window>

Code behind:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        DataContext = new ViewModel();
    }
}

• Notice how I'm setting UpdateSourceTrigger=PropertyChanged on the first and second bindings. This causes the binding to update the value source immediately when the target changes (which means it's being done at every key press).

• Also notice that the ViewModel must Implement INotifyPropertyChanged in order to properly support two-way WPF DataBinding.

• Notice how the logic is completely decoupled from the UI and it's really Simple, Simple Properties and INotifyPropertyChanged. No need for bizarre manipulations of the binding framework or stupid @override (whatever that means) boilerplate.

• Also see how I'm using XAML rather than procedural code to Define the UI, and then simple DataBinding to connect it to the underlying data. In WPF, manipulating UI elements in procedural code is discouraged and unneeded.

• WPF Rocks. C# Rocks. java is legacy.

• Let me know if you need further help.