如何对JSON文件单条条目增删改查及编写指定读写方法？

核心问题解答 #

1. JSON文件单条目的增删改查操作步骤 #

结合你已经掌握的读写整个文件的方法，完整的单条目操作流程梳理如下：

• 删除：你之前的步骤是正确的，补充完整流程：
  1. 从Settings.cs类中移除对应属性；
  2. 读取现有JSON文件内容，反序列化为Settings对象，移除对应属性后重新序列化写入文件。
• 添加：完善你的原有步骤：
  1. 在Settings.cs类中添加对应属性；
  2. 读取现有JSON文件内容，反序列化为Settings对象，为新属性赋值后重新序列化写入文件。
• 更新：
  1. 确保Settings.cs类中存在目标属性；
  2. 读取JSON文件内容并反序列化为Settings对象；
  3. 修改目标属性的取值；
  4. 将修改后的对象重新序列化，覆盖写入原JSON文件。
• 读取：
  1. 读取JSON文件内容并反序列化为Settings对象；
  2. 直接访问对象的对应属性即可获取值。

2. 可以通过编程方式对"SettingJson.json"进行条目增删 #

完全不需要手动修改JSON文件，通过序列化/反序列化结合对象操作就能实现，下面会给出具体的独立方法实现。

优化后的独立方法实现 #

根据你的补充需求，我基于你现有的代码，编写了支持单个/多个键值对操作的独立Write和Read方法：

首先调整Settings类（确保无参数构造函数存在，Newtonsoft.Json反序列化需要）：

namespace ConsoleApp
{
    public class Settings
    {
        // 添加无参数构造函数，保证反序列化正常执行
        public Settings() { }
        
        public string NameSetting1 { get; set; }
        public string NameSetting2 { get; set; }
        public string NameSetting3 { get; set; }
    }
}

然后在Program类中添加独立的读写方法：

// using Newtonsoft.Json;
using System.IO;
using System.Collections.Generic;
using System.Reflection;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // 示例用法
            string jsonPath = $"{Environment.CurrentDirectory}\\SettingsFolder\\SettingJson.json";
            
            // 写入单个键值对
            WriteSetting(jsonPath, "NameSetting2", "Updated_Value_Setting_2");
            
            // 写入多个键值对
            var keyValues = new Dictionary<string, string>
            {
                { "NameSetting1", "New_Value_Setting_1" },
                { "NameSetting3", "New_Value_Setting_3" }
            };
            WriteSettings(jsonPath, keyValues);
            
            // 读取单个键的值
            string setting1Value = ReadSetting(jsonPath, "NameSetting1");
            System.Console.WriteLine($"NameSetting1的值：{setting1Value}");
            
            // 读取多个键的值
            var keysToRead = new List<string> { "NameSetting2", "NameSetting3" };
            var readValues = ReadSettings(jsonPath, keysToRead);
            foreach(var kv in readValues)
            {
                System.Console.WriteLine($"{kv.Key}的值：{kv.Value}");
            }
        }

        // 写入单个键值对的方法
        static void WriteSetting(string jsonPath, string key, string value)
        {
            Settings settings = LoadSettingsFromFile(jsonPath);
            
            // 通过反射找到对应属性并赋值
            PropertyInfo prop = typeof(Settings).GetProperty(key);
            if(prop != null && prop.PropertyType == typeof(string))
            {
                prop.SetValue(settings, value);
                SaveSettingsToFile(jsonPath, settings);
            }
        }

        // 写入多个键值对的方法
        static void WriteSettings(string jsonPath, Dictionary<string, string> keyValuePairs)
        {
            Settings settings = LoadSettingsFromFile(jsonPath);
            
            foreach(var kv in keyValuePairs)
            {
                PropertyInfo prop = typeof(Settings).GetProperty(kv.Key);
                if(prop != null && prop.PropertyType == typeof(string))
                {
                    prop.SetValue(settings, kv.Value);
                }
            }
            
            SaveSettingsToFile(jsonPath, settings);
        }

        // 读取单个键的值
        static string ReadSetting(string jsonPath, string key)
        {
            Settings settings = LoadSettingsFromFile(jsonPath);
            
            PropertyInfo prop = typeof(Settings).GetProperty(key);
            return prop?.GetValue(settings)?.ToString();
        }

        // 读取多个键的值
        static Dictionary<string, string> ReadSettings(string jsonPath, List<string> keys)
        {
            Settings settings = LoadSettingsFromFile(jsonPath);
            var result = new Dictionary<string, string>();
            
            foreach(string key in keys)
            {
                PropertyInfo prop = typeof(Settings).GetProperty(key);
                if(prop != null)
                {
                    result[key] = prop.GetValue(settings)?.ToString();
                }
            }
            
            return result;
        }

        // 辅助方法：从文件加载Settings对象
        static Settings LoadSettingsFromFile(string jsonPath)
        {
            Settings settings = new Settings();
            
            if(File.Exists(jsonPath))
            {
                using(var reader = File.OpenText(jsonPath))
                {
                    string fileText = reader.ReadToEnd();
                    // 这里改成单实例对象更符合配置文件的常规场景
                    // 如果需要保留原有数组格式，只需替换泛型为Settings[]并调整逻辑
                    settings = JsonConvert.DeserializeObject<Settings>(fileText) ?? new Settings();
                }
            }
            
            return settings;
        }

        // 辅助方法：将Settings对象保存到文件
        static void SaveSettingsToFile(string jsonPath, Settings settings)
        {
            // 自动创建不存在的文件夹
            Directory.CreateDirectory(Path.GetDirectoryName(jsonPath));
            
            using(StreamWriter writer = File.CreateText(jsonPath))
            {
                // 格式化JSON，提升可读性
                string output = JsonConvert.SerializeObject(settings, Formatting.Indented);
                writer.Write(output);
            }
        }

        // 你的原有方法可按需保留或替换
        static Settings[] FillArrayAll()
        {
            Settings[] settings = new Settings[] {
                new Settings() { NameSetting1 = "ValueSetting_1", NameSetting2 = "ValueSetting_2", NameSetting3 = "ValueSetting_3" }
            };
            return settings;
        }
        
        static Settings[] FillArrayOneItem()
        {
            Settings[] settings = new Settings[] {
                new Settings() { NameSetting2 = "ValueSetting_2", }
            };
            return settings;
        }
        
        static void SaveDataArray(Settings[] settings)
        {
            string path = $"{Environment.CurrentDirectory}\\SettingsFolder\\SettingJson.json";
            using (StreamWriter writer = File.CreateText(path))
            {
                string output = JsonConvert.SerializeObject(settings);
                writer.Write(output);
            }
        }
        
        public Settings[] ReadData()
        {
            string path = $"{Environment.CurrentDirectory}\\SettingsFolder\\SettingJson.json";
            using (var reader = File.OpenText(path))
            {
                var fileText = reader.ReadToEnd();
                return JsonConvert.DeserializeObject<Settings[]>(fileText);
            }
        }
    }
}

额外说明 #

• 上述方法使用反射实现动态键值对操作，后续修改Settings类时无需同步修改读写方法；
• 我将原有数组格式的配置改为单实例Settings对象，更符合常规配置文件的使用场景，若需保留数组格式，可调整辅助方法的泛型类型为Settings[]并对应修改逻辑；
• 方法内置了文件不存在的处理逻辑，会自动初始化新的Settings对象；
• 写入时启用了Formatting.Indented格式化JSON，让文件内容更易读。

内容的提问来源于stack exchange，提问作者koverflow