Creating source node which sends new event when a property is changed

[ZegCricket]

Hello! Hope you are doing well.

I'm trying to create a package that extends some functionality I need, but I'm not very familiar with C# and ReactiveX.
For a source node in particular, I would like to perform a calculation based on the properties of the node and that the result of the calculation would be sent as an event everytime I changed a property (similar to what happens with the Int node). However, only one event is sent and it only happens when the workflow starts running. When I change a property of the node, nothing happens.

I have already implemented the case for which I "feed" an input stream to the same source node and if any property is changed, the value of the next event is what is expected, so I believe that the problem has to do with the type of observable that I'm creating in the first case.

Here's the code I'm using for both implementations:

// Node version without input data stream
public IObservable<double[]> Generate()
{
    return Observable.Defer(() => Observable.Return(ILDArray()));
}

// Node version with input data stream
public IObservable<double[]> Generate<TSource>(IObservable<TSource> source)
{
    return source.Select(input => ILDArray());
}

In case it helps the properties of the node and the ILDArray function are the following:

public int NumSteps { get; set; }
public double StepSize { get; set; }
public bool UseLog { get; set; }
public double LogBase { get; set; } = Math.E;

public double[] ILDArray()
{
    double[] ILDs = new double[NumSteps * 2];
    for (int i = 0; i < NumSteps; i++)
    {
        if (UseLog)
        {
            ILDs[i] = -StepSize * Math.Log(1 + NumSteps - i, LogBase);
        }
        else
        {
            ILDs[i] = -StepSize * (NumSteps - i);
        }
    }

    for (int i = NumSteps; i < NumSteps * 2; i++)
    {
        if (UseLog)
        {
            ILDs[i] = StepSize * Math.Log(1 + i - NumSteps + 1, LogBase);
        }
        else
        {
            ILDs[i] = StepSize * (i - NumSteps + 1);
        }
    }

    return ILDs;
}

Let me know if you need me to clarify the problem, because I believe my explanation is a bit confusing.

Thank you in advance for your help!

[ncguilbeault]

I think the Bonsai source code has some examples for how to do this. For example, here.

Basically, in addition to what you have already coded, you want to trigger an event that will emit a new value to the sequence whenever the property value changes. In the example above, there is a function called OnValueChanged which gets called anytime the value of the property is set. The Action<int> ValueChanged is a type of delegate, which takes a single argument int. The OnValueChanged method is responsible for raising the ValueChanged event.

Inside of the Generate method, Observable.Defer(() => Observable.Return(value)) ensures that the current value is emitted when the observable sequence is subscribed to while Observable.FromEvent<int> creates an observable that listens to the ValueChanged event and emits a new value each time the event is raised. The Concat method ensures that the observables are combined into a single sequence.

[ZegCricket]

Thank you so much! It worked! :)