Update dependent properties

Maciejasjmj

So, I've already described my problem in the Lounge, but since I'm a little stuck, I might as well pull it out here.

I have a bunch of objects representing some models. Said models have a lot of properties, and some of them should be calculated based on other properties - an example model would look like that:

public class MyModel
{
    public decimal Foo { get; set; }
    public decimal Bar { get; set; }
    public decimal Baz { get { return Bar * 2; } }
    public decimal Quux { get { return Bar + Baz; } }
    public decimal Norf { get { return Foo * 0.5; } }
}

Easy and simple. Problem is, the data in the DB sometimes will not follow the formulas, and the application needs to account for that:

each record needs a "Calculate" flag. If it's set, the fields should follow the formulas and automatically update themselves, but if it's not, then Baz, Quux and Norf should be editable.
if the fields are set from the DB, then the values in the fields should not change until a relevant field is edited. So if the user edits Bar, Baz and Quux should be recalculated based on the new value, but Norf should not even if it's not equal to Foo * 0.5 at the moment.

I have this code, and it works:

public class MyModel
{
    public bool Calculate { get; set; }
    private decimal _foo;
    public decimal Foo
    {
        get { return _foo; }
        set
        {
            _foo = value;
            _norf = _norfCalculated;
        }
    }

    private decimal _bar;
    public decimal Bar
    {
        get { return _bar; }
        set
        {
            _bar = value;
            _baz = _bazCalculated;
            _quux = _quuxCalculated;
        }
    }
    private decimal _bazBacking;
    private decimal _baz //quux needs to be updated even if we're assigning privately
    {
        get { return _bazBacking; }
        set
        {
             _bazBacking = value;             
             _quux = _quuxCalculated;
        }
    }
    private decimal _bazCalculated { get { return Bar * 2; } }
    private decimal _bazUser;
    public decimal Baz
    {
        get { return Calculate ? _baz : _bazUser; }
        set
        {
             _baz = value;
             _bazUser = value;
        }
    }

    private decimal _quux;
    private decimal _quuxCalculated { get { return Bar + Baz; } }
    private decimal _quuxUser;
    public decimal Quux
    {
        get { return Calculate ? _quux : _quuxUser; }
        set
        {
             _quux = value;
             _quuxUser = value;
        }
    }

    private decimal _norf;
    private decimal _norfCalculated { get { return Foo * 0.5; } }
    private decimal _norfUser;
    public decimal Norf
    {
        get { return Calculate ? _norf : _norfUser; }
        set
        {
             _norf = value;
             _norfUser = value;
        }
    }
}

It works, but it's rather terrible to manage, given the fact that there can be anywhere between 30 to 70 properties on any given model, there are almost 20 models, and you basically need to reason backwards from the formulas - if Baz = Bar * 2, then you not only have to update Baz to calculate itself, but also remember to update Bar to trigger the property update. I tried the magic reflection wand, and it helped a bit, but not much:

public class MyModel
{
    private enum Fields //no magic strings in the application
    {
        Foo, Bar, Baz, Quux, Norf
    }
    
    private void UpdateDependents(Expression<Func<MyModel, object>> caller) //goes into the base class actually
    {
        var changedPropertyInfo = LambdaParser.GetPropertyByLambda(changedProperty); // gets PropertyInfo from the selector
        if (changedPropertyInfo == null) return;
        if (changedPropertyInfo.HasAttribute<FieldAttribute>())
        {
            var changedFieldEnum = changedPropertyInfo.GetAttribute<FieldAttribute>().Field; //get the field ID
            if (changedFieldEnum == null) return;
            var allMembers = typeof(MyModel)
                .GetMembers(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); //get all members
            var dependentMembers = allMembers
                   .Where(x => x.GetAttributes<DependsOnAttribute>()
                                .Any(y => changedFieldEnum.Equals(y.Field))); //get all members with a DependsOn attribute pointing at current field
            foreach (var dependentMember in dependentMembers)
            {
                var dependentFieldEnum = dependentMember.GetAttribute<FieldAttribute>().Field; //get ID of the dependent field
                var calculationField = allMembers
                       .Where(x => x.GetAttributes<CalculatingBackingFieldAttribute>()
                                    .Any(y => dependentFieldEnum.Equals(y.Field))).FirstOrDefault(); //find the backing field that does the calculation
                var baseField = allMembers
                       .Where(x => x.GetAttributes<BaseBackingFieldAttribute>()
                                    .Any(y => dependentFieldEnum.Equals(y.Field))).FirstOrDefault(); //find the backing field to set
                var value = ((PropertyInfo)calculationField).GetValue(this, null); //get the calculated value
                ((FieldInfo)baseField).SetValue(this, value); //set the backing field to the calculated value
            }
        }
    }

    public bool Calculate { get; set; }
    private decimal _foo;
    [Field(Fields.Foo)]
    public decimal Foo
    {
        get { return _foo; }
        set
        {
            _foo = value;
            UpdateDependents(x => x.Foo);
        }
    }

    private decimal _bar;
    [Field(Fields.Bar)]
    public decimal Bar
    {
        get { return _bar; }
        set
        {
            _bar = value;
            UpdateDependents(x => x.Bar);
        }
    }
    [BaseBackingField(Fields.Baz)]
    private decimal _baz;
    [CalculatingBackingField(Fields.Baz)]
    private decimal _bazCalculated { get { return Bar * 2; } }
    private decimal _bazUser;
    [Field(Fields.Baz)]
    [DependsOn(Fields.Bar)]
    public decimal Baz
    {
        get { return Calculate ? _baz : _bazUser; }
        set
        {
             _baz = value;
             _bazUser = value;
             UpdateDependents(x => x.Baz);
        }
    }
    [BaseBackingField(Fields.Quux)]
    private decimal _quux;
    [CalculatingBackingField(Fields.Quux)]
    private decimal _quuxCalculated { get { return Bar + Baz; } }
    private decimal _quuxUser;
    [Field(Fields.Quux)]
    [DependsOn(Fields.Bar)]
    [DependsOn(Fields.Baz)]
    public decimal Quux
    {
        get { return Calculate ? _quux : _quuxUser; }
        set
        {
             _quux = value;
             _quuxUser = value;
             UpdateDependents(x => x.Quux);
        }
    }
    [BaseBackingField(Fields.Norf)]
    private decimal _norf;
    [CalculatingBackingField(Fields.Norf)]
    private decimal _norfCalculated { get { return Foo * 0.5; } }
    private decimal _norfUser;
    [Field(Fields.Norf)]
    [DependsOn(Fields.Foo)]
    public decimal Norf
    {
        get { return Calculate ? _norf : _norfUser; }
        set
        {
             _norf = value;
             _norfUser = value;
             UpdateDependents(x => x.Norf);
        }
    }
}

On one hand, it inverts the problem and allows me to just set the attributes on the property to be updated, instead of modifying properties that trigger the updates. On the other, it's a total fucking incomprehensible spaghetti soup, it requires me to define an enum with every property involved in the mechanism (no, really, fuck magic strings), and it still requires me to remember to call UpdateDependents(). Performance will also likely suck, but at least that is not much of an issue.

In short - I need a smart way to trigger property updates when a property on the model changes, and I can't use the standard calculated properties. What do I do?

PleegWat

Without actually knowing anything about C#, isn't this fixable with change listeners?

Gąska

What I'd do:

Dictionary<Field, decimal> fixed_values that will hold fixed values
Dictionary<Field, Func<decimal>> formulas that will hold formulas to calculate dependencies

When value of any field changes, iterate over all entries in formulas and assign results to calculated_values. A getter for each field should check if a fixed value exists for a given field - if yes, return it, if not, calculate it using formula.

If you cannot afford to calculate each property again and again whenever it's used, you can cache the results in another dictionary - say, calculated_values - and on each change to any fixed value, iterate over all formulas and update respective entries in calculated_values regardless of whether there was a dependency between the values or not. In short - fuck dependencies, update everything. This is assuming that recalculating all the values on each change doesn't take too long, which I would be very surprised if it did, since we're talking about a hundred values tops.

Maciejasjmj

@Gaska said:

In short - fuck dependencies, update everything.

Problem is, it's a business requirement that we don't update everything, just the values that actually depend - directly or indirectly - on the changed value. Otherwise it would be much simpler.

Gąska

If a tree falls in a forest and no one is around to hear it, does it make a sound? If a value is recalculated and assigned the same value as before, has it really been updated?

Maciejasjmj

@Gaska said:

If a value is recalculated and assigned the same value as before, has it really been updated?

Let's say you pull from the database:

Foo |Bar |Baz |Quux|Norf|
12  |34  |751 |9050|1267|

Then, in the application, you assign Bar = 50. If you recalculate all the values, you get

Foo |Bar |Baz |Quux|Norf|
12  |50  |100 |150 |24  |

Instead of:

Foo |Bar |Baz |Quux|Norf|
12  |50  |100 |150 |1267|

which is what the business requires you to get, since OMG I haven't changed Foo and Norf changed under me, fix it nao!

Gąska

You calculate all values, but use the calculated value only when there is no fixed value already present for the given field.

PleegWat

But Baz, Quux, and Norf already have a value in the DB, which overrides calculations, right?

Maciejasjmj

@PleegWat said:

But Baz, Quux, and Norf already have a value in the DB, which overrides calculations, right?

Yeah, well, that would be simple.

They have values in the DB, and those values are set on initialization, but when the user edits Bar later while the Calculate flag is set, it should recalculate the values for Baz and Quux based on the new Bar value.

Which is also why @Gaska's method doesn't quite work - depending on how you look at it, either none or all of the properties have a "fixed value" at the beginning, and yet only Baz and Quux should be updated when Bar is, and Norf should be left alone.

PleegWat

OK I'm getting out of here before my head explodes.

Gąska

@Maciejasjmj said:

They have values in the DB, and those values are set on initialization, but when the user edits Bar later while the Calculate flag is set, it should recalculate the values for Baz and Quux based on the new Bar value.

OK, I'm completely lost. Let's talk about concrete examples. Dependencies are Foo <- Bar <- Baz.

Foo is initialized with value, Bar and Baz are not. When Foo changes, both Bar and Baz change?
Foo and Bar are initialized with value, Baz is not. When Foo changes, neither Bar nor Baz change?
Foo and Baz are initialized with value, Bar is not. Bar changes by some other means than changing Foo. Does it make sense at all? If so, does either Foo or Baz change?

Maciejasjmj

@Gaska said:

OK, I'm completely lost.

Ok, let's start from scratch. There's no concept of "initialized/uninitialized", every field gets a starting value from the DB (which might be null, but then it's just null).

Point is, the values the object is initialized with do not necessarily follow the formulas. That object is then shoved into a data-bound form. At this point, the values in the object are supposed to be the same as when it was pulled from the DB - if no changes were made, then we're supposed to save the object the same as it was before.

Then, the user changes a value. When he does, if the Calculate flag is set, then every value dependent on the value changed should be calculated from the new value, but the values not dependent on the value changed should not be touched.

For a more real life example: assume you have an object with the following fields:

WalletInPLN | WalletInUSD | BankAcctInPLN | BankAcctInUSD | USDPLNRate
2150        | 99999       | 10000         | 74344         | 2.00

Let's say the formulas are WalletInUSD = WalletInPLN * USDPLNRate and BankAcctInUSD = BankAcctInPLN * USDPLNRate.

The values you have in the object are what you pulled from the DB. If you don't change anything and just click "Save", the USD values shouldn't change, even though they're incorrect based on the exchange rate.

If the user edits only WalletInPLN, then WalletInUSD should be updated based on the exchange rate, but the bank account values shouldn't be touched. So, if you update WalletInPLN = 2000, you should end up with the following values:

WalletInPLN | WalletInUSD | BankAcctInPLN | BankAcctInUSD | USDPLNRate
2000        | 4000 (calc.)| 10000         | 74344         | 2.00

Gąska

Oh, I see. Previously I thought that Calculate is based solely on existence in DB.

My previous solution can be adapted quite easily.

Dictionary<Field, decimal> values - will contain values, either calculated or fixed.
Dictionary<Field, Func> formulas - will contain formulas to recalculate.
Dictionary<Field, Field> dependencies - a hardcoded constant that will contain all edges in the dependency graph.
Dictionary<Field, Field> realDependencies - calculated based on dependencies; it contains all direct and indirect dependencies.
Set<Field> fieldsToRecalculate - will hold all fields that can be recalculated and don't have to match DB values
Initially, values is filled with DB values and fieldsToRecalculate is empty.
Getters look like:

if (!values.has(field)) {
    values[field] = formulas[field](this);
}
return values[field];

If some field is changed, then all dependent values that are included in fieldsToRecalculate are removed from values, then they're each assigned recalculated value. The order in which they're recalculated in this step doesn't matter, since if some value is recalculated earlier than its dependency, the getter will get the job done.

If you want a really fancy solution, you can automatically generate dependency graph by making a mock class which will remember which getters were called and return dummy values for them - it doesn't matter what, because the result won't be used. Then iterate over formulas, call each function with a new mock, and collect the results. Voila!

blakeyrat

I don't really have a better solution (and I think reflection is icky), except I'd implement your original plan using nullable values:

private decimal? _baz = null;
    
public decimal Baz {
    get { if( _baz.HasValue() ) { return _baz.Value; } else { return Bar * 2; } }
    set { _baz = value }
}

Reflection just makes it nearly impossible to tell what's going on.

Tsaukpaetra

Wow, 14 replies and not a single like? Where's the love

Maciejasjmj

@Gaska said:

Voila!

I'm not sure if that's gonna result in less or more boilerplate than I have now, but hell, it might work, and I use a similar dictionary-based approach somewhere else so it won't be too out-of-place... will investigate Monday.