public void TestReactiveExpressionWeakness2()
{
var dependency = new ReactiveVariable <int>();
AddDependents(dependency, true);
GC.Collect();
Assert.AreEqual(0, ReactiveManager.GetDependents(dependency).Count());
}
public void Square()
{
var input = new ReactiveVariable <int>(1);
var inputSquared = new ReactiveExpression <int>(() => input.Value * input.Value);
inputSquared.Subscribe(getSquare => Console.WriteLine("square = " + getSquare()));
input.Value = 2;
input.Value = 3;
}
static void AddDependents(ReactiveVariable <int> dependency, bool weak)
{
int sum = 0;
foreach (var obj in Enumerable.Range(0, 10000))
{
var expression = new ReactiveExpression <int>(() => dependency.Value, weak);
sum += expression.Evaluate();
}
}
public void Composition()
{
var input = new ReactiveVariable <int>();
var timesTwo = new ReactiveExpression <int>(() => input.Value * 2);
var timesThree = new ReactiveExpression <int>(() => input.Value * 3);
var sumOfBoth = new ReactiveExpression <int>(() => timesTwo.Evaluate() + timesThree.Evaluate());
sumOfBoth.Subscribe(getValue => Console.WriteLine("sumOfBoth = " + getValue())); //Prints 'sumOfBoth = 0'
input.Value = 1; //Prints 'sumOfBoth = 5'
input.Value = 2; //Prints 'sumOfBoth = 10'
}
public void Precise()
{
var left = new ReactiveVariable <bool>();
var right = new ReactiveVariable <bool>();
var leftOrRight = new ReactiveExpression <bool>(() => left.Value || right.Value);
leftOrRight.Subscribe(getValue => Console.WriteLine("leftOrRight = " + getValue())); // Prints 'leftOrRight = False'
right.Value = true; // Prints 'leftOrRight = True'
left.Value = true; // Prints 'leftOrRight = True'
right.Value = false; // Prints nothing
}
public void TestWeakStrongExpression()
{
var listener = new Listener();
var source = new ReactiveVariable <int>(3);
var listenerValue = ReactiveManager.Evaluate(new CompositeReactiveObject(listener, "first"), () => source.Value);
Assert.AreEqual(source.Value, listenerValue);
var results = new List <object>();
listener.Notifications.Subscribe(result => results.Add(result));
source.Value++;
Assert.AreEqual("first", results[0]);
}
public void TestIndirectDiamondSituation2()
{
var input = new ReactiveVariable <int>();
var timesTwo = new DebugReactiveExpression <int>(() => input.Value * 2, "timesTwo");
var plusOne = new DebugReactiveExpression <int>(() => input.Value + 1, "plusOne");
var sumOfBoth = new DebugReactiveExpression <int>(() => timesTwo.Evaluate() + plusOne.Evaluate(), "sumOfBoth");
var counter = 0;
sumOfBoth.Subscribe(getValue => Const(getValue, () => counter++));
Assert.AreEqual(1, counter);
input.Value = 1;
Assert.AreEqual(2, counter);
input.Value = 2;
Assert.AreEqual(3, counter);
}
public void Cache()
{
var input = new ReactiveVariable <int>(2); //We define a reactive variable.
Func <int> f = () => //f is the calculation we want to cache.
{
Console.WriteLine("f was evaluated");
return(input.Value * input.Value); //f depends on our reactive variable input.
};
var cache = new ReactiveCache <int>(f); //We base our cache on f.
Console.WriteLine("f() = " + cache.Get()); //Cache was not set so we evaluate f.
Console.WriteLine("f() = " + cache.Get()); //Cache is set so we don't evaluate f.
input.Value = 3; //We change our input variable, causing our cache to become stale.
Console.WriteLine("f() = " + cache.Get()); //Cache is stale, so we must evaluate f.
}
