.NET C# 中的单例模式缓存

一. 概述

在企业开发中，缓存是一个常见且重要的功能。本文将介绍如何使用C#实现单例设计模式，并通过单例模式实现缓存功能。单例模式确保整个应用中只有一个缓存实例，可以对缓存进行统一管理和访问。通过本文的示例，我们将实现以下缓存操作：

• 添加元素到缓存
• 更新缓存中的元素
• 从缓存中检索元素
• 删除缓存中的特定元素
• 清空整个缓存

二. 创建缓存接口

首先，我们需要定义一个缓存接口，来声明缓存的基本操作。接口ICacheService定义了五个基本方法：添加、更新、获取、删除和清空缓存。

// 定义缓存服务接口，声明缓存的操作
public interface ICacheService
{
    // 添加键值对到缓存，返回是否添加成功
    bool Add(object key, object value);

    // 添加或更新缓存中的键值对，返回是否操作成功
    bool AddOrUpdate(object key, object value);

    // 根据键从缓存中获取值，返回获取的值
    object Get(object key);

    // 从缓存中移除指定的键值对，返回是否移除成功
    bool Remove(object key);

    // 清空缓存中的所有键值对
    void Clear();
}

三. 实现单例缓存类

接下来，创建一个名为CacheService的类，该类实现了ICacheService接口，并使用线程安全的ConcurrentDictionary来存储缓存数据。此类采用单例设计模式，确保整个应用程序中只有一个缓存实例。

// 定义缓存服务类，使用单例模式并实现ICacheService接口
public sealed class CacheService : ICacheService
{
    // 使用线程安全的ConcurrentDictionary来存储缓存数据
    private ConcurrentDictionary<object, object> _concurrentDictionary = new();

    // 定义静态的单例实例
    private static readonly CacheService _cacheService = new();

    // 通过静态方法获取单例实例，确保线程安全
    public static CacheService GetInstance()
    {
        return _cacheService; // 返回单例实例
    }

    // 构造函数私有化，防止外部实例化
    private CacheService()
    {
        Console.WriteLine("单例缓存实例已创建.");
    }

    // 实现Add方法，向缓存中添加键值对
    public bool Add(object key, object value)
    {
        return _concurrentDictionary.TryAdd(key, value); // 如果键已存在则返回false
    }

    // 实现AddOrUpdate方法，添加或更新缓存中的键值对
    public bool AddOrUpdate(object key, object value)
    {
        // 如果键存在，先移除旧的键值对，再添加新的
        if (_concurrentDictionary.ContainsKey(key))
        {
            _concurrentDictionary.TryRemove(key, out _);
        }
        return _concurrentDictionary.TryAdd(key, value); // 添加新的键值对
    }

    // 实现Get方法，获取指定键的值
    public object Get(object key)
    {
        return _concurrentDictionary.ContainsKey(key) ? _concurrentDictionary[key] : null;
    }

    // 实现Remove方法，移除指定的键值对
    public bool Remove(object key)
    {
        return _concurrentDictionary.TryRemove(key, out _); // 移除成功返回true
    }

    // 实现Clear方法，清空缓存中的所有键值对
    public void Clear()
    {
        _concurrentDictionary.Clear(); // 清空ConcurrentDictionary
    }
}

代码解析

• Add方法：如果键不存在于缓存中，则添加键值对，成功返回true，否则返回false。
• AddOrUpdate方法：如果键已存在，则更新键对应的值；否则添加新的键值对。
• Get方法：根据键从缓存中获取值，如果键不存在则返回null。
• Remove方法：从缓存中移除指定的键值对，成功移除返回true，否则返回false。
• Clear方法：清空缓存中的所有键值对。

四. 在客户端代码中使用缓存

接下来，我们将在客户端代码中演示如何使用CacheService类进行缓存操作。以下代码展示了如何添加、更新、获取和删除缓存中的数据。

// 定义缓存中的键
const string ID = "Id";
const string NAME = "Name";

// 获取单例缓存实例
CacheService cache = CacheService.GetInstance();

// 使用Add和AddOrUpdate方法将键值对添加到缓存中
Console.WriteLine("将键值对添加到缓存中");
Console.WriteLine($"添加Id到缓存: {cache.Add(ID, 1)}");
Console.WriteLine($"添加Name到缓存: {cache.Add(NAME, "张三")}");

// 尝试再次添加相同的Id键，验证是否会覆盖
Console.WriteLine($"再次添加相同的Id键: {cache.Add(ID, 100)}");

// 使用AddOrUpdate方法更新缓存中的Id键
Console.WriteLine($"更新Id键的值: {cache.AddOrUpdate(ID, 100)}");

// 使用Get方法获取缓存中的值
Console.WriteLine("\n从缓存中获取值");
Console.WriteLine($"获取Id的值: {cache.Get(ID)}");
Console.WriteLine($"获取Name的值: {cache.Get(NAME)}");

// 使用Remove方法移除缓存中的Id键
Console.WriteLine("\n从缓存中移除Id");
Console.WriteLine($"移除Id键: {cache.Remove(ID)}");
Console.WriteLine($"再次尝试获取已移除的Id键: {cache.Get(ID)}");

// 清空缓存中的所有键值对
cache.Clear();
Console.WriteLine("\n清空所有缓存");
Console.WriteLine($"尝试获取已清空的Name键: {cache.Get(NAME)}");

输出结果

单例缓存实例已创建.
将键值对添加到缓存中
添加Id到缓存: True
添加Name到缓存: True
再次添加相同的Id键: False
更新Id键的值: True

从缓存中获取值
获取Id的值: 100
获取Name的值: 张三

从缓存中移除Id
移除Id键: True
再次尝试获取已移除的Id键: null

清空所有缓存
尝试获取已清空的Name键: null

五. 结论

通过本文，我们学习了如何使用C#实现单例设计模式进行缓存操作。单例模式确保缓存实例的唯一性，而ConcurrentDictionary确保了缓存操作的线程安全性。这种方式能够有效管理缓存，并且避免了多线程环境下的竞争条件问题。在实际应用中，这种方式是实现轻量级缓存功能的理想选择。