C# 简单的本地数据存储系统

原创 已于 2025-09-12 17:12:45 修改 · 1.8k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c#

于 2024-08-06 11:37:25 首次发布

目录

一、简介

二、实现效果

简单版（推荐）

旧版（仅参考）

三、接口的调用

1.添加键值对

2.读取键值对

3.添加数组

4.读取数组

5.数组追加数据

6.删除指定的key

7.删除指定key中指定的元素

结束

一、简介

在上位机开发中，经常会有数据需要长期保存，比如常见的配置文件，即使软件关闭，下次重新打开也不会受到影响，但也有些数据，不适合写到配置文件中，比如软件的操作记录，特殊的一些全局变量等，因此我写了一个简单的本地存储系统，将数据写到 Json 文件中，并让其和缓存中的变量保持一致。

我们需要实现下面的功能：

1.json 文件如果不存在，自动创建

2.对应路径文件夹如果不存在，自动创建

3.软件运行后，json 文件的数据要自动加载到变量中

4.软件中进行了添加，删除，任何数据改变都要同步到 json 文件中

5.保存数据的类型，目前设置为两种，键值对和数组

6.提供大部分场景对应的接口

二、实现效果

新建一个 .Net Framework 4.8 控制台项目，项目名随意，写代码之前，先添加一个插件

简单版（推荐）

简单版的用下面的代码就行了，简单而稳定

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;

/// <summary>
/// Json 配置文件管理
/// </summary>
internal class JsonConfigManager
{
    #region 字段

    //json 文件的路径 
    private string JsonPath = string.Empty;
    //数据列表 
    private Dictionary<string, JToken> DataDictionary = new Dictionary<string, JToken>();
    //锁 
    private object locks = new object();

    #endregion

    #region 数据处理
    
    /// <summary>
    /// 读取配置文件
    /// </summary>
    public void ReadConfig()
    {
        lock (locks)
        {
            if (string.IsNullOrEmpty(JsonPath))
            {
                Console.WriteLine("请在构造函数传入正确的文件路径");
                return;
            }

            string json = null;
            Dictionary<string, JToken> data = null;
            try
            {
                json = File.ReadAllText(JsonPath);
                data = JsonConvert.DeserializeObject<Dictionary<string, JToken>>(json);
            }
            catch (Exception ex)
            {
                Console.WriteLine("[配置文件管理]读取配置文件错误：{0}", ex.Message);
                return;
            }

            if (data != null)
                DataDictionary = data;
            else
               Console.WriteLine("[配置文件管理]未读取到配置文件的值");
        }
    }

    /// <summary>
    /// 获取配置文件 key 的值
    /// </summary>
    /// <typeparam name="T">key的类型</typeparam>
    /// <param name="key">key</param>
    /// <returns>p1.是否成功，p2.key的值，p3.错误</returns>
    public (bool, T, string) Get<T>(string key)
    {
        if (string.IsNullOrEmpty(JsonPath))
            return (false, default(T), "请在构造函数传入正确的文件路径");
        if (string.IsNullOrEmpty(key))
            return (false, default(T), "参数 key 不能为空");

        lock (locks)
        {
            if (!DataDictionary.TryGetValue(key, out JToken token))
                return (false, default(T), $"未找到 {key} 的值");

            T value;
            try
            {
                value = token.ToObject<T>();
            }
            catch (Exception ex)
            {
                return (false, default(T), $"转换值错误：{ex.Message}");
            }
            return (true, value, null);
        }
    }

    /// <summary>
    /// 获取配置文件 key 的值，若 key 不存在则保存
    /// </summary>
    /// <typeparam name="T">key的类型</typeparam>
    /// <param name="key">key</param>
    /// <param name="value">key的值，如key不存在则保存当前键值对</param>
    /// <returnsp1.是否成功，p2.key的值，p3.错误</returns>
    public (bool, T, string) GetAndSave<T>(string key, T value)
    {
        if (string.IsNullOrEmpty(JsonPath))
            return (false, default(T), "请在构造函数传入正确的文件路径");
        if (string.IsNullOrEmpty(key))
            return (false, default(T), "参数 key 不能为空");
        if (value == null)
            return (false, default(T), "参数 value 不能为空");

        lock (locks)
        {
            if (!DataDictionary.TryGetValue(key, out JToken token))
            {
                var tuple = Set(key, value);
                if (tuple.Item1)
                    return (true, value, null);
                else
                    return (false, default(T), tuple.Item2);
            }

            T value2;
            try
            {
                value2 = token.ToObject<T>();
            }
            catch (Exception ex)
            {
                return (false, default(T), $"转换值错误：{ex.Message}");
            }
            return (true, value2, null);
        }
    }

    /// <summary>
    /// 设置配置文件的值
    /// </summary>
    /// <typeparam name="T">key的类型</typeparam>
    /// <param name="key">key</param>
    /// <param name="value">key的值</param>
    /// <returns>p1.是否成功，p2.错误</returns>
    public (bool, string) Set<T>(string key, T value)
    {
        if (string.IsNullOrEmpty(JsonPath))
            return (false, "请在构造函数传入正确的文件路径");
        if (string.IsNullOrEmpty(key))
            return (false, "参数 key 不能为空");
        if (value == null)
            return (false, "参数 value 不能为空");

        lock (locks)
        {
            try
            {
                DataDictionary[key] = value != null ? JToken.FromObject(value) : JValue.CreateNull();
                string json = JsonConvert.SerializeObject(DataDictionary, Formatting.Indented);
                File.WriteAllText(JsonPath, json);
                return (true, null);
            }
            catch (Exception ex)
            {
                return (false, $"设置值错误：{ex.Message}");
            }
        }
    }

    #endregion

    #region 构造函数

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="jsonPath">配置文件的完整路径</param>
    public JsonConfigManager(string jsonPath)
    {
        if (string.IsNullOrEmpty(jsonPath))
        {
            Console.WriteLine("[配置文件管理]参数 jsonPath 不能为空");
            return;
        }
        if (!File.Exists(jsonPath))
        {
            Console.WriteLine("[配置文件管理]参数 jsonPath 文件路径不存在");
            return;
        }

        JsonPath = jsonPath;
        ReadConfig();
    }

    #endregion
}

这个怎么用我就不展示了，就几个方法，都是基础的东西，或者你直接复制代码问 AI 应该也是没问题的。

旧版（仅参考）

下面的代码是之前写的旧版的，功能虽然多一些，但整体没那么优雅，不知道有没有隐形的 bug

添加一个类 LocalStorage.cs

代码：

using LogManager;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;

/// <summary>
/// 简单的本地数据读写系统
/// </summary>
internal sealed class LocalStorage
{
    #region 字段

    //json 文件的路径 
    private string JsonPath = string.Empty;
    //数据列表 
    private Dictionary<string, JToken> DataDictionary = new Dictionary<string, JToken>();
    //锁 
    private readonly object locks = new object();

    #endregion

    #region 构造函数

    public LocalStorage(string path)
    {
        if (string.IsNullOrEmpty(path))
        {
            Debug.Error("参数 path 不能为空");
            return;
        }

        var suffix = Path.GetExtension(path);
        if (string.IsNullOrEmpty(suffix))
        {
            Debug.Error("[LocalStorage]路径必须包含文件名和扩展名");
            return;
        }

        JsonPath = path;
        ReadConfigData();
    }

    /// <summary>
    /// 读取配置文件
    /// </summary>
    public void ReadConfigData()
    {
        lock (locks)
        {
            try
            {
                EnsureFileExists();
                string json = File.ReadAllText(JsonPath);
                DataDictionary = JsonConvert.DeserializeObject<Dictionary<string, JToken>>(json)
                                 ?? new Dictionary<string, JToken>();
            }
            catch (Exception ex)
            {
                Debug.Log($"[LocalStorage]配置文件读取失败：{ex.Message}");
                DataDictionary = new Dictionary<string, JToken>();
            }
        }
    }

    #endregion

    #region 设置键值对

    /// <summary>
    /// 设置键值对的值，用来存储数字，重复设置会覆盖
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">key</param>
    /// <param name="value">值</param>
    public void SetValueNumber<T>(string key, T value) where T : struct
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            DataDictionary[key] = JToken.FromObject(value);
            SaveToLocal();
        }
    }

    /// <summary>
    /// 设置键值对的值，用来存储字符串，重复设置会覆盖
    /// </summary>
    /// <param name="key">key</param>
    public void SetValueString(string key, string value)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }
        if (string.IsNullOrEmpty(value))
        {
            Debug.Warning("[LocalStorage]参数 value 不能为空");
            return;
        }

        lock (locks)
        {
            DataDictionary[key] = JToken.FromObject(value);
            SaveToLocal();
        }
    }

    /// <summary>
    /// 设置键值对的值，用来存储类，重复设置会覆盖
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public void SetValueClass<T>(string key, T value) where T : class, IAllowedType
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            DataDictionary[key] = JToken.FromObject(value);
            SaveToLocal();
        }
    }

    #endregion

    #region 获取键值对

    /// <summary>
    /// 获取键值对
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">key</param>
    /// <returns></returns>
    public T GetValue<T>(string key)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return default(T);
        }

        lock (locks)
        {
            try
            {
                if (DataDictionary.TryGetValue(key, out var token))
                    return token.ToObject<T>();
                else
                    return default(T);
            }
            catch (Exception)
            {
                return default(T);
            }
        }
    }

    /// <summary>
    /// 获取键值对
    /// </summary>
    /// <param name="key">key</param>
    /// <param name="type">反射类型</param>
    /// <returns></returns>
    public object GetValue(string key, Type type)
    {
        if (type == null)
        {
            Debug.Warning("[LocalStorage]参数 type 不能为空");
            return null;
        }
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return null;
        }

        lock (locks)
        {
            try
            {
                if (DataDictionary.ContainsKey(key))
                    return DataDictionary[key].ToObject(type);
                else
                    return null;
            }
            catch (Exception)
            {
                return null;
            }
        }
    }

    /// <summary>
    /// 尝试获取键值对
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">key</param>
    /// <param name="value">值</param>
    /// <returns></returns>
    public bool TryGetValue<T>(string key, out T value)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            value = default;
            return false;
        }

        lock (locks)
        {
            try
            {
                if (DataDictionary.TryGetValue(key, out var token))
                {
                    value = token.ToObject<T>();
                    return true;
                }
            }
            catch (Exception) { }

            value = default;
            return false;
        }
    }

    /// <summary>
    /// 尝试获取键值对，如果存在 key，则返回它的值，
    /// 如果没有找到 key，返回参数 value 的值，并将 value 的值保存到本地
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public T TryGetValueAndSave<T>(string key, T value) where T : struct
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return default(T);
        }

        lock (locks)
        {
            try
            {
                if (!DataDictionary.TryGetValue(key, out var token))
                {
                    SetValueNumber(key, value);
                    return value;
                }
                return token.ToObject<T>();
            }
            catch (Exception)
            {
                return default(T);
            }
        }
    }

    /// <summary>
    /// 尝试获取键值对，如果无此 key 将参数 value 保存到本地，
    /// 如果参数 value 不在 min、max 范围内，会返回 value，但不会保存。
    /// 如果读取本地的 value 不在 min、max 范围内，则使用参数的键值对保存覆盖，并返回 value 的值。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">key</param>
    /// <param name="value">默认值</param>
    /// <param name="min">参数的最小值</param>
    /// <param name="max">参数的最大值</param>
    /// <returns></returns>
    public (bool, T) TryGetValueAndSave<T>(string key, T value, T min, T max) where T : struct, IComparable<T>
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return (false, value);
        }
        if (value.CompareTo(min) < 0 || value.CompareTo(max) > 0)
        {
            Debug.Warning("[LocalStorage]] value 的值 必须在 max、min 范围内");
            return (false, value);
        }

        lock (locks)
        {
            try
            {
                //如果获取成功
                if (DataDictionary.TryGetValue(key, out var token))
                {
                    T _value = token.ToObject<T>();
                    //值相同
                    if (_value.Equals(value))
                        return (true, _value);
                    //值超出了范围
                    if (_value.CompareTo(min) < 0 || _value.CompareTo(max) > 0)
                    {
                        SetValueNumber(key, value);
                        return (true, value);
                    }
                    //值在范围内
                    return (true, _value);
                }

                SetValueNumber(key, value);
                return (false, value);
            }
            catch (Exception)
            {
                return (false, value);
            }
        }
    }

    #endregion

    #region 设置列表

    /// <summary>
    /// 设置列表的值，用于值类型，会替换整个 List
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">key</param>
    /// <param name="list">列表</param>
    public void SetListNumber<T>(string key, List<T> list) where T : struct
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            DataDictionary[key] = JToken.FromObject(list);
            SaveToLocal();
        }
    }

    /// <summary>
    /// 设置列表的值，用于字符串，会替换整个 List
    /// </summary>
    /// <param name="key">key</param>
    /// <param name="list">列表</param>
    public void SetListString(string key, List<string> list)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            DataDictionary[key] = JToken.FromObject(list);
            SaveToLocal();
        }
    }

    /// <summary>
    /// 设置列表的值，用于 class 类型，会替换整个 List
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="list"></param>
    public void SetListClass<T>(string key, List<T> list) where T : class, IAllowedType
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            DataDictionary[key] = JToken.FromObject(list);
            SaveToLocal();
        }
    }

    #endregion

    #region 获取列表

    /// <summary>
    /// 获取列表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key">key</param>
    /// <returns></returns>
    public List<T> GetList<T>(string key)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return null;
        }

        lock (locks)
        {
            try
            {
                if (DataDictionary.TryGetValue(key, out var token) && token != null)
                {
                    var result = token.ToObject<List<T>>();
                    return result;
                }
                return null;
            }
            catch (Exception)
            {
                return null;
            }
        }
    }

    /// <summary>
    /// 尝试获取列表，如果获取失败则返回 false，value 值则为空
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public bool TryGetList<T>(string key, out T value)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            value = default(T);
            return false;
        }

        lock (locks)
        {
            try
            {
                if (DataDictionary.TryGetValue(key, out var token))
                {
                    value = token.ToObject<T>();
                    return true;
                }

                value = default;
                return false;
            }
            catch (Exception)
            {
                value = default;
                return false;
            }
        }
    }

    #endregion

    #region 向列表追加数据

    /// <summary>
    /// 向列表中追加数据，主要用于值类型，不会检测 List 元素容是否重复
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public void ListAddNumber<T>(string key, T value) where T : struct
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            if (DataDictionary.TryGetValue(key, out var token))
            {
                if (token is JArray array)
                {
                    array.Add(value);
                }
            }
            else
            {
                var newArray = new JArray { JToken.FromObject(value) };
                DataDictionary[key] = newArray;
            }

            SaveToLocal();
        }
    }

    /// <summary>
    /// 向列表中追加数据，主要用于字符串类型，不会检测 List 元素容是否重复
    /// </summary>
    /// <param name="key">key</param>
    /// <param name="value">要添加的元素</param>
    public void ListAddString(string key, string value)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            if (DataDictionary.TryGetValue(key, out var token))
            {
                if (token is JArray array)
                {
                    array.Add(value);
                }
            }
            else
            {
                var newArray = new JArray { JToken.FromObject(value) };
                DataDictionary[key] = newArray;
            }

            SaveToLocal();
        }
    }

    /// <summary>
    ///  向列表中追加数据，主要用于 class 类型，不会检测 List 元素容是否重复
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public void ListAddClass<T>(string key, T value) where T : class, IAllowedType
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            if (DataDictionary.TryGetValue(key, out var token))
            {
                if (token is JArray array)
                {
                    // 如果已经是 JArray，直接添加新对象
                    array.Add(JToken.FromObject(value));
                }
                else
                {
                    // 如果不是 JArray，创建一个新的 JArray 存储
                    var newArray = new JArray { JToken.FromObject(value) };
                    DataDictionary[key] = newArray;
                }
            }
            else
            {
                // 如果没有找到 key 对应的数据，创建一个新的 JArray 存储
                var newArray = new JArray { JToken.FromObject(value) };
                DataDictionary[key] = newArray;
            }

            SaveToLocal();
        }
    }

    #endregion

    #region 删除数据

    /// <summary>
    /// 删除对应 key 的所有数据
    /// </summary>
    /// <param name="key">key</param>
    public void Remove(string key)
    {
        if (string.IsNullOrEmpty(key))
        {
            Debug.Warning("[LocalStorage]参数 key 不能为空");
            return;
        }

        lock (locks)
        {
            if (DataDictionary.Remove(key))
                SaveToLocal();
        }
    }

    #endregion

    #region 其他

    /// <summary>
    /// 保存到本地
    /// </summary>
    private void SaveToLocal()
    {
        lock (locks)
        {
            try
            {
                string json = JsonConvert.SerializeObject(DataDictionary, Formatting.Indented);
                File.WriteAllText(JsonPath, json);
            }
            catch (Exception ex)
            {
                Debug.Log($"[LocalStorage]数据保存失败：{ex.Message}");
            }
        }
    }

    /// <summary>
    /// 判断文件是否存在，不存在则创建
    /// </summary>
    private bool EnsureFileExists()
    {
        try
        {
            if (!File.Exists(JsonPath))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(JsonPath));
                File.WriteAllText(JsonPath, "{}"); // 初始化空JSON对象
                return true;
            }
            return false;
        }
        catch (Exception ex)
        {
            Debug.Log($"[LocalStorage]文件创建失败：{ex.Message}");
            return false;
        }
    }

    #endregion
}

/// <summary>
/// 约束 T 只能是自定义的类，防止写入时滥用其他系统类
/// </summary>
public interface IAllowedType { }

三、接口的调用

当前接口的示例使用的上面的旧版  LocalStorage.cs 来进行展示的，在源码可能有部分改动，大部分应该都对的上，个人推荐使用简单版的。

1.添加键值对

SetValue 这个方法我添加了泛型约束， T 只能是值类型，所以下面我又添加了一个 string 类型的重载方法，这里主要的目的是，既然是简单的存储系统，就尽量不要存储那些比较复杂的数据结构。

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            localStorage.SetValue("myName", "张三");

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行后，自动生成了文件，并写入了 json

2.读取键值对

读取键值对，这里有几个重载方法

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            string name = localStorage.GetValue<string>("myName");
            Console.WriteLine("name：{0}", name);

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

也可以用反射指定 T 的类型

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            var name = localStorage.GetValue("myName", typeof(string));
            Console.WriteLine("name:{0}", name);

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

还可以使用 TryGetValue 方法，不必指定类，如果 out 变量的类型对应不上，则会报错。

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            string name;
            bool isRes = localStorage.TryGetValue("myName", out name);
            Console.WriteLine("isRes：{0}，name：{1}", isRes, name);

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

3.添加数组

SetList 方法这里依然是采用两个重载方法，用泛型约束限制了 T 的类型只能是值类型和 string 类型，一般来说，使用 List 用来存储数组类型已经完全够用了，原来还写了 SetArray 方法，后面删掉了。

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);

            List<string> list1 = new List<string>() { "a", "b", "c", "d" };
            List<int> list2 = new List<int>() { 1, 34, 5, 23, 56, 64 };
            localStorage.SetList("list1", list1);
            localStorage.SetList("list2", list2);

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

4.读取数组

读取数组也有几个重载，建议看下对应的接口

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);

            List<string> list1 = localStorage.GetList<string>("list1");
            Console.WriteLine(string.Join("，", list1));

            List<int> list2 = localStorage.GetList<int>("list2");
            Console.WriteLine(string.Join("，", list2));

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

另一种读取方式，不需要指定接收值的类型

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);

            List<string> list;
            bool isRes = localStorage.TryGetList("list1", out list);
            Console.WriteLine("isRes：{0}，list：{1}", isRes, string.Join("，", list));

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

5.数组追加数据

在 SetList 方法中，数组只能替换，不能向数组追加数据，所以后面我又添加了一个方法 ListAdd，用来向指定 key 内的数组添加数据，如果当前的 key 不存在，那么就自动创建一个键值对，value类型为数组。

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            localStorage.ListAdd("list2", 3);

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

如果 key 不存在，会自动创建一个新的键值对，比如：

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            localStorage.ListAdd("age", 4);

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

6.删除指定的key

会删除整个键值对

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            localStorage.Remove("age");

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

7.删除指定key中指定的元素

这里有两个重载，可以根据对应的需求来使用

1.删除指定 key 指定起点开始指定个数的数组

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            localStorage.Remove("list1", 1, 3);

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

2.删除指定 key 中对应的元素

代码：

namespace LocalSave
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = $"{Environment.CurrentDirectory}\\Config\\LocalStorage.json";

            LocalStorage localStorage = new LocalStorage(path);
            localStorage.Remove("list2", new List<int> { 1, 34, 5, 23, 56 });

            Console.WriteLine("\n执行完成");
            Console.ReadKey();
        }
    }
}

运行：

源码下载地址：

https://download.youkuaiyun.com/download/qq_38693757/90408820

源码和上面的代码稍微有一些不同

结束

如果这个帖子对你有用，欢迎 关注 + 点赞 + 留言，谢谢

end

C# 本地文件存储技术
05-13 824
C#提供了强大的文件和流处理功能，使得开发者能够轻松地进行本地文件存储操作。在选择合适的方法时，应考虑文件的大小、内存占用以及安全性等因素。通过合理使用FileFileInfo和流类，你可以高效地处理各种文件存储需求。
C#保存本地信息
12-02
VS2010 C# 编写的，保存用户设置，当地最近消息等
本地存储HTML5，C＃
04-04
没有数据会“自行”更新，只有有人更新时，它才会更新。 也许您需要更好地解释您的意思？
使用 C# 进行数据存储与日志管理：基础与实践
最新发布
威哥说编程
10-04 710
本文探讨了C#中数据存储和日志管理的实现方法。数据存储部分介绍了文件存储（文本/CSV文件）和数据库存储（使用ADO.NET操作SQL Server）两种方式，并提供了代码示例。日志管理部分展示了如何利用System.Diagnostics命名空间进行简单日志记录，包括信息、错误和警告日志的输出。这些技术能帮助开发者有效处理数据和日志，提高系统可维护性和可靠性。
C# WINFOMR 添加本地数据库示例
05-07
C# WINFOMR 添加本地数据库示例(.sdf)
数据在内存中的存储 - c
weixin_63790936的博客
03-03 932
目录C语言数据类型内置类型类型的意义类型的基本归类整形家族浮点数家族构造类型指针类型空类型数据在内存中的存储整形在内存中的存储符号位 原码 反码 补码原码反码补码补码转换原码大小端大小字节序大端存储模式小端存储模式为什么有大小端浮点数的数据存储浮点数的存储规则指数E C语言数据类型 内置类型 char 字符数据类型 short 短整形 int 整形 long 长整型 long long 更长的整形 float 单精度浮点数 double 双精度浮点数 类型的意义 不同
localStorage使用总结
weixin_33675507的博客
06-26 5530
一、什么是localStorage、sessionStorage 在HTML5中，新加入了一个localStorage特性，这个特性主要是用来作为本地存储来使用的，解决了cookie存储空间不足的问题(cookie中每条cookie的存储空间为4k)，localStorage中一般浏览器支持的是5M大小，这个在不同的浏览器中localStorage会有所不同。   二、localStorag...
C#本地储存
weixin_44047064的博客
04-03 2042
首先做本地化登录需要引用头文件 using System.IO; using System.Runtime.Serialization.Formatters.Binary; 引用这两个头文件之后才可以写出 流的那个单词FileStream 下面的代码就是一个简单的本地储存 先创建一个 新的类 里头有要储存的东西 名字与年龄 Main方法里面先把建的类实例化一下 在把你想要存的信息写出来 再写...
c#线程本地存储数据
火焰
03-17 1646
环境： window 10 .netcore 3.1.1 vs 16.4.5 说明： 要达到的效果是，每一个线程都有一个单独的容器用来存储数据。 一、线程槽 未命名槽 命名槽 二、ThreadStatic 三、ThreadLocal using System; using System.Collections.Generic; using System.IO; using System.Lin...
Unity3D 使用C＃语言建立本地数据库
苗伟业的专栏
12-03 1641
原创文章如需转载请注明：转载自雨松MOMO程序研究院本文链接地址:Unity3D研究院之使用C＃语言建立本地数据库（二十三） 原文：http://forum.unity3d.com/threads/28500-SQLite-Class-Easier-Database-Stuff 原始文章主要是使用JavaScript语言建立本地数据库 以前在开发中一直使用IOS源生的数据库，通过传递消息
C#数据本地存储方案之SQLite
Angelo Lee's Blog
03-20 1064
即使是做网络应用，在断线情况下，也需要考虑数据的本地存储。在SQLite出现之前，数据量大的情况下，我们一直使用ACCESS，数据量小，则文件存储。ACCESS不支持事务原子性，在断电情况下（这种情况总是会发生）会导致数据很难恢复。   一：安装 SQLITE，是一款轻型的数据库，是遵守ACID的关联式数据库管理系统。我直接使用的是http://sqlite.phxsoftware.com/
C#常用数据存储
liyuqian199695的博客
10-31 7630
C#常用数据存储类型 1.List 类 表示可通过索引访问的对象的强类型列表。 提供用于对列表进行搜索、排序和操作的方法。 命名空间：  System.Collections.Generic 程序集：  mscorlib（在 mscorlib.dll 中） public class List : IList, ICollection, IEnumerable, I
c#数据存储
weixin_30279751的博客
02-29 144
1.配置文件 2.cache 转载于:https://www.cnblogs.com/williamwindy/archive/2012/02/29/2374795.html
关于C#的数据存储问题
weixin_65479901的博客
01-22 640
想做一个winform的程序，生成后在bin-debug中应用程序形式发给对象当礼物，试了一下好像不能用数据库，那如果想实现在上面存储东西的话要怎么弄吖，比如写日记等等，求大佬指点
C# 连接本地数据库
竹毛言己
03-21 6678
C# VSCode M1 C# 如何连接本地数据库？ 1. 安装MySQL 下载MySQL软件，傻瓜式安装即可，安装完之后，在系统偏好号设置里会出现一个MySQL的图标。 在安装的时候会让用户输入密码，这个自己看着输就行了，但是别忘记了。 建议别用终端命令行安装了，对初学者来说学习成本比较大。 2. 连接本地MySQL 安装完MySQL之后，点击MySQL图标，开启MySQL，如下我已开启 我本地已安装了Navicate，我就使用Navicate对本地数据库进行连接，验证是否能连接成功 打开Nvi.
localStorage
chu_geng的博客
05-16 595
关于页面获得data后无法传递，可以存在 localStorage里边 保存 window.localStorage.setItem('key', data) //注意setItme是有俩个参数的 获取 window.localStorage.getItem('key') 注意： localStorage 用于长久保存整个网站的数据，保存的数据没有过期时间，只能手动去删除。 删除...
数据的存储（C语言/C#）
qq_64176311的博客
01-30 990
基本数据类型有：char 、short 、 int 、long 、long 、 float 、double。
C#链接本地数据库
風情
06-30 133
【c#】localStorage做缓存
zhougengxu2009的博客
03-25 3606
c# LocalStorage做缓存1、localStorage做缓存2、缓存使用实例 1、localStorage做缓存 1.1 LocalStorage做缓存Cache internal class Cache { private LocalStorage localStorage; public Cache(string doma...
C#实现CSV数据本地存储与加载操作示例
本篇将详细讨论如何使用C#将数据存储到本地CSV文件中，并能够从中加载数据。 首先，C#中的数据存储和读取可以通过多种方式实现，如使用System.IO命名空间下的文件操作API，或者利用.NET Framework和.NET Core提供的...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊思宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值