缓存属性 vs Lazy<T>

Question

在 .NET 4 中，也可以使用 System.Lazy<T> 类编写以下带有缓存属性的 sn-p。我测量了这两种方法的性能，结果几乎相同。为什么我应该使用一个而不是另一个有什么真正的好处或魔法？

缓存属性

public static class Brushes
{
    private static LinearGradientBrush _myBrush;

    public static LinearGradientBrush MyBrush
    {
        get
        {
            if (_myBrush == null)
            {
                var linearGradientBrush = new LinearGradientBrush { ...};
                linearGradientBrush.GradientStops.Add( ... );
                linearGradientBrush.GradientStops.Add( ... );

                _myBrush = linearGradientBrush;
            }

            return _myBrush;
        }
    }
}

懒惰

public static class Brushes
{
    private static readonly Lazy<LinearGradientBrush> _myBrush =
        new Lazy<LinearGradientBrush>(() =>
            {
                var linearGradientBrush = new LinearGradientBrush { ...};
                linearGradientBrush.GradientStops.Add( ... );
                linearGradientBrush.GradientStops.Add( ... );

                return linearGradientBrush;
            }
        );

    public static LinearGradientBrush MyBrush
    {
        get { return _myBrush.Value; }
    }
}

Answer 1

我一般会使用Lazy<T>：

• 它是线程安全的（在这种情况下可能不是问题，但在其他情况下会是问题）
• 仅通过名称就可以清楚地知道发生了什么
• 它允许 null 成为有效值

请注意，您必须为委托使用 lambda 表达式。例如，这是一种可能更简洁的方法：

public static class Brushes
{
    private static readonly Lazy<LinearGradientBrush> _myBrush =
        new Lazy<LinearGradientBrush>(CreateMyBrush);

    private static LinearGradientBrush CreateMyBrush()
    {
        var linearGradientBrush = new LinearGradientBrush { ...};
        linearGradientBrush.GradientStops.Add( ... );
        linearGradientBrush.GradientStops.Add( ... );

        return linearGradientBrush;
    }

    public static LinearGradientBrush MyBrush
    {
        get { return _myBrush.Value; }
    }
}

当创建过程因循环等而变得复杂时，这特别方便。请注意，从外观上看，您可以在创建代码中使用 GradientStops 的集合初始化程序。

另一种选择是不 懒惰地这样做，当然...除非你的类中有几个这样的属性，并且你只想一个一个地创建相关的对象，您可以在许多情况下依赖惰性类初始化。

正如 DoubleDown 的回答中指出的那样，无法重置它以强制重新计算（除非您将 Lazy<T> 字段设为非只读） - 但我很少发现这很重要。

Answer 2

使用Lazy<T>，因为它准确地表达了您在做什么 - 延迟加载。

此外，它使您的财产非常干净并且是线程安全的。

Answer 3

通常不使用惰性的唯一原因是将变量重置为空，以便下一次访问导致它再次加载。懒惰没有重置，您需要从头开始重新创建懒惰。

Answer 4

Lazy<T> 将正确处理并发场景（如果您传入正确的 LazyThreadSafetyMode ），而您的示例没有任何线程安全检查。

Answer 5

Lazy<T> 更简单——它清楚地表达了代码的意图。
它也是线程安全的。

请注意，如果您实际上是在多个线程上使用它，则需要将其设为[ThreadStatic]； GDI+ 对象不能跨线程共享。

Answer 6

Lazy 有一些同步开销来提供线程安全，而缓存属性在任何其他代码之前由 CLR 方式初始化，您不需要支付同步成本

从可测试性的角度来看，Lazy 是经过充分测试和证明的工件。

但是，在我看来，与其他选项相比，它的开销很小

Answer 7

好吧，如果您的性能大致相同，那么在缓存版本上使用 Lazy<T> 的唯一原因是您不确定用户是否真的要加载该属性。

Lazy<T> 的要点是等到用户需要资源，然后及时在那个实例上创建它。如果他们总是需要资源，那么使用Lazy<T> 是没有意义的，除非您需要它的某些其他目的，例如线程安全。