C# .NET Core 延遲加載深度實戰：兩種技術手段讓你的應用性能飛起來
作者：iamrick
延遲加載（Lazy Loading）是一種智能資源管理模式，核心思想是"用時再加載"。想象一下，你在看新聞App時，并不需要一次性加載所有文章內容，而是滑動到哪里加載到哪里。這就是延遲加載的精髓。
在現代C#開發中，性能優化已經成為高級開發者必備技能。今天我們來深入探討延遲加載這一重要設計模式，它能幫助你的應用程序在處理大量數據時保持高效運行。
什么是延遲加載？
延遲加載（Lazy Loading）是一種智能資源管理模式，核心思想是"用時再加載"。想象一下，你在看新聞App時，并不需要一次性加載所有文章內容，而是滑動到哪里加載到哪里。這就是延遲加載的精髓。
延遲加載的4大優勢
- 內存友好避免一次性加載大量數據造成內存壓力
- 啟動更快應用程序初始化時間顯著減少
- 性能提升減少不必要的數據庫查詢和網絡請求
- 用戶體驗優化響應更加迅速，交互更流暢
實戰技術一：使用Lazy實現對象延遲初始化
Lazy<T>是.NET框架提供的內置延遲加載解決方案，使用簡單但功能強大。
完整示例：文件處理服務
namespace AppLazyLoading
{
/// <summary>
/// 模擬一個資源密集型的文件處理服務
/// </summary>
publicclass FileProcessingService
{
private readonly string _configPath;
public FileProcessingService(string configPath)
{
_configPath = configPath;
Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] FileProcessingService 開始初始化...");
// 模擬耗時的初始化過程：讀取配置、建立連接等
Thread.Sleep(3000);
Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] FileProcessingService 初始化完成！");
}
/// <summary>
/// 處理文件的核心方法
/// </summary>
public string ProcessFile(string fileName)
{
Console.WriteLine($"正在處理文件: {fileName}");
return $"文件 {fileName} 處理完成，大小：{new Random().Next(100, 1000)}KB";
}
}
/// <summary>
/// 主程序：演示延遲加載的效果
/// </summary>
class Program
{
// 使用 Lazy<T> 包裝服務，實現延遲初始化
// 線程安全的單例模式
privatestatic readonly Lazy<FileProcessingService> _lazyFileService =
new Lazy<FileProcessingService>(() =>
new FileProcessingService("config.xml"));
static void Main(string[] args)
{
Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] 程序啟動");
Console.WriteLine("================================");
// 程序啟動時，服務并未實例化
Console.WriteLine("程序已啟動，但文件服務尚未初始化");
// 模擬其他業務邏輯
Thread.Sleep(2000);
Console.WriteLine("\n現在需要使用文件服務...");
// 第一次訪問 Value 屬性時，才開始真正的初始化
var result = _lazyFileService.Value.ProcessFile("document.pdf");
Console.WriteLine($"處理結果: {result}");
// 再次使用時，不會重復初始化
Console.WriteLine("\n再次使用服務（無需重復初始化）:");
var result2 = _lazyFileService.Value.ProcessFile("image.jpg");
Console.WriteLine($"處理結果: {result2}");
Console.WriteLine($"\n[{DateTime.Now:HH:mm:ss}] 程序結束");
}
}
}
圖片
實戰技術二：自定義延遲加載容器
對于復雜業務場景，我們可以創建自定義的延遲加載容器：
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
namespace CustomLazyLoading
{
/// <summary>
/// 支持異步操作的延遲加載容器
/// </summary>
publicclass AsyncLazy<T>
{
private readonly Func<Task<T>> _taskFactory;
private readonly Lazy<Task<T>> _lazy;
public AsyncLazy(Func<Task<T>> taskFactory)
{
_taskFactory = taskFactory ?? thrownew ArgumentNullException(nameof(taskFactory));
_lazy = new Lazy<Task<T>>(taskFactory);
}
/// <summary>
/// 獲取異步任務
/// </summary>
public Task<T> Value => _lazy.Value;
/// <summary>
/// 檢查是否已經開始加載
/// </summary>
publicbool IsValueCreated => _lazy.IsValueCreated;
/// <summary>
/// 重置延遲加載狀態（重新創建Lazy實例）
/// </summary>
public void Reset()
{
if (_lazy.IsValueCreated)
{
// 這里需要重新創建一個新的AsyncLazy實例來實現真正的重置
// 或者可以考慮其他設計模式
}
}
}
/// <summary>
/// 支持取消的異步延遲加載容器
/// </summary>
publicclass CancellableAsyncLazy<T>
{
private readonly Func<CancellationToken, Task<T>> _taskFactory;
private readonly object _lock = new object();
private Task<T> _task;
public CancellableAsyncLazy(Func<CancellationToken, Task<T>> taskFactory)
{
_taskFactory = taskFactory ?? thrownew ArgumentNullException(nameof(taskFactory));
}
public Task<T> GetValue(CancellationToken cancellationToken = default)
{
if (_task != null)
return _task;
lock (_lock)
{
if (_task == null)
{
_task = _taskFactory(cancellationToken);
}
return _task;
}
}
publicbool IsValueCreated => _task != null;
public void Reset()
{
lock (_lock)
{
_task = null;
}
}
}
/// <summary>
/// 使用示例：異步數據服務
/// </summary>
publicclass DataService
{
private readonly AsyncLazy<string> _lazyData;
private readonly AsyncLazy<List<User>> _lazyUsers;
private readonly CancellableAsyncLazy<string> _cancellableLazyConfig;
public DataService()
{
// 延遲加載異步數據
_lazyData = new AsyncLazy<string>(LoadDataAsync);
// 延遲加載用戶列表
_lazyUsers = new AsyncLazy<List<User>>(LoadUsersAsync);
// 支持取消的延遲加載配置
_cancellableLazyConfig = new CancellableAsyncLazy<string>(LoadConfigAsync);
}
/// <summary>
/// 模擬異步數據加載（如API調用、文件讀取等）
/// </summary>
private async Task<string> LoadDataAsync()
{
Console.WriteLine("開始異步加載數據...");
// 模擬網絡請求或文件I/O
await Task.Delay(2000);
Console.WriteLine("數據加載完成！");
return"這是從遠程API獲取的重要數據";
}
/// <summary>
/// 模擬加載用戶列表
/// </summary>
private async Task<List<User>> LoadUsersAsync()
{
Console.WriteLine("開始加載用戶列表...");
await Task.Delay(1500);
var users = new List<User>
{
new User { Id = 1, Name = "張三", Email = "zhangsan@example.com" },
new User { Id = 2, Name = "李四", Email = "lisi@example.com" },
new User { Id = 3, Name = "王五", Email = "wangwu@example.com" }
};
Console.WriteLine($"用戶列表加載完成，共{users.Count}個用戶");
return users;
}
/// <summary>
/// 支持取消的配置加載
/// </summary>
private async Task<string> LoadConfigAsync(CancellationToken cancellationToken)
{
Console.WriteLine("開始加載配置...");
// 模擬長時間的配置加載過程
for (int i = 0; i < 10; i++)
{
cancellationToken.ThrowIfCancellationRequested();
await Task.Delay(300, cancellationToken);
Console.WriteLine($"配置加載進度: {(i + 1) * 10}%");
}
Console.WriteLine("配置加載完成！");
return"重要的系統配置數據";
}
/// <summary>
/// 獲取數據
/// </summary>
public async Task<string> GetDataAsync()
{
return await _lazyData.Value;
}
/// <summary>
/// 獲取用戶列表
/// </summary>
public async Task<List<User>> GetUsersAsync()
{
return await _lazyUsers.Value;
}
/// <summary>
/// 獲取配置（支持取消）
/// </summary>
public async Task<string> GetConfigAsync(CancellationToken cancellationToken = default)
{
return await _cancellableLazyConfig.GetValue(cancellationToken);
}
/// <summary>
/// 檢查數據是否已加載
/// </summary>
publicbool IsDataLoaded => _lazyData.IsValueCreated;
/// <summary>
/// 檢查用戶列表是否已加載
/// </summary>
publicbool IsUsersLoaded => _lazyUsers.IsValueCreated;
/// <summary>
/// 檢查配置是否已加載
/// </summary>
publicbool IsConfigLoaded => _cancellableLazyConfig.IsValueCreated;
/// <summary>
/// 重置配置加載狀態
/// </summary>
public void ResetConfig()
{
_cancellableLazyConfig.Reset();
Console.WriteLine("配置加載狀態已重置");
}
}
/// <summary>
/// 用戶模型
/// </summary>
publicclass User
{
publicint Id { get; set; }
publicstring Name { get; set; }
publicstring Email { get; set; }
public override string ToString()
{
return $"User(Id: {Id}, Name: {Name}, Email: {Email})";
}
}
/// <summary>
/// 高級異步延遲加載示例：緩存服務
/// </summary>
publicclass CacheService
{
private readonly Dictionary<string, AsyncLazy<object>> _cache = new();
private readonly object _lock = new object();
/// <summary>
/// 獲取或創建緩存項
/// </summary>
public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> factory)
{
AsyncLazy<object> lazy;
lock (_lock)
{
if (!_cache.TryGetValue(key, out lazy))
{
lazy = new AsyncLazy<object>(async () => await factory());
_cache[key] = lazy;
}
}
var result = await lazy.Value;
return (T)result;
}
/// <summary>
/// 檢查緩存項是否存在且已加載
/// </summary>
public bool IsLoaded(string key)
{
lock (_lock)
{
return _cache.TryGetValue(key, out var lazy) && lazy.IsValueCreated;
}
}
/// <summary>
/// 移除緩存項
/// </summary>
public void Remove(string key)
{
lock (_lock)
{
_cache.Remove(key);
}
}
/// <summary>
/// 清空所有緩存
/// </summary>
public void Clear()
{
lock (_lock)
{
_cache.Clear();
}
}
}
/// <summary>
/// 程序入口點，演示各種用法
/// </summary>
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine("=== 異步延遲加載示例 ===\n");
// 1. 基本用法演示
await BasicUsageDemo();
Console.WriteLine("\n" + newstring('=', 50) + "\n");
// 2. 取消操作演示
await CancellationDemo();
Console.WriteLine("\n" + newstring('=', 50) + "\n");
// 3. 緩存服務演示
await CacheServiceDemo();
Console.WriteLine("\n程序執行完成，按任意鍵退出...");
Console.ReadKey();
}
/// <summary>
/// 基本用法演示
/// </summary>
static async Task BasicUsageDemo()
{
Console.WriteLine("1. 基本用法演示");
Console.WriteLine("================");
var dataService = new DataService();
// 檢查初始狀態
Console.WriteLine($"數據加載狀態: {dataService.IsDataLoaded}");
Console.WriteLine($"用戶列表加載狀態: {dataService.IsUsersLoaded}");
// 并發獲取數據 - 方法1：分別等待
var dataTask = dataService.GetDataAsync();
var usersTask = dataService.GetUsersAsync();
// 等待所有任務完成
await Task.WhenAll(dataTask, usersTask);
// 獲取結果
var data = await dataTask;
var users = await usersTask;
Console.WriteLine($"\n獲取到的數據: {data}");
Console.WriteLine($"用戶列表:");
foreach (var user in users)
{
Console.WriteLine($" - {user}");
}
// 再次檢查狀態
Console.WriteLine($"\n數據加載狀態: {dataService.IsDataLoaded}");
Console.WriteLine($"用戶列表加載狀態: {dataService.IsUsersLoaded}");
// 第二次調用應該立即返回緩存的結果
Console.WriteLine("\n第二次調用（應該立即返回）:");
var cachedData = await dataService.GetDataAsync();
Console.WriteLine($"緩存的數據: {cachedData}");
}
/// <summary>
/// 取消操作演示
/// </summary>
static async Task CancellationDemo()
{
Console.WriteLine("2. 取消操作演示");
Console.WriteLine("================");
var dataService = new DataService();
// 創建取消令牌
using var cts = new CancellationTokenSource();
// 3秒后自動取消
cts.CancelAfter(TimeSpan.FromSeconds(3));
try
{
Console.WriteLine("開始加載配置（3秒后自動取消）...");
var config = await dataService.GetConfigAsync(cts.Token);
Console.WriteLine($"獲取到配置: {config}");
}
catch (OperationCanceledException)
{
Console.WriteLine("配置加載被取消");
}
// 重置并重新嘗試
Console.WriteLine("\n重置配置加載狀態并重新嘗試...");
dataService.ResetConfig();
try
{
var config = await dataService.GetConfigAsync();
Console.WriteLine($"重新獲取的配置: {config}");
}
catch (Exception ex)
{
Console.WriteLine($"配置加載失敗: {ex.Message}");
}
}
/// <summary>
/// 緩存服務演示
/// </summary>
static async Task CacheServiceDemo()
{
Console.WriteLine("3. 緩存服務演示");
Console.WriteLine("================");
var cacheService = new CacheService();
// 定義一些異步工廠方法
Func<Task<string>> expensiveOperation1 = async () =>
{
Console.WriteLine("執行昂貴操作1...");
await Task.Delay(1000);
return"昂貴操作1的結果";
};
Func<Task<int>> expensiveOperation2 = async () =>
{
Console.WriteLine("執行昂貴操作2...");
await Task.Delay(800);
return42;
};
// 第一次調用 - 應該執行實際操作
Console.WriteLine("第一次調用緩存操作:");
var result1 = await cacheService.GetOrCreateAsync("key1", expensiveOperation1);
var result2 = await cacheService.GetOrCreateAsync("key2", expensiveOperation2);
Console.WriteLine($"結果1: {result1}");
Console.WriteLine($"結果2: {result2}");
// 檢查緩存狀態
Console.WriteLine($"\nkey1緩存狀態: {cacheService.IsLoaded("key1")}");
Console.WriteLine($"key2緩存狀態: {cacheService.IsLoaded("key2")}");
// 第二次調用 - 應該直接返回緩存結果
Console.WriteLine("\n第二次調用（應該直接返回緩存）:");
var cachedResult1 = await cacheService.GetOrCreateAsync("key1", expensiveOperation1);
var cachedResult2 = await cacheService.GetOrCreateAsync("key2", expensiveOperation2);
Console.WriteLine($"緩存結果1: {cachedResult1}");
Console.WriteLine($"緩存結果2: {cachedResult2}");
// 清空緩存
Console.WriteLine("\n清空緩存并重新調用:");
cacheService.Clear();
var newResult = await cacheService.GetOrCreateAsync("key1", expensiveOperation1);
Console.WriteLine($"清空緩存后的新結果: {newResult}");
}
}
}
圖片
總結
延遲加載是C# .NET Core開發中的重要性能優化技術，掌握以下要點：
- Lazy 適用于對象延遲初始化
- EF Core延遲加載 適用于數據訪問優化
- 自定義容器 適用于復雜異步場景
- 避免N+1查詢，注意線程安全
- 根據具體場景選擇最適合的策略
合理運用延遲加載，能讓你的應用程序在處理大規模數據時依然保持出色的性能表現。
責任編輯：武曉燕
來源：
技術老小子
