用于存储的 XML 或 INI 文件？ [关闭]

Question

存储值列表以供在我的程序中使用并允许用户更改它们的最佳方式是什么？ XML 文件或 INI 文件，为什么？

如果您有更好的建议，欢迎您。

编辑：为了得到最合适的答案，这里有一些细节。但是，答案可以帮助其他用户，因为自定义详细信息仅作为 cmets 编写。

我有一个元素集合，每个元素都标有“真”或“假”值。
在我的程序中，我只想使用列表中用“真”值签名的元素。

我只能使用带有“True”元素的 Enum，但我希望用户通过将 false 更改为 true 来选择他想要的元素，反之亦然。

但是，我不希望他在每次执行中都选择所需的元素。这就是为什么我考虑使用可以根据用户偏好方便更改的文件的原因。

Answer 1

在我看来有很多选择，但如果不是很有经验，你应该尽可能简单。

一种方法是使用您可以通过项目本身生成的设置。

只需在解决方案资源管理器中单击Add > New Item 将设置文件添加到您的项目，然后选择Settings File。

This 是一篇关于将列表添加到设置文件的有用文章。

---

在您的情况下，您也可以选择string 设置。只需将整数值保存到 string 使用：

Properties.Settings.Default.SettingX = string.Join(",", array);

用这个把它们读回来：

string[] list = Properties.Settings.Default.SettingX.Split(',');

Answer 2

我建议使用 .NET 默认方式，这肯定是 XML。

与 INI 格式相比，使用 XML 有一些优势：

• 分层数据结构
• 复杂的数据类型易于存储（序列化）
• 您可以简单地使用 xsd 进行验证
• XML 已标准化且面向未来

Answer 3

您可能应该使用app.config configuration 文件。

它使用 XML 来存储设置，但框架会为您处理大部分繁琐的工作。

如果您需要能够在运行时从应用程序更改设置，请查看Settings files。

Answer 4

最好地回答一个问题可能是一件大事。我认为这里有几个很好的解决方案，希望对您有所帮助。

实际上，我开发了很多应用程序，所有这些应用程序都需要由最终用户配置。 在使用“xml”一段时间后，我将自己更改为仅由“propertyName”=“value”组成的简单 ini 文件。

我写了一个简单的类来处理这类文件。用法很简单

Settings.ConfigProperties cfProps = new Settings.ConfigProperties("c:\\test.ini");
//if the file exists it will be read

//to update or insert new values
cfProps.UpdateValue("myNewProperty", "myValue");

//to get a stored value
String readValue = cfProps.ToString("myNewProperty");

//to permanently write changes to the ini file
cfProps.Save();

代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace Settings
{
    public class ConfigProperties
    {
        public class PropertyList<T> : List<ConfigProperty>
        {
            public ConfigProperty this[String propertyName]
            {
                get
                {
                    ConfigProperty ret = null;
                    foreach (ConfigProperty cp in this)
                    {
                        if (cp.Name == propertyName)
                        {
                            ret = cp;
                            break;
                        }
                    }
                    return ret;
                }
                set
                {
                    ConfigProperty ret = null;
                    foreach (ConfigProperty cp in this)
                    {
                        if (cp.Name == propertyName)
                        {
                            ret = cp;
                            break;
                        }
                    }
                    value = ret;
                }
            }
            public PropertyList()
                : base()
            {

            }

            public void Add(String Name, String Value)
            {
                ConfigProperty cp = new ConfigProperty();
                cp.Name = Name;
                cp.Value = Value;
                this.Add(cp);
            }
        }
        public class ConfigProperty
        {
            public String Name { get; set; }
            public String Value { get; set; }
            public ConfigProperty()
            {
                Name = "newPropertyName_" + DateTime.Now.Ticks.ToString();
                Value = "";
            }
            public ConfigProperty(String name, String value)
            {
                Name = name;
                Value = value;
            }
        }

        public String FileName { get; set; }
        public PropertyList<ConfigProperty> CFCollection { get; private set; }

        public ConfigProperties()
            : this(AppDomain.CurrentDomain.BaseDirectory + "config.ini")
        {
        }

        public ConfigProperties(String fileName)
        {
            CFCollection = new PropertyList<ConfigProperty>();
            FileName = fileName;
            if (fileName != null && File.Exists(fileName))
            {
                ReadFile();
            }
        }

        private void ReadFile()
        {
            if (File.Exists(FileName))
            {
                CFCollection = new PropertyList<ConfigProperty>();
                using (StreamReader sr = new StreamReader(FileName, Encoding.Default))
                {
                    while (!sr.EndOfStream)
                    {
                        String line = sr.ReadLine();
                        if (!line.StartsWith("#"))
                        {
                            ConfigProperty cf = new ConfigProperty();
                            String tmp = "";
                            Char splitter = '=';
                            for (int i = 0; i < line.Length; i++)
                            {
                                if (line[i] != splitter)
                                {
                                    tmp += ((Char)line[i]).ToString();
                                }
                                else
                                {
                                    cf.Name = tmp;
                                    tmp = "";
                                    splitter = '\n';
                                }
                            }
                            cf.Value = tmp;
                            if (cf.Name.Length > 0)
                            {
                                CFCollection.Add(cf);
                            }
                        }
                    }

                    sr.Close();
                }
            }
        }

        private void SaveConfigProperty(ConfigProperty prop)
        {
            List<String> output = new List<String>();
            if (File.Exists(FileName))
            {
                using (StreamReader sr = new StreamReader(FileName, Encoding.Default))
                {
                    while (!sr.EndOfStream)
                    {
                        String line = sr.ReadLine();
                        if (line.StartsWith(prop.Name + "="))
                        {
                            output.Add(prop.Name + "=" + prop.Value);
                        }
                        else
                        {
                            output.Add(line);
                        }
                    }
                    sr.Close();
                }
            }

            if (!output.Contains(prop.Name + "=" + prop.Value))
            {
                output.Add(prop.Name + "=" + prop.Value);
            }

            StreamWriter sw = new StreamWriter(FileName, false, Encoding.Default);

            foreach (String s in output)
            {
                sw.WriteLine(s);
            }
            sw.Close();
            sw.Dispose();
            GC.SuppressFinalize(sw);
            sw = null;

            output.Clear();
            output = null;

        }

        public void Save()
        {
            foreach (ConfigProperty cp in CFCollection)
            {
                SaveConfigProperty(cp);
            }
        }

        public void UpdateValue(String propertyName, String propertyValue)
        {
            try
            {
                IEnumerable<ConfigProperty> myProps = CFCollection.Where(cp => cp.Name.Equals(propertyName));
                if (myProps.Count() == 1)
                {
                    myProps.ElementAt(0).Value = propertyValue;
                }
                else if (myProps.Count() == 0)
                {
                    CFCollection.Add(new ConfigProperty(propertyName, propertyValue));
                }
                else
                {
                    throw new Exception("Can't find/set value for: " + propertyName);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public String ToString(String propertyName)
        {
            try
            {
                return CFCollection.Where(cp => cp.Name.Equals(propertyName)).First().Value;
            }
            catch (Exception ex)
            {
                throw new Exception("Can't find/read value for: " +
                    propertyName, ex);
            }
        }

    }
}

Answer 5

我想推荐 JSON 格式

• 可以人工阅读/编辑
• 支持层次结构
• 它不像 XML 那样复杂
• 它可以像魅力一样使用（没有丑陋的ini解析）

格式化文件的样子

{"DevCommentVisibility":27,"CommentVisibility":1,"IssueStatusAfterCheckin":4,"Log":{"Debug":false,"Info":true,"Warn":true,"FileName":" d:\temp\2.log"},"语言":"en"}

public static string Serialize(T pSettings)
{
    return (new JavaScriptSerializer()).Serialize(pSettings);
}

public static T Load(string fileName)
{
    T t = new T();
    if (File.Exists(fileName))
        try
        {
            t = (new JavaScriptSerializer()).Deserialize<T>(File.ReadAllText(fileName));
            var s = t as SettingsFoo;
            if (s != null)
                s.FileName = fileName;
        }
        catch (Exception ex)
        {
            Trace.WriteLine(string.Format("failed to parse settings file {0}", fileName));
            Trace.WriteLine(ex.Message);
        }
    else
    {
        Trace.WriteLine(string.Format("failed load settings '{0}' absolute '{1}'", fileName, Path.GetFullPath(fileName)));
        Save(t);
    }
    return t;
}

Answer 6

您可以使用简单的纯文件。

将List<int> list 保存到file.txt：

System.IO.File.WriteAllLines("file.txt", list.Select(v => v.ToString()).ToArray());

加载中：

List<int> loaded = System.IO.File.ReadAllLines("file.txt").Select(l => int.Parse(l)).ToList();

使用扩展方法来设计更好的语法和正确的错误处理

UPD：我可以提出的通用扩展方法（无异常处理）：

public static class MyExtensions
{
    public static void SaveToFile<T>(this List<T> list, string filename)
    {
        System.IO.File.WriteAllLines(filename, list.Select(v => v.ToString()).ToArray());
    }

    public static void FillFromFile<T>(this List<T> list, string filename, Func<string, T> parser)
    {
        foreach (var line in System.IO.File.ReadAllLines(filename))
        {
            T item = parser(line);

            list.Add(item);
        }
    }
}

像这样使用它：

List<int> list = new List<int>() { 0, 1, 2 };

list.SaveToFile("numbers.txt");

List<int> loaded = new List<int>();

loaded.FillFromFile("numbers.txt", (l) => int.Parse(l));