public async Task SuppressTest()
{
var time = Services.GetRequiredService <ITimeService>();
var count1 = 0;
var count2 = 0;
#pragma warning disable 1998
var c1 = await SimpleComputed.New <int>(async (prev, cancellationToken) => count1++)
.UpdateAsync(false);
var c2 = await SimpleComputed.New <int>(async (prev, cancellationToken) => count2++)
.UpdateAsync(false);
#pragma warning restore 1998
var c12 = await SimpleComputed.New <(int, int)>(
async (prev, cancellationToken) => {
var a = await c1.UseAsync(cancellationToken);
using var _ = Computed.Suppress();
var b = await c2.UseAsync(cancellationToken);
return(a, b);
}).UpdateAsync(false);
var v12a = await c12.UseAsync();
c1.Invalidate(); // Should increment c1 & impact c12
var v12b = await c12.UseAsync();
v12b.Should().Be((v12a.Item1 + 1, v12a.Item2));
c2.Invalidate(); // Should increment c2, but shouldn't impact c12
var v12c = await c12.UseAsync();
v12c.Should().Be(v12b);
}
public static async Task Dependencies()
{
#region part02_dependencies
WriteLine("Creating computed instances...");
var cDate = SimpleComputed.New <DateTime>(async(prev, ct) => {
var result = DateTime.Now;
WriteLine($"Computing cDate: {result}");
return(result);
});
var cCount = SimpleComputed.New <int>(async(prev, ct) => {
var result = prev.Value + 1;
WriteLine($"Computing cCount: {result}");
return(result);
});
var cTitle = SimpleComputed.New <string>(async(prev, ct) => {
var date = await cDate.UseAsync(ct);
var count = await cCount.UseAsync(ct);
var result = $"{date}: {count}";
WriteLine($"Computing cTitle: {result}");
return(result);
});
WriteLine("All the computed values below should be in invalidated state.");
WriteLine($"{cDate}, Value = {cDate.Value}");
WriteLine($"{cCount}, Value = {cCount.Value}");
WriteLine($"{cTitle}, Value = {cTitle.Value}");
WriteLine();
WriteLine("Let's trigger the computations:");
cTitle = await cTitle.UpdateAsync(false);
WriteLine($"{cDate}, Value = {cDate.Value}");
WriteLine($"{cCount}, Value = {cCount.Value}");
WriteLine($"{cTitle}, Value = {cTitle.Value}");
WriteLine();
WriteLine($"The next line won't trigger the computation, even though {nameof(cCount)} will be updated:");
cCount = await cCount.UpdateAsync(false);
WriteLine($"Let's do the same for {nameof(cDate)} now:");
cDate = await cDate.UpdateAsync(false);
WriteLine();
WriteLine($"Let's invalidate {nameof(cCount)} and see what happens:");
cCount.Invalidate();
WriteLine($"{cCount}, Value = {cCount.Value}");
WriteLine($"As you see, no computation is triggered so far.");
WriteLine($"But notice that {nameof(cTitle)} is invalidated as well, because it depends on {nameof(cCount)}:");
WriteLine($"{cTitle}, Value = {cTitle.Value}");
WriteLine($"Finally, let's update {nameof(cTitle)} again:");
cTitle = await cTitle.UpdateAsync(false);
WriteLine($"{cTitle}, Value = {cTitle.Value}");
#endregion
}
public static async Task CreateNoDefault()
{
#region part01_createNoDefault
var c = SimpleComputed.New <DateTime>(async(prev, ct) => DateTime.Now);
WriteLine($"{c}, Value = {c.Value}"); // Must be in Invalidated state
c = await c.UpdateAsync(false);
WriteLine($"{c}, Value = {c.Value}"); // Must be in Consistent state
#endregion
}
public static async Task Create()
{
#region part01_create
// Later we'll show you much nicer ways to create IComputed instances,
// but for now let's stick to the basics:
var c = SimpleComputed.New(async(prev, ct) => prev.Value + 1, Result.New(1));
WriteLine($"{c}, Value = {c.Value}");
WriteLine($"Properties:");
WriteLine($"{nameof(c.Value)}: {c.Value}");
WriteLine($"{nameof(c.Error)}: {c.Error}");
WriteLine($"{nameof(c.Output)}: {c.Output}");
WriteLine($"{nameof(c.State)}: {c.State}");
WriteLine($"{nameof(c.LTag)}: {c.LTag}"); // It is similar to ETag in HTTP
#endregion
}
public static async Task InvalidateAndUpdate()
{
#region part01_invalidateAndUpdate
var c = SimpleComputed.New(async(prev, ct) => prev.Value + 1, Result.New(1));
c.Invalidate();
WriteLine($"{c}, Value = {c.Value}"); // Must be in Invalidated state
var c1 = await c.UpdateAsync(false);
WriteLine($"{c1}, Value = {c1.Value}"); // Must be in Consistent state
// Equality isn't overriden for any implementation of IComputed,
// so it relies on default Equals & GetHashCode (by-ref comparison).
WriteLine($"Are {nameof(c)} and {nameof(c1)} pointing to the same instance? {c == c1}");
#endregion
}