Restoring data 1 minute ago for time-shifted sequence - system.reactive

Question

This class accumulates values + knows at current moment the difference between current sum and sum 1 minute ago. Its client uses it in such way: adds new value for every incoming data chunk and gets the difference. Now, there's a problem with restoring its state. Suppose application gets recycled, and this data in pump for previous minute is lost and first minute after recycling Change will equal 0, so I'd have to wait for a minute to be able to calculate difference. How to fix it?
public class ChangeEstimator
{
private int sum;
private Subject<int> sumPump;
private IConnectableObservable<int> hotSumPump;
public int Sum
{
get
{
return sum;
}
private set
{
sum = value;
sumPump.OnNext(value);
}
}
public int Change { get; private set; }
public void Start()
{
sumPump = new Subject<int>();
hotSumPump = sumPump.Publish();
var changePeriod = TimeSpan.FromMinutes(1);
hotSumPump.Delay(changePeriod)
.Subscribe(value =>
{
Change = Sum - value;
});
hotSumPump.Connect();
}
public void AddNewValue(int newValue)
{
Sum += newValue;
}
}
UPDATE
In the code below you can see the explanation. The client subscribes to transaction stream, and with every new transaction it updates the estimator. Also client exposes IObservable source of snapshots which pushes snapshot of data to listeners which can be UI or database. The problem is when recycling happens, UI will be shown not real Change but 0. If this problem is too specific for Stackoverflow please forgive me. I was advised to use RabbitMQ to keep persistence of changes. Do you think it could work for this problem?
public class Transaction
{
public int Price { get; set; }
}
public class AlgorithmResult
{
public int Change { get; set; }
}
public interface ITransactionProvider
{
IObservable<Transaction> TransactionStream { get; }
}
public class Client
{
private ChangeEstimator estimator = new ChangeEstimator();
private ITransactionProvider transactionProvider;
public Client(ITransactionProvider transactionProvider)
{
this.transactionProvider = transactionProvider;
}
public void Init()
{
transactionProvider.TransactionStream.Subscribe(t =>
{
estimator.AddNewValue(t.Price);
});
}
public IObservable<AlgorithmResult> CreateSnaphotsTimedSource(int periodSeconds)
{
return Observable
.Interval(TimeSpan.FromSeconds(periodSeconds))
.Select(_ =>
{
AlgorithmResult snapshot;
snapshot = new AlgorithmResult
{
Change = estimator.Change
};
return snapshot;
})
.Where(snapshot => snapshot != null);
}
}

Answer 1

Your application gets restarted and has no memory (pun intended) of its previous life. No Rx tricks (within this application) can help you.
As discussed, you should figure out the business requirements and consider state initialization during startup.
You might want to consider storing latest state via I/O source or separating application logic between message sender and consumer in order to implement a queue.

Answer 2

I have to answer my own question because I got an answer from someone and this works in my case. I agree that the correct answer depends on the business logic and I think I had explained it as clearly as I could.
So, here the right way to deal with possible application recycle is to put the class ChangeEstimator to outer process and exchange messages with it.
I use AMQP to send messages to estimator (RabbitMQ). To key point here is that the risk that external process will close/recycle is really small compared to that of web application in which the rest is contained.