System.Lazy 是 .NET Framework 4.0 引入（位于 System 命名空间）的泛型类，用于实现线程安全的延迟初始化（Lazy Initialization）。它确保一个昂贵的对象或资源只在第一次真正需要时才被创建，并且在多线程环境下保证初始化只发生一次。

• 核心特性：

  • 延迟计算：值的创建被推迟到第一次访问 .Value 属性时。
  • 线程安全：内置多种线程安全模式，默认情况下完全线程安全。
  • 异常缓存：如果初始化过程中抛出异常，后续访问会重复抛出同一个异常（不重复执行工厂方法）。
  • 值缓存：一旦初始化完成，后续所有访问都返回同一个实例（单例行为）。

• 适用场景：

  • 昂贵资源初始化（如数据库连接、大文件加载、复杂计算）。
  • 配置对象、单例模式（比双检查锁更安全简洁）。
  • 避免启动时不必要的开销（尤其在某些代码路径可能不使用该对象时）。

为什么使用 Lazy？

传统方式（如直接在字段初始化或手动双检查锁）存在明显缺陷：

• 提前初始化：无论是否使用，都会浪费系统资源。
• 手动锁：极易出错，可能导致死锁、竞争条件或 ABA 问题。
• 异常处理复杂：开发者需手动处理并缓存初始化时的异常，代码冗余且易错。

相比之下，Lazy 提供了卓越的性能优化与代码简洁性：

• 线程安全：由微软高度优化，采用无锁或轻量级锁实现，性能极高。
• 代码简洁：仅需一行代码即可取代复杂的双检查锁逻辑，降低维护成本。
• 防 ABA：内部使用复合状态结合 CAS 机制，彻底避免 ABA 问题，完美解决上述所有痛点。

如何使用 Lazy？

核心语法与属性

基础示例（默认构造）

using System;
using System.Threading;

// 模拟创建成本高的对象（如加载配置、连接数据库）
public class ExpensiveObject
{
    public ExpensiveObject()
    {
        Console.WriteLine("ExpensiveObject 开始初始化（耗时操作）...");
        Thread.Sleep(2000); // 模拟2秒耗时初始化
        Console.WriteLine("ExpensiveObject 初始化完成！");
    }

    public void DoWork() => Console.WriteLine("ExpensiveObject 执行业务逻辑...");
}

class LazyBasicDemo
{
    static void Main()
    {
        Console.WriteLine("程序启动，创建Lazy实例...");
        // 此时仅创建Lazy容器，ExpensiveObject并未实例化
        Lazy lazyObj = new Lazy();

        Console.WriteLine($"对象是否已创建：{lazyObj.IsValueCreated}"); // 输出：False

        // 首次访问Value：触发ExpensiveObject的构造函数
        Console.WriteLine("n=== 首次访问Value ===");
        lazyObj.Value.DoWork();
        Console.WriteLine($"对象是否已创建：{lazyObj.IsValueCreated}"); // 输出：True

        // 再次访问Value：直接返回已创建的实例，不再初始化
        Console.WriteLine("n=== 再次访问Value ===");
        lazyObj.Value.DoWork();
    }
}

输出结果：

深入理解 System.Lazy：C#.NET 延迟初始化与线程安全

基础用法与工厂方法

在 C# 中，System.Lazy 提供了简洁的延迟初始化机制。默认构造函数仅接受一个无参工厂方法，但在实际开发中，我们往往需要传递参数或执行复杂的初始化逻辑。此时，应使用接受 Func 委托的重载构造函数，该委托可以捕获外部变量或执行更复杂的计算逻辑。

自定义工厂方法（带参数初始化）

若对象需要传参或复杂初始化逻辑，使用 Func 工厂方法：

Lazy 的线程安全模式

Lazy 的关键特性是支持多线程场景，通过 LazyThreadSafetyMode 枚举控制线程安全行为。默认情况下，Lazy 是线程安全的，这意味着多个线程同时访问 Value 属性时，初始化逻辑只会被执行一次，且后续访问直接返回已初始化的实例，无需额外的锁操作，从而保证了高性能与数据一致性。

多线程场景下的行为验证

示例：多线程下的线程安全模式

输出结果

所有线程最终获取的 HashCode 完全相同，且仅触发一次初始化（证明单实例）：

高级应用场景

懒加载单例模式

Lazy 是 .NET 中实现线程安全、懒加载单例的最优方式：相比传统的双重检查锁定（Double-Checked Locking），Lazy 不仅代码更简洁，而且避免了手动管理锁带来的潜在死锁或性能瓶颈问题。它是 .NET 官方推荐的标准单例实现方案。

处理初始化异常

若 Lazy 的工厂方法抛出异常，后续访问 Value 会缓存并重新抛出同一异常。这意味着一旦初始化失败，Lazy 实例将处于“错误状态”，再次调用 Value 属性会直接抛出之前捕获的异常，而不会重新尝试初始化。开发者需通过 IsValueAvailable 属性判断是否初始化成功，或通过 Value 属性获取结果。

异步懒加载（伪 AsyncLazy）

虽然 Lazy 本身不支持异步初始化，但可以通过封装 Task 或使用第三方库（如 AsyncLazy）来实现异步懒加载。这在处理数据库连接、文件 IO 等耗时操作时尤为有用，允许在后台线程异步完成初始化，同时保持接口的同步访问特性。

支持刷新（Reset）的自定义包装

标准的 Lazy 实例一旦初始化便不可更改。若需支持重新初始化，可自定义包装类，内部维护一个 Lazy 实例，并提供 Reset 方法。该方法通过重新赋值内部 Lazy 实例来实现“刷新”效果，适用于缓存失效或配置变更场景。

与依赖注入结合（ASP.NET Core）

在 ASP.NET Core 中，Lazy 常与依赖注入（DI）容器结合使用。通过将 Lazy 注册为服务，可以在控制器或服务中按需获取实例，避免应用启动时加载所有重型依赖。这种方式不仅提升了启动速度，还优化了内存使用，特别适用于大型微服务架构。

配置文件加载

Lazy 也常用于配置文件的延迟加载。例如，在应用启动时并不立即读取大型 JSON 或 XML 配置文件，而是在首次访问配置数据时才触发读取操作。这有助于减少应用启动时间，并在配置未使用时节省内存资源。

Lazy vs 手动懒加载

手动实现线程安全的懒加载需要写双重检查锁定（易出错），而 Lazy 已封装所有逻辑：包括锁的获取、释放、状态检查以及异常处理。手动实现不仅代码冗长，还容易因锁粒度控制不当导致性能下降或死锁。Lazy 经过微软内部团队长期优化，其性能表现通常优于手动实现，且具备更好的可维护性。

Lazy 内部实现原理（简要）

Lazy 的内部实现依赖于底层的状态标记和锁机制。在 .NET Framework 和 .NET Core 中，它使用一个内部状态字段来跟踪初始化阶段（未初始化、初始化中、已初始化、错误）。当多个线程同时请求 Value 时，第一个线程会获取锁并执行工厂方法，其他线程则阻塞等待。一旦初始化完成，状态被更新，后续访问直接返回结果，无需再次加锁。这种设计确保了线程安全与高性能的平衡。

优点与缺点

最佳实践

• 优先使用 Lazy 替代手动双检查锁，以简化代码逻辑并减少出错概率。

• 始终使用默认线程安全模式，除非明确需要 PublicationOnly 以优化特定场景下的性能表现。

• 工厂方法应无副作用，尤其在 PublicationOnly 模式下，确保多次调用返回一致结果。

• 异常处理：捕获 .Value 抛出的异常，确保初始化失败时状态能正确回滚或记录。

• 不要在工厂方法中访问同一个 Lazy 实例，否则可能导致死锁或递归初始化错误。

总结

• System.Lazy 是 .NET 官方的延迟初始化工具，核心是首次访问 Value 时创建对象，提升程序启动速度和内存效率；

• 核心属性：Value（触发初始化）、IsValueCreated（判断是否已创建）；

• 线程安全模式需按需选择：单线程用 None，多线程高成本对象用默认的ExecutionAndPublication；

• 最优场景：创建成本高 / 不一定使用的对象、懒加载单例模式；

程序启动，创建Lazy实例...
对象是否已创建：False

=== 首次访问Value ===
ExpensiveObject 开始初始化（耗时操作）...
ExpensiveObject 初始化完成！
ExpensiveObject 执行业务逻辑...
对象是否已创建：True

=== 再次访问Value ===
ExpensiveObject 执行业务逻辑...

// 自定义带参数的对象构造
public class ConfigObject
{
    private string _configPath;
    public ConfigObject(string configPath)
    {
        _configPath = configPath;
        Console.WriteLine($"加载配置文件：{configPath}");
    }

    public string GetConfig() => $"配置内容（来自{_configPath}）";
}

class LazyFactoryDemo
{
    static void Main()
    {
        // 自定义工厂方法：创建ConfigObject并传入参数
        Lazy lazyConfig = new Lazy(() => 
        {
            Console.WriteLine("执行自定义工厂方法...");
            return new ConfigObject("appsettings.json");
        });

        Console.WriteLine("首次访问配置：");
        Console.WriteLine(lazyConfig.Value.GetConfig()); // 触发工厂方法
    }
}

class LazyThreadSafetyDemo
{
    // 默认模式：ExecutionAndPublication（加锁保证单实例）
    static Lazy lazySafeObj = new Lazy();

    static void AccessLazyObj()
    {
        Console.WriteLine($"线程{Thread.CurrentThread.ManagedThreadId} 尝试访问Value...");
        var obj = lazySafeObj.Value;
        Console.WriteLine($"线程{Thread.CurrentThread.ManagedThreadId} 获取对象HashCode：{obj.GetHashCode()}");
    }

    static void Main()
    {
        // 启动5个线程同时访问
        for (int i = 0; i < 5; i++)
        {
            new Thread(AccessLazyObj).Start();
        }
        Thread.Sleep(3000); // 等待所有线程完成
    }
}

线程3 尝试访问Value...
ExpensiveObject 开始初始化（耗时操作）...
线程4 尝试访问Value...
线程5 尝试访问Value...
线程6 尝试访问Value...
线程7 尝试访问Value...
ExpensiveObject 初始化完成！
线程3 获取对象HashCode：46104728
线程4 获取对象HashCode：46104728
线程5 获取对象HashCode：46104728
线程6 获取对象HashCode：46104728
线程7 获取对象HashCode：46104728

public sealed class LazySingleton
{
    // 私有静态Lazy实例：延迟初始化，默认线程安全
    private static readonly Lazy _lazyInstance = new Lazy(() => new LazySingleton());

    // 私有构造函数：禁止外部实例化
    private LazySingleton() 
    {
        Console.WriteLine("单例对象初始化...");
    }

    // 公共属性：首次访问时创建实例
    public static LazySingleton Instance => _lazyInstance.Value;

    public void DoBusiness() => Console.WriteLine("单例对象执行业务逻辑...");
}

// 使用
class SingletonDemo
{
    static void Main()
    {
        Console.WriteLine("程序启动，未访问单例...");
        // 首次访问Instance：触发单例初始化
        LazySingleton.Instance.DoBusiness();
        // 再次访问：直接返回已创建的实例
        LazySingleton.Instance.DoBusiness();
    }
}

Lazy lazyErrorObj = new Lazy(() =>
{
    throw new InvalidOperationException("初始化失败：配置文件不存在！");
});

try
{
    // 首次访问：抛出异常
    lazyErrorObj.Value.DoWork();
}
catch (AggregateException ex)
{
    Console.WriteLine($"初始化异常：{ex.InnerException.Message}");
}

try
{
    // 再次访问：仍抛出同一异常（异常被缓存）
    lazyErrorObj.Value.DoWork();
}
catch (AggregateException ex)
{
    Console.WriteLine($"再次访问异常：{ex.InnerException.Message}");
}

private readonly Lazy> _asyncResource = new(async () =>
{
    await Task.Delay(2000);
    return new ExpensiveObject();
});

public async Task GetResourceAsync() => await _asyncResource.Value;

public class RefreshableLazy<T>
{
    private Lazy _current;

    public RefreshableLazy(Func factory)
    {
        _current = new Lazy(factory);
    }

    public T Value => _current.Value;

    public void Refresh()
    {
        var factory = _current.Value; // 保留旧工厂？或传入新工厂
        _current = new Lazy(_current.Factory); // 重新创建
    }
}

services.AddSingleton();
services.AddSingleton>(provider => 
    new Lazy(provider.GetRequiredService));

public class AppConfig
{
    private static readonly Lazy _instance = 
        new Lazy(LoadConfiguration);
    
    public static AppConfig Instance => _instance.Value;
    
    public string ConnectionString { get; }
    public int Timeout { get; }
    
    private AppConfig(string config)
    {
        // 解析配置
    }
    
    private static AppConfig LoadConfiguration()
    {
        string configData = File.ReadAllText("config.json");
        return new AppConfig(configData);
    }
}

// 手动实现（线程安全，需双重检查+volatile）
private volatile ExpensiveObject _manualObj;
private readonly object _lockObj = new object();
public ExpensiveObject ManualObj
{
    get
    {
        if (_manualObj == null)
        {
            lock (_lockObj)
            {
                if (_manualObj == null)
                {
                    _manualObj = new ExpensiveObject();
                }
            }
        }
        return _manualObj;
    }
}

// Lazy实现（一行搞定，线程安全）
private readonly Lazy _lazyObj = new Lazy();
public ExpensiveObject LazyObj => _lazyObj.Value;