Can Lazy<> and Task<> be combined to defer database lookup?

Question

I've coded a simplified version of my problem below. So I've got this service and in the method DoSomething - I want to do a synchronous check ( IsTrue() method ) followed by an async call ( database lookup ).

I only want to do the database lookup (EF6 async select - simulated by this.SuperSlowThing ) if the syncResult is false. This can be done by using && which will only continue to asyncResult in case syncResult is true.

My question: is this a good solution for this problem? If so, is there an easier way to do this?

internal class MyService
{
    public void DoSomething(bool someValue)
    {
        var syncResult = this.IsTrue(someValue);
        var asyncResult = new Lazy<Task<string>>(this.SuperSlowThing);

        if (syncResult && asyncResult.Value.Result.Length > 0)
        {
            Console.WriteLine("Did SuperSlowThing - result is " + asyncResult.Value.Result);
        }
        else
        {
            Console.WriteLine("Didn't do SuperSlowThing");
        }            
    }

    private bool IsTrue(bool someValue)
    {
        return someValue;
    }

    private Task<string> SuperSlowThing()
    {
        var sw = System.Diagnostics.Stopwatch.StartNew();

        while (sw.ElapsedMilliseconds < 5000)
        {
            Thread.Sleep(500);
            Console.WriteLine("Delaying");
        }

        return Task.FromResult("Done!");
    }
}

EDIT

So let me elaborate a bit on what the code does in real life. The DoSomething method is really a database lookup. If the someValue is some number that is present in the web.config - then do a database lookup of the number in table A. This is the synchronous operation.

If a result is then found in table A, return that, otherwise lookup the number in table B.

If the number of someValue was not found in web.config - do the lookup in table B immediately.

Answer 1

I see no real reason to use Lazy here. You can just check the syncResult first and then the asyncResult:

public async Task DoSomething(bool someValue)
{
    if (IsTrue(someValue) && await SuperSlowThing().Length > 0)
    {
       // ..
    }
    else
    {
       // ..
    }            
}

Or an even better, more readable version:

public async Task DoSomething(bool someValue)
{
    bool condition = false;

    if (IsTrue(someValue))
    {
        var result = await SuperSlowThing();
        if (result.Length > 0)
        {
            Console.Writeline(result);
        }
        condition = true;
    }

    if (!condition)
    {
        // ..
    }
}

Lazy is useful in multi-threaded cases, or where you're not completely sure if/when you'll use it or not. In your case you do know whether you use it in the scope of that method, so using Lazy only complicates things.

Answer 2

Yes, a Lazy is appropriate for such cases. Your sample code is fine in principle. It has a problem in that it uses .Result instead of await. But that is just a detail immaterial to this discussion.

If you want to avoid using Lazy here, let me suggest an alternative:

string slowResult;
if (IsTrue(someValue) && (slowResult = await SuperSlowThing()).Length > 0)
{
   Console.WriteLine(slowResult);
}

Notice, that you can access slowResult multiple times without re-executing SuperSlowThing. This is what you were using Lazy for.

C# 6 will even let you declare a variable inline:

if (IsTrue(someValue) && (var slowResult = await SuperSlowThing()).Length > 0)

(At least that's how I think it's going to be.)

If you find the nested assignment confusing (which is understandable):

if (IsTrue(someValue))
{
   string slowResult = await SuperSlowThing();
   if (slowResult.Length > 0)
     Console.WriteLine(slowResult);
}

Thanks to await this problem is really the same that you would have with synchronous code. This is not about async or Task. Whether you write await SuperSlowThingAsync() or SuperSlowThing makes no difference to the logical flow of the method. Disregard asynchrony in your thinking.

Answer 3

If so, is there an easier way to do this?

What exactly does your solution achieve, that a simple if-construct would not?

var syncResult = this.IsTrue(someValue);

if (syncResult)
{
    var result = this.SuperSlowThing();
    Console.WriteLine("Did SuperSlowThing - result is " + result);
}
else
{
    Console.WriteLine("Didn't do SuperSlowThing");
}  

Answer 4

If your goal is to encapsulate an on-demand, asynchronously retrieved value, then a Lazy<Task<T>> is an appropriate abstraction. It's hard to tell from your question if that's what you really want though.

Consider these two:

var x = new Lazy<int>(
    () => Task.Run(
        () => ComputeValue()));
var y = Task.Run(
    () => ComputeValue());

where ComputeValue is some expensive function returning an int.

Then the value assigned to y will begin computing immediately. Everybody who waits on y is waiting on an already started Task.

The value assigned to x will only begin computing the first time somebody asks for the value, but everyone will still wait on the same computation once it is started.

Answer 5

Lazy has nothing to do with sync or async, it has to do with deferred execution. In your case, you're not deferring the execution at all. You're creating the Lazy parameter, and then accessing it right away (assuming your value is true). Just putting

if(condition)
{
  var = await SuperSlowThing()
}

will give you the desired functionality.