C#中的Lazy如何使用详解

在C#中，我们经常会遇到需要延迟加载的情况，例如需要从数据库中加载数据，或者需要进行复杂的计算。此时，我们可以使用Lazy类实现延迟加载。本篇文章将详细介绍如何使用Lazy类。

什么是Lazy

Lazy是一个泛型类，可以用于在需要时延迟创建对象或计算结果。Lazy的Value属性用于获取Lazy实例所表示的值。当第一次调用Value属性时，Lazy会执行指定的工厂方法来创建或计算结果，并将结果赋给Value属性。同时，Lazy也提供了一些属性和方法，用于控制延迟加载的行为。

如何使用Lazy

下面是Lazy的基本用法：

var lazyValue = new Lazy<int>(() => ComputeResult());
int result = lazyValue.Value;

Lazy的构造函数需要一个工厂方法作为参数。此工厂方法将在第一次调用Value属性时执行，用于创建对象或计算结果。在示例中，我们使用lambda表达式定义了工厂方法。

当我们第一次调用lazyValue.Value时，Lazy将执行ComputeResult方法并将结果赋给Value属性。下一次调用lazyValue.Value时，将直接返回上次计算的结果，而不会再次执行工厂方法。

Lazy的属性和方法

Lazy提供了一些属性和方法，用于控制延迟加载的行为。下面是一些常用的属性和方法：

IsValueCreated

IsValueCreated属性用于判断Lazy实例是否已经执行了工厂方法来创建或计算结果。如果已经创建或计算了结果，则返回true，否则返回false。

if (lazyValue.IsValueCreated)
{
    Console.WriteLine("Value has been created.");
}

Value

Value属性用于获取Lazy实例的值。如果Lazy实例的值还没有被创建或计算，则会执行工厂方法来创建或计算值。如果值已经被创建或计算，则直接返回上次计算的结果。

int result = lazyValue.Value;

ForceExecution

ForceExecution方法用于强制执行工厂方法来创建或计算结果。

lazyValue.ForceExecution();

ValueFactory

ValueFactory属性用于获取或设置Lazy实例的工厂方法。如果需要重新设置工厂方法，可以直接修改ValueFactory属性。

lazyValue.ValueFactory = () => ComputeResult();

多线程下的使用

Lazy是线程安全的，在多线程下也可以安全使用。如果在多线程下使用Lazy，则每个线程第一次调用Value属性时，都会执行一次工厂方法来创建或计算结果。为了控制多线程下Lazy的行为，可以使用LazyThreadSafetyMode枚举类型来设置线程安全模式。LazyThreadSafetyMode枚举类型有以下几个值：

• None：不使用任何线程安全措施。
• PublicationOnly：保证值是可见的，但不保证线程安全。
• ExecutionAndPublication：保证线程安全，并保证值是可见的。

下面是在多线程下使用Lazy的示例：

var lazyValue = new Lazy<int>(() => ComputeResult(), LazyThreadSafetyMode.ExecutionAndPublication);
int result = lazyValue.Value; // 第一个线程执行工厂方法
int result2 = lazyValue.Value; // 第二个线程可以直接返回上次计算的结果

示例说明

示例一

假设我们需要在程序启动时初始化一些资源，此时可以使用Lazy来延迟加载。下面的示例中，ResourceLoader类负责加载资源。我们可以使用Lazy来实现延迟加载。

public class ResourceLoader
{
    public ResourceLoader()
    {
        // 加载资源
        LoadResource();
    }

    public void LoadResource()
    {
        Console.WriteLine("Loading resource...");
    }
}

// 在程序启动时初始化资源
var resourceLoader = new Lazy<ResourceLoader>();

当我们第一次调用resourceLoader.Value时，ResourceLoader的构造函数将被执行，并会输出"Loading resource..."。

示例二

假设我们需要计算一个数的平方根。如果对于每个数都直接计算平方根，将会非常耗时。此时可以使用Lazy来缓存已经计算的结果，避免重复计算。

Dictionary<double, Lazy<double>> sqrtCache = new Dictionary<double, Lazy<double>>();

public double Sqrt(double number)
{
    if (!sqrtCache.ContainsKey(number))
    {
        // 如果缓存中没有，则创建一个Lazy<double>实例，并将结果缓存起来
        sqrtCache[number] = new Lazy<double>(() => Math.Sqrt(number));
    }

    return sqrtCache[number].Value; // 返回计算结果
}

在上面的示例中，我们使用一个Dictionary来缓存已经计算的结果。每次调用Sqrt方法时，都会先查看缓存中是否已经存在对应的结果。如果缓存中没有，则创建一个Lazy实例，并将工厂方法设置为计算平方根。下次调用Sqrt方法时，将直接返回上次计算的结果，而不会再次计算平方根。