Unity 数据读取|（三）ini文件解析（INIParser，StreamReader，System.Runtime.InteropServices）

游戏开发小Y

发布于 2024-01-18 19:14:31

3370

发布于 2024-01-18 19:14:31

文章被收录于专栏：Unity开发系列专栏

1. 前言

INI文件是一种纯文本文件，通常用于存储应用程序的配置信息。它由多个节（section）和键值对（key-value pair）组成，可以方便地组织和管理配置信息。INI文件的特点包括易于编辑和阅读，结构简单，支持多层级节，不支持数据类型等。在Windows操作系统中，INI文件被广泛应用于各种软件和程序的配置文件中。当一个应用程序需要存储一些配置信息时，可以将这些信息写入INI文件中，以便程序在初始化和运行时可以读取这些配置信息。

2. 优缺点

INI文件格式的优点主要包括以下几点：
- 易于理解和编辑：INI文件是一种纯文本文件，可以方便地使用文本编辑器打开和编辑。INI文件格式简单清晰，由节（section）、键（key）和值（value）组成，可以通过修改相应的键值对来修改配置信息。
- 结构灵活：INI文件支持多层级节，可以根据需要添加、删除或修改节和键。这种灵活的结构使得INI文件可以方便地管理复杂的配置信息。
- 易于扩展：INI文件不支持复杂的数据类型，只支持字符串类型。但是，INI文件支持注释和空白行，方便用户添加注释来解释文件内容。此外，INI文件也可以通过扩展语法来支持其他数据类型或特殊配置需求。
- 适用于多种操作系统：INI文件是一种通用的配置文件格式，可以适用于多种操作系统和编程语言。这使得在不同平台上开发的应用程序可以使用相同的配置文件，提高了可移植性和兼容性。
然而，INI文件格式也存在一些缺点：
- 安全性问题：INI文件通常包含敏感信息，如用户名、密码等。如果INI文件未受到适当的保护，可能会被恶意用户访问或篡改。因此，在处理INI文件时需要注意安全性问题。
- 不适合存储大量数据：INI文件格式不适合存储大量数据。由于INI文件是文本文件，存储大量数据会导致文件变大，并可能影响程序的性能。
- 解析速度相对较慢：相对于其他配置文件格式，如XML或JSON，INI文件的解析速度相对较慢。这主要是因为INI文件格式较为简单，需要更多的处理来读取和解析文件内容。
- 无法表示复杂的数据结构：INI文件不支持复杂的数据类型，只支持字符串类型。同时，INI文件也不支持嵌套结构，无法表示复杂的数据结构。这使得在需要存储复杂数据结构时，需要使用其他配置文件格式或自定义解决方案。

3. 解析

格式模板

[section1]  
key1=value1  
key2=value2  
  
[section2]  
key3=value3  
key4=value4

3.1 StreamReader

using UnityEngine;
using System.IO;
using System.Collections.Generic;
/// <summary>
/// unity中对ini配置文件的操作
/// </summary>
public class IniFile
{
    //去掉一行信息的开始和末尾不需要的信息
    private static readonly char[] TrimStart = new char[] { ' ', '\t' };
    private static readonly char[] TrimEnd = new char[] { ' ', '\t', '\r', '\n' };
    //key和value的分隔符
    private const string DELEMITER = "=";
    //路径
    private string strFilePath = null;
    //是否区分大小写
    private bool IsCaseSensitive = false;
    private Dictionary<string, Dictionary<string, string>> IniConfigDic = new Dictionary<string, Dictionary<string, string>>();
    //初始化
    public IniFile(string path, bool isCaseSensitive = false)
    {
        strFilePath = path;
        IsCaseSensitive = isCaseSensitive;
    }
    //解析ini
    public void ParseIni()
    {
        if (!File.Exists(strFilePath))
        {
            Debug.LogWarning("the ini file's path is error：" + strFilePath);
            return;
        }
        using (StreamReader reader = new StreamReader(strFilePath))
        {
            string section = null;  
            string key = null;
            string val = null;  
            Dictionary<string, string> config = null;

            string strLine = null;  
            while ((strLine = reader.ReadLine()) != null)
            {
                strLine = strLine.TrimStart(TrimStart);
                strLine = strLine.TrimEnd(TrimEnd);
                //'#'开始代表注释
                if (strLine.StartsWith("#"))
                {
                    continue;
                }

                if (TryParseSection(strLine, out section))
                {
                    if (!IniConfigDic.ContainsKey(section))
                    {
                        IniConfigDic.Add(section, new Dictionary<string, string>());
                    }
                    config = IniConfigDic[section];
                }
                else
                {
                    if (config != null)
                    {
                        if (TryParseConfig(strLine, out key, out val))
                        {
                            if (config.ContainsKey(key))
                            {
                                config[key] = val;
                                Debug.LogWarning("the Key[" + key + "] is appear repeat");
                            }
                            else
                            {
                                config.Add(key, val);
                            }
                        }
                    }
                    else
                    {
                        Debug.LogWarning("the ini file's format is error，lost [Section]'s information");
                    }
                }
            }
        }
    }
    //写入ini
    public void SaveIni()
    {
        if (string.IsNullOrEmpty(strFilePath))
        {
            Debug.LogWarning("Empty file name for SaveIni.");
            return;
        }

        string dirName = Path.GetDirectoryName(strFilePath);
        if (string.IsNullOrEmpty(dirName))
        {
            Debug.LogWarning(string.Format("Empty directory for SaveIni:{0}.", strFilePath));
            return;
        }
        if (!Directory.Exists(dirName))
        {
            Directory.CreateDirectory(dirName);
        }

        using (StreamWriter sw = new StreamWriter(strFilePath))
        {
            foreach (KeyValuePair<string, Dictionary<string, string>> pair in IniConfigDic)
            {
                sw.WriteLine("[" + pair.Key + "]");
                foreach (KeyValuePair<string, string> cfg in pair.Value)
                {
                    sw.WriteLine(cfg.Key + DELEMITER + cfg.Value);
                }
            }
        }
    }

    public string GetString(string section, string key, string defaultVal)
    {
        if (!IsCaseSensitive)
        {
            section = section.ToUpper();
            key = key.ToUpper();
        }
        Dictionary<string, string> config = null;
        if (IniConfigDic.TryGetValue(section, out config))
        {
            string ret = null;
            if (config.TryGetValue(key, out ret))
            {
                return ret;
            }
        }
        return defaultVal;
    }

    public int GetInt(string section, string key, int defaultVal)
    {
        string val = GetString(section, key, null);
        if (val != null)
        {
            return int.Parse(val);
        }
        return defaultVal;
    }

    public void SetString(string section, string key, string val)
    {
        if (!string.IsNullOrEmpty(section) && !string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(val))
        {
            if (!IsCaseSensitive)
            {
                section = section.ToUpper();
                key = key.ToUpper();
            }
            Dictionary<string, string> config = null;
            if (!IniConfigDic.TryGetValue(section, out config))
            {
                config = new Dictionary<string, string>();
                IniConfigDic[section] = config;
            }
            config[key] = val;
        }
    }

    public void SetInt(string section, string key, int val)
    {
        SetString(section, key, val.ToString());
    }

    public void AddString(string section, string key, string val)
    {
        if (!string.IsNullOrEmpty(section) && !string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(val))
        {
            if (!IsCaseSensitive)
            {
                section = section.ToUpper();
                key = key.ToUpper();
            }
            Dictionary<string, string> config = null;
            if (!IniConfigDic.TryGetValue(section, out config))
            {
                config = new Dictionary<string, string>();
                IniConfigDic[section] = config;
            }
            if (!config.ContainsKey(key))
            {
                config.Add(key, val);
            }
        }
    }

    public void AddInt(string section, string key, int val)
    {
        AddString(section, key, val.ToString());
    }

    public bool RemoveSection(string section)
    {
        if (IniConfigDic.ContainsKey(section))
        {
            IniConfigDic.Remove(section);
            return true;
        }
        return false;
    }

    public bool RemoveConfig(string section, string key)
    {
        if (!IsCaseSensitive)
        {
            section = section.ToUpper();
            key = key.ToUpper();
        }
        Dictionary<string, string> config = null;
        if (IniConfigDic.TryGetValue(section, out config))
        {
            if (config.ContainsKey(key))
            {
                config.Remove(key);
                return true;
            }
        }
        return false;
    }

    public Dictionary<string, string> GetSectionInfo(string section)
    {
        Dictionary<string, string> res = null;
        if (!IsCaseSensitive)
        {
            section = section.ToUpper();
        }
        IniConfigDic.TryGetValue(section, out res);
        return res;
    }

    private bool TryParseSection(string strLine, out string section)
    {
        section = null;
        if (!string.IsNullOrEmpty(strLine))
        {
            int len = strLine.Length;
            if (strLine[0] == '[' && strLine[len - 1] == ']')
            {
                section = strLine.Substring(1, len - 2);
                if (!IsCaseSensitive)
                {
                    section = section.ToUpper();
                }
                return true;
            }
        }
        return false;
    }

    private bool TryParseConfig(string strLine, out string key, out string val)
    {
        if (strLine != null && strLine.Length >= 3)
        {
            string[] contents = strLine.Split(DELEMITER.ToCharArray());
            if (contents.Length == 2)
            {
                key = contents[0].TrimStart(TrimStart);
                key = key.TrimEnd(TrimEnd);
                val = contents[1].TrimStart(TrimStart);
                val = val.TrimEnd(TrimEnd);
                if (key.Length > 0 && val.Length > 0)
                {
                    if (!IsCaseSensitive)
                    {
                        key = key.ToUpper();
                    }

                    return true;
                }
            }
        }

        key = null;
        val = null;
        return false;
    }
}

3.2 System.Runtime.InteropServices

public class MyIni
{
  public string path;//ini文件的路径
  public MyIni(string path)
  {
    this.path=path;
  }
  [DllImport("kernel32")]
  public static extern long WritePrivateProfileString(string section,string key,string value,string path);
  [DllImport("kernel32")]
  public static extern int GetPrivateProfileString(string section,string key,string deval,StringBuilder stringBuilder,int size,string path);

//写入ini文件
public void WriteIniContent(string section,string key,string value)
{
WritePrivateProfileString(section,key,value,this.path);
}

//读取Ini文件
public string ReadIniContent(string section,string key)
{
   StringBuilder temp=new StringBuilder(255);
   int i=GetPrivateProfileString(section,key,"",temp,255,this.path);
   return temp.ToString();
}

//判断路径是否正确
public bool IsIniPath()
{
   return File.Exists(this.path);
}
}

3.3 INIParser

INIParser ini = new INIParser();  
ini.Open(“C:/Test.ini”);  
ini.WriteValue(“Player”,“Name”,“Arnold”);  
ini.WriteValue(“Hi-score”,“Top3”,1000);  
ini.Close();  
ini.Open(“C:/Test2.ini”);  
ini.WriteValue(“Position”,“x”,2);  
ini.WriteValue(“Position”,“y”,3);  
ini.Close();

多个Ini文件时请注意，对于每个INIParser实例，你在任何一个时间只能有一个open的ini文件，你可以打开下一个ini文件，但是之前您必须使用Close()。

方法	描述
Open(string path)	Open ini_file关于 reading 和 writing. 如果这个文件不存在将被创建。. 一旦你完成了reading/writing 记得调用函数 Close( )。来保存这个ini文件的所有改变。
Open(TextAsset asset)	Open 一个 TextAsset 作为 ini_file. 如果做了任何更改，则副本将保存在Persistent Data Path持久性数据的路径下。这个函数会一直看着Persistent Data Path持久数据路径，如果有任何修改的TextAsset的副本，实际上看游戏中的文本资源包之前首先看到在Persistent Data Path持久数据路径的变化。
OpenFromString(string str)	从字符串创建ini文件和打开它用于进行读/写。正确格式化的字符串作为ini文件(即：sections部分，keys键和values值) 否则将无法正确创建ini文件。注意，这个ini文件是暂时的，只存在于内存中。但是你可以使用ToString()返回的字符串可以被保存到服务器或磁盘的完整的ini文件。
string ToString(string str)	返回完整的 ini file 字符串。
Close()	一旦你完成读取或写入任何打开的ini文件，应调用此方法。ini文件数据存储在内存中，直到调用此方法，这一数据被写入到磁盘。
string ReadValue(string section, string key, string default)	从ini_file中读取值。如果值不存在，(默认值)将被返回。
WriteValue(string section, string key, string value)	写入一个值到 ini_file
bool IsSectionExists(string section)	检查是否存在ini文件中的section 节。您不需要检查，以防止错误，因为如果你ReadValue从一个不存在的section 节，ReadValue将只返回默认值。然而，有时它可以是有用的如果ini文件已保存的具体数据。
KeyDelete(string section, string key)	删除被选择的 key (还有和它相关的 value) 从 ini file.中
bool IsKeyExists(string section, string key)	检查以查看是否有指定的键存在于ini文件。您不需要检查，以防止错误，因为如果你ReadValue一个不存在的节，ReadValue将只返回默认值。然而，有时它可以是有用的如果ini文件已保存的具体数据。