PropertyChangedReactions 1.0.0

README

Small helper project to handle property changes and conditionally execute post change behaviors. This helps remove the boilerplate of backing fields and allows for defining behaviors to run after setting a property.

Background

Sometimes logic needs to execute after a property changed and that typically requires a backing field to do something like

public int SomeProperty
{
    get
    {
        return _someBackingField;
    }
    set
    {
        if(_someBackingField == value)
            return;
        _someBackingField = value;

        SomeLogic();

        if (foo)
            SomeOtherLogic();
    }
}

This project takes that idea and attempts to wrap it up in a cleaner way.

Example

Basic get/set

For basic getting and setting, you can use the property model to handle the boiler plate for you, without backing fields. It also cleans up the code a bit, for example updating a property type would just be changing the type definition in the Get method.

public int IntProperty
{
    get => Model.Get<int>();
    set => Model.Set(value);
}

Set Only If Value Changed

To filter out the "if not changed return" boilerplate, the SetIfChanged can be used.

 public bool IsSomeState
{
    get => _model.Get<bool>();
    private set => _model.SetIfChanged(value);
}

Note: This is the default behavior when using PropertyChangedReaction

Adding Post OnChanged Behaviors

To run logic after a property is changed, PropertyChangedReaction objects can be used.

public string StringProperty
{
    get => _model.Get<string>();
    set => _model.Reaction()
        .AddOnChangedBehavior(() => Foo())
        .AddOnChangedBehavior(() =>
        {
            if (bar)
                Baz();
        })
        .Set(value);
}

Even Cleaner Version

The above is to demonstrate the idea, but still has boilerplate in the set logic. This can of course be reduced with some refactoring.

public string StringProperty
{
    get => _model.Get<string>();
    set => _model.Reaction()
            .AddOnChangedBehavior(OnStringPropertyUpdated)
            .Set(value);
}

private void OnStringPropertyUpdated()
{
    Foo();

    if(bar)
        Baz();
}

Or

// set example
set => UpdateStringProperty(value);

UpdateStringProperty(string newVal)
{
    _model.Reaction(nameof(StringProperty))
        .AddOnChangedBehavior(OnStringPropertyUpdated)
        .Set(value);
}

The above snippets add 2 behaviors to run after the property StringProperty is changed to a new value. After the set, and the native OnPropertyChanged executes, the 2 additional behaviors will run.

This works by first calling the Setup method which starts a reaction chain, allowing the setup of the behaviors. At the end is the call to Set() which commits the property value, updates if changed (again the setup / reaction workflow does not do direct value setting, and only sets if different) and fires the post-changed behaviors.