C# Ini、Json、Xml 封装类

1.Ini是什么？（我对它的理解，用于存储用户配置信息的文件，该文件放在用户电脑...）

INI文件是一个无固定标准格式的配置文件。它以简单的文字与简单的结构组成，常常使用在Windows操作系统，或是其他操作系统上，许多程序也会采用INI文件做为设置程序之用。Windows操作系统后来以注册表的形式取代掉INI档。INI文件的命名来源，是取自英文“初始（Initial）”的首字缩写，正与它的用途——初始化程序相应。有时候，INI文件也会以不同的扩展名，如“.CFG”、“.CONF”、或是“.TXT”代替。

ps:

注释使用分號表示（;）。在分號後面的文字，直到該行結尾都全部為註解。

      /// <summary>
    /// INI文件读取类
    /// </summary>
    public class INIHelper
    {
        /// <summary>
        /// 文件名
        /// </summary>
        public static string str = "setting.ini";
        /// <summary>
        /// 文件路径
        /// </summary>
        public static string path = System.AppDomain.CurrentDomain.BaseDirectory + str;

        [DllImport("kernel32")]
        private static extern long WritePrivateProfileString(string section, string key, string val, string filePath);

        [DllImport("kernel32")]
        private static extern int GetPrivateProfileString(string section, string key, string def, StringBuilder retVal, int size, string filePath);

        [DllImport("kernel32")]
        private static extern int GetPrivateProfileString(string section, string key, string defVal, Byte[] retVal, int size, string filePath);

        /// <summary>
        /// 写INI文件
        /// </summary>
        /// <param name="Section">节点名称</param>
        /// <param name="Key">键</param>
        /// <param name="Value">值</param>
        public static void IniWriteValue(string Section, string Key, string Value)
        {
            WritePrivateProfileString(Section, Key, Value, path);
        }

        /// <summary>
        /// 读取INI文件
        /// </summary>
        /// <param name="Section">节点名称</param>
        /// <param name="Key">键</param>
        /// <param name="path">文件路径</param>
        /// <returns></returns>
        public static string IniReadValue(string Section, string Key, string path)
        {
            StringBuilder temp = new StringBuilder();
            int i = GetPrivateProfileString(Section, Key, "", temp, , path);
            return temp.ToString();
        }

        /// <summary>
        /// 读取INI文件
        /// </summary>
        /// <param name="section">节点名称</param>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static byte[] IniReadValues(string section, string key)
        {
            byte[] temp = new byte[];
            int i = GetPrivateProfileString(section, key, "", temp, , path);
            return temp;

        }
        /// <summary>
        /// 删除ini文件下所有节点
        /// </summary>
        public static void ClearAllSection()
        {
            IniWriteValue(null, null, null);
        }
        /// <summary>
        /// 删除ini文件指点节点下的所有键
        /// </summary>
        /// <param name="Section"></param>
        public static void ClearSection(string Section)
        {
            IniWriteValue(Section, null, null);
        }
    }

来源： https://zh.wikipedia.org/wiki/INI%E6%96%87%E4%BB%B6

参考：https://en.wikipedia.org/wiki/INI_file

2.Json是什么？

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language.

来源：http://www.json.org/

目前，接触比较多都是Newtonsoft.Json，它封装的很齐全，记忆比较深刻的是，它用通过字段的属性，来确定字段是否被序列化以及null不序列化等功能，用来支撑变化多端的需求。

参考：Newtonsoft https://www.newtonsoft.com/json

  /// <summary>
        /// 反序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="json"></param>
        /// <returns></returns>
        public static T DeserializeObject<T>(string json)
        {
            return JsonConvert.DeserializeObject<T>(json);
        }
        /// <summary>
        /// 序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="json"></param>
        /// <returns></returns>
        public static string DeserializeObject<T>(object obj)
        {
            JsonConvert.SerializeObject(obj);
        }

3.Xml是什么？（更接近人类的语言）

In computing, Extensible Markup Language (XML) is a markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable. The W3C's XML 1.0 Specification[2] and several other related specifications[3]—all of them free open standards—define XML.[4]

The design goals of XML emphasize simplicity, generality, and usability across the Internet.[5] It is a textual data format with strong support via Unicode for different human languages. Although the design of XML focuses on documents, the language is widely used for the representation of arbitrary data structures[6] such as those used in web services.

Several schema systems exist to aid in the definition of XML-based languages, while programmers have developed many application programming interfaces (APIs) to aid the processing of XML data.

来源：https://en.wikipedia.org/wiki/XML

 public class AppConfigXmlHelper
    {
        public static string AppConfig()
        {
            XmlDocument xDoc = new XmlDocument();
            xDoc.Load(System.Windows.Forms.Application.ExecutablePath + ".config");
            string strDirectoryPath = Environment.CurrentDirectory + "\\IniJsonXmlTest.EXE.config";
            return strDirectoryPath;
        }
        public static string GetPath(string key)
        {
            XmlDocument xDoc = new XmlDocument();
            try
            {
                xDoc.Load(AppConfig());
                XmlNode xNode;
                XmlElement xElem;
                xNode = xDoc.SelectSingleNode("//appSettings");　　　　//补充，需要在你的app.config 文件中增加一下，<appSetting> </appSetting>
                xElem = (XmlElement)xNode.SelectSingleNode("//add[@key='" + key + "']");
                if (xElem != null)
                    return xElem.GetAttribute("value");
                else
                    return "";
            }
            catch (Exception)
            {
                return "";
            }
        }
        public static void SetPath(string key, string path)
        {
            XmlElement xElem;
            XmlDocument doc = new XmlDocument();
            doc.Load(AppConfig());
            XmlNode node = doc.SelectSingleNode(@"//appSettings");
            xElem = (XmlElement)node.SelectSingleNode("//add[@key='" + key + "']");
            xElem.SetAttribute("value", path);
            doc.Save(AppConfig());
        }
    }

public class XmlSerialization
    {

        public static System.IO.Stream Serialize(object obj, Encoding encode, System.IO.Stream s)
        {
            TextWriter writer = null;
            writer = new StreamWriter(s, encode);

            XmlSerializer ser = new XmlSerializer(obj.GetType());

            ser.Serialize(writer, obj);
            return s;

        }

        public static MemoryStream Serialize(object obj, Encoding encode)
        {
            MemoryStream s = new MemoryStream();
            Serialize(obj, encode, s);
            s.Position = ;
            return s;
        }

        public static MemoryStream Serialize(object obj, String encode)
        {
            return Serialize(obj, Encoding.GetEncoding(encode));
        }

        public static MemoryStream Serialize(object obj)
        {
            return Serialize(obj, Encoding.UTF8);
        }

        public static object Deserialize(System.IO.Stream In, Type objType)
        {
            In.Position = ;
            XmlSerializer ser = new XmlSerializer(objType);
            return ser.Deserialize(In);
        }
    }

    public class XmlSerialization<T>
    {
        public static System.IO.Stream Serialize(T obj, Encoding encode, System.IO.Stream s)
        {
            TextWriter writer = null;
            writer = new StreamWriter(s, encode);

            XmlSerializer ser = new XmlSerializer(typeof(T));

            ser.Serialize(writer, obj);
            return s;
        }

        public static MemoryStream Serialize(T obj, Encoding encode)
        {
            MemoryStream s = new MemoryStream();
            Serialize(obj, encode, s);
            s.Position = ;
            return s;
        }

        public static MemoryStream Serialize(T obj, String encode)
        {
            return Serialize(obj, Encoding.GetEncoding(encode));
        }

        public static MemoryStream Serialize(T obj)
        {
            return Serialize(obj, Encoding.UTF8);
        }

        public static T Deserialize(System.IO.Stream In)
        {
            In.Position = ;
            XmlSerializer ser = new XmlSerializer(typeof(T));
            return (T)ser.Deserialize(In);
        }
    }

4.序列化与反序列化

• 序列化： 将数据结构或对象转换成二进制串的过程。
• 反序列化：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。

using System;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

using System.Web.Script.Serialization;

using System.Xml.Serialization;

    public static class Serializer
    {

        #region 二进制
        /// <summary>
        /// 序列化二进制文件
        /// </summary>
        /// <param name="path"></param>
        /// <param name="data"></param>
        public static void SaveBinary(string path, object data)
        {
            if (File.Exists(path))
            {
                File.Delete(path);
            }
            BinaryFormatter bf = new BinaryFormatter();
            FileStream fs = File.Create(path);
            bf.Serialize(fs, data);
            fs.Close();
        }

        /// <summary>
        /// 反序列化二进制文件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <returns></returns>
        public static T LoadBinary<T>(string path)
        {
            if (!File.Exists(path))
            {
                return default(T);
            }
            BinaryFormatter bf = new BinaryFormatter();
            FileStream fs = File.OpenRead(path);
            object data = bf.Deserialize(fs);
            fs.Close();
            return (T)data;
        }
        #endregion

        #region xml
        /// <summary>
        /// 序列化XML文件
        /// </summary>
        /// <param name="path"></param>
        /// <param name="data"></param>
        /// <param name="type"></param>
        public static void SaveXml(string path, object data, Type type)
        {
            if (File.Exists(path))
            {
                File.Delete(path);
            }
            XmlSerializer xs = new XmlSerializer(type);
            FileStream fs = File.Create(path);
            xs.Serialize(fs, data);
            fs.Close();
        }

        /// <summary>
        /// 反序列化XML文件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static T LoadXml<T>(string path, Type type)
        {
            if (!File.Exists(path))
            {
                return default(T);
            }
            XmlSerializer xs = new XmlSerializer(type);
            FileStream fs = File.OpenRead(path);
            object data = xs.Deserialize(fs);
            fs.Close();
            return (T)data;
        }
        #endregion

        #region json
        /// <summary>
        /// 序列化JSON
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string Serialize(object data)
        {
            JavaScriptSerializer json = new JavaScriptSerializer();
            json.MaxJsonLength = Int32.MaxValue;
            return json.Serialize(data);
        }

        /// <summary>
        /// 反序列化JSON
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="json"></param>
        /// <returns></returns>
        public static T Deserialize<T>(string json)
        {
            JavaScriptSerializer js = new JavaScriptSerializer();
            js.MaxJsonLength = Int32.MaxValue;
            return js.Deserialize<T>(json);
        }
        #endregion

    }

github：https://github.com/HuQinL/IniJsonXmlTest

参考：

INI配置文件的格式 https://blog.csdn.net/gateway6143/article/details/29554349

序列化和反序列化 http://www.infoq.com/cn/articles/serialization-and-deserialization