-1

How to properly write complex observable logic is case of class inheritance?

Please check an example:

    public class A : ReactiveObject
{
    public A()
    {
        AProperty = new SimpleValue();

        this.WhenAnyValue(x => x.AProperty)
            // virtual method call in constructor
            .Subscribe(x => CheckIsChanged());

        // this will crash app because B is not initialized
        AProperty.Value = true;
    }

    #region "AProperty" property

    private SimpleValue _aProperty;

    public SimpleValue AProperty
    {
        get { return _aProperty; }
        set { this.RaiseAndSetIfChanged(ref _aProperty, value); }
    }

    #endregion

    protected virtual bool CalculateIsChanged()
    {
        return AProperty.Value;
    }

    protected void CheckIsChanged()
    {
        IsChanged = CalculateIsChanged();
    }

    #region "IsChanged" property

    private bool _isChanged;

    public bool IsChanged
    {
        get { return _isChanged; }
        set { this.RaiseAndSetIfChanged(ref _isChanged, value); }
    }

    #endregion
}

public class B : A
{
    public B()
    {
        BProperty = new SimpleValue();
    }

    protected override bool CalculateIsChanged()
    {
        // crash will happen here
        return BProperty.Value || base.CalculateIsChanged();

        // definitely we can check BProperty for null
        // but i hope there are more elegant way to do not call such methods before all class tree initialized
        // or better way to write everything :)
    }

    #region "BProperty" property

    private SimpleValue _bProperty;

    public SimpleValue BProperty
    {
        get { return _bProperty; }
        set { this.RaiseAndSetIfChanged(ref _bProperty, value); }
    }

    #endregion
}

public class SimpleValue: ReactiveObject
{
    #region "Value" property

    private bool _value;

    public bool Value
    {
        get { return _value; }
        set { this.RaiseAndSetIfChanged(ref _value, value); }
    }

    #endregion
}

This is simple example but dependencies and logic on the could be much harder (10 properties in each class to observe... complex logical decisions)

P.S. have no idea what to add to my "mostly code" question. Hope you find "more details" in the code comments.

Oleg Gochachko
  • 101
  • 7

1 Answers1

1

The problem is your calling a virtual method in your constructor (even though it's embedded inside your WhenAnyValue call).

Your best bet is to move to either a virtual Initialize() method call so you can create BProperty first then call into the base class, or move to a composition based design where your BProperty logic is hosted elsewhere.

The problem with virtual methods in constructors is you can't control when the base class's constructor is called, it's always called before your derived classes constructor.

Glenn Watson
  • 2,758
  • 1
  • 20
  • 30
  • Thanks, but it's a crutch (temporary solution (what if I remove property assignment or add another one in constructor...)) to exactly current implementation rather than elegant universal approach. – Oleg Gochachko Dec 12 '18 at 10:20
  • Well part of your problem is your relying on virtual methods in your Constructor for which is a big no no. Often people get around this by using an Initialize() method in their class. Constructors get called in the opposite order you want in this case. – Glenn Watson Dec 12 '18 at 15:45
  • Also I think your solution is crying out for composition in this case. Eg if you have a constructor injected object with your derived functionality it will likely allow some decoupling. – Glenn Watson Dec 12 '18 at 15:50
  • Thanks for comments Glenn. 1. this is simplest example to understand the problem. 2. There are no direct calls virtual methods in constructor (and i know this is bad). 3. I asked for better solution - and your proposal at the moment - "skip" processing events several times. 4. if you have another "big yes yes" approach to decompose logic in different classes - you are always welcome. – Oleg Gochachko Dec 12 '18 at 19:50
  • 1
    CalculateIsChanged is called in your constructor by your WhenAnyValue call which is virtual which is going to case you issues. Hence the suggestion of moving it into a initialize method. Since your BProperty won't exist yet due to breaking the general advice of calling virtual methods in a constructor. – Glenn Watson Dec 12 '18 at 22:53
  • While Glenn's Skip answer may not be the best. He is trying to get you over the initial property changed event that will trigger and result in a thrown exception based on how your code is constructed currently. He is not pointing out that your approach leaves some to be desired. Part of the sell to Rx is that objects are composable. And that brings up the classic [Composition vs Inheritance](https://en.wikipedia.org/wiki/Composition_over_inheritance) conversation. I think your approach could be different. But that doesn't really answer your question of bypassing an event. – Rodney Littles Dec 12 '18 at 23:12