c# - Lazy<> 和 Task<> 可以组合起来推迟数据库查找吗？

Question

我在下面编写了我的问题的简化版本。所以我已经有了这个服务，并且在方法 DoSomething 中 - 我想执行同步检查( IsTrue() 方法)，然后执行 async > 调用(数据库查找)。

如果 syncResult 为 false，我只想进行数据库查找(EF6 异步选择 - 由 this.SuperSlowThing 模拟)。这可以通过使用 && 来完成，如果 syncResult 为 true，它只会继续到 asyncResult。

我的问题:这是解决这个问题的好方法吗？如果是这样，有没有更简单的方法来做到这一点？

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!");
    }
}

编辑

所以让我详细说明一下代码在现实生活中的作用。 DoSomething 方法实际上是一个数据库查找。如果 someValue 是 web.config 中存在的某个数字 - 则对表 A 中的数字进行数据库查找。这是同步操作。

如果在表 A 中找到结果，则返回该结果，否则在表 B 中查找该数字。

如果在 web.config 中找不到 someValue 的数量 - 立即在表 B 中查找。

Answer 1

我认为没有真正的理由在这里使用Lazy。您可以先检查 syncResult，然后检查 asyncResult:

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

或者更好、更易读的版本:

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 在多线程情况下，或者在您不完全确定是否/何时使用它的情况下非常有用。在您的情况下，您确实知道是否在该方法的范围内使用它，因此使用 Lazy 只会使事情变得复杂。