读取/写入INI文件

. net框架的创建者希望您使用基于xml的配置文件，而不是INI文件。所以不，没有内置的机制来读取它们。

不过，也有第三方的解决方案。

• INI处理程序可以通过NuGet包获得，例如INI解析器。
• 您可以编写自己的INI处理程序，这是一种老式的、费力的方法。它为您提供了对实现的更多控制，可以用于坏的方面，也可以用于好的方面。参见e.g. 一个INI文件处理类，使用c#， P/Invoke和Win32。

CodeProject“一个使用c#的INI文件处理类”的这篇文章应该会有所帮助。

作者创建了一个c#类“Ini”，它公开了KERNEL32.dll中的两个函数。这些函数是:WritePrivateProfileString和GetPrivateProfileString。你需要两个命名空间:System.Runtime.InteropServices和System.Text。

使用Ini类的步骤

在项目名称空间定义中添加

using INI;

像这样创建一个INIFile

INIFile ini = new INIFile("C:\\test.ini");

使用IniWriteValue向section中的特定键写入新值，或使用IniReadValue从特定section中的键读取值。

注意:如果你从头开始，你可以阅读这篇MSDN文章: 如何:将应用程序配置文件添加到c#项目。这是配置应用程序的一种更好的方式。

在CommonLibrary。网中有一个Ini解析器可用

这有各种非常方便的重载获取部分/值，是非常轻的重量。

我发现了这个简单的实现:

http://bytes.com/topic/net/insights/797169-reading-parsing-ini-file-c

能满足我的需要。

下面是如何使用它:

public class TestParser
{
public static void Main()
{
IniParser parser = new IniParser(@"C:\test.ini");


String newMessage;


newMessage = parser.GetSetting("appsettings", "msgpart1");
newMessage += parser.GetSetting("appsettings", "msgpart2");
newMessage += parser.GetSetting("punctuation", "ex");


//Returns "Hello World!"
Console.WriteLine(newMessage);
Console.ReadLine();
}
}

代码如下:

using System;
using System.IO;
using System.Collections;


public class IniParser
{
private Hashtable keyPairs = new Hashtable();
private String iniFilePath;


private struct SectionPair
{
public String Section;
public String Key;
}


/// <summary>
/// Opens the INI file at the given path and enumerates the values in the IniParser.
/// </summary>
/// <param name="iniPath">Full path to INI file.</param>
public IniParser(String iniPath)
{
TextReader iniFile = null;
String strLine = null;
String currentRoot = null;
String[] keyPair = null;


iniFilePath = iniPath;


if (File.Exists(iniPath))
{
try
{
iniFile = new StreamReader(iniPath);


strLine = iniFile.ReadLine();


while (strLine != null)
{
strLine = strLine.Trim().ToUpper();


if (strLine != "")
{
if (strLine.StartsWith("[") && strLine.EndsWith("]"))
{
currentRoot = strLine.Substring(1, strLine.Length - 2);
}
else
{
keyPair = strLine.Split(new char[] { '=' }, 2);


SectionPair sectionPair;
String value = null;


if (currentRoot == null)
currentRoot = "ROOT";


sectionPair.Section = currentRoot;
sectionPair.Key = keyPair[0];


if (keyPair.Length > 1)
value = keyPair[1];


keyPairs.Add(sectionPair, value);
}
}


strLine = iniFile.ReadLine();
}


}
catch (Exception ex)
{
throw ex;
}
finally
{
if (iniFile != null)
iniFile.Close();
}
}
else
throw new FileNotFoundException("Unable to locate " + iniPath);


}


/// <summary>
/// Returns the value for the given section, key pair.
/// </summary>
/// <param name="sectionName">Section name.</param>
/// <param name="settingName">Key name.</param>
public String GetSetting(String sectionName, String settingName)
{
SectionPair sectionPair;
sectionPair.Section = sectionName.ToUpper();
sectionPair.Key = settingName.ToUpper();


return (String)keyPairs[sectionPair];
}


/// <summary>
/// Enumerates all lines for given section.
/// </summary>
/// <param name="sectionName">Section to enum.</param>
public String[] EnumSection(String sectionName)
{
ArrayList tmpArray = new ArrayList();


foreach (SectionPair pair in keyPairs.Keys)
{
if (pair.Section == sectionName.ToUpper())
tmpArray.Add(pair.Key);
}


return (String[])tmpArray.ToArray(typeof(String));
}


/// <summary>
/// Adds or replaces a setting to the table to be saved.
/// </summary>
/// <param name="sectionName">Section to add under.</param>
/// <param name="settingName">Key name to add.</param>
/// <param name="settingValue">Value of key.</param>
public void AddSetting(String sectionName, String settingName, String settingValue)
{
SectionPair sectionPair;
sectionPair.Section = sectionName.ToUpper();
sectionPair.Key = settingName.ToUpper();


if (keyPairs.ContainsKey(sectionPair))
keyPairs.Remove(sectionPair);


keyPairs.Add(sectionPair, settingValue);
}


/// <summary>
/// Adds or replaces a setting to the table to be saved with a null value.
/// </summary>
/// <param name="sectionName">Section to add under.</param>
/// <param name="settingName">Key name to add.</param>
public void AddSetting(String sectionName, String settingName)
{
AddSetting(sectionName, settingName, null);
}


/// <summary>
/// Remove a setting.
/// </summary>
/// <param name="sectionName">Section to add under.</param>
/// <param name="settingName">Key name to add.</param>
public void DeleteSetting(String sectionName, String settingName)
{
SectionPair sectionPair;
sectionPair.Section = sectionName.ToUpper();
sectionPair.Key = settingName.ToUpper();


if (keyPairs.ContainsKey(sectionPair))
keyPairs.Remove(sectionPair);
}


/// <summary>
/// Save settings to new file.
/// </summary>
/// <param name="newFilePath">New file path.</param>
public void SaveSettings(String newFilePath)
{
ArrayList sections = new ArrayList();
String tmpValue = "";
String strToSave = "";


foreach (SectionPair sectionPair in keyPairs.Keys)
{
if (!sections.Contains(sectionPair.Section))
sections.Add(sectionPair.Section);
}


foreach (String section in sections)
{
strToSave += ("[" + section + "]\r\n");


foreach (SectionPair sectionPair in keyPairs.Keys)
{
if (sectionPair.Section == section)
{
tmpValue = (String)keyPairs[sectionPair];


if (tmpValue != null)
tmpValue = "=" + tmpValue;


strToSave += (sectionPair.Key + tmpValue + "\r\n");
}
}


strToSave += "\r\n";
}


try
{
TextWriter tw = new StreamWriter(newFilePath);
tw.Write(strToSave);
tw.Close();
}
catch (Exception ex)
{
throw ex;
}
}


/// <summary>
/// Save settings back to ini file.
/// </summary>
public void SaveSettings()
{
SaveSettings(iniFilePath);
}
}

读写INI文件

前言

首先，阅读MSDN关于INI文件的局限性的博客文章。如果它符合你的需要，请继续读下去。

这是我写的一个简洁的实现，利用原始的Windows P/Invoke，所以它被安装了。net的所有版本的Windows(即Windows 98 - Windows 11)所支持。我在此将其发布到公共领域-您可以在没有归属的情况下自由地使用它。

小班授课

在你的项目中添加一个名为IniFile.cs的新类:

using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;


// Change this to match your program's normal namespace
namespace MyProg
{
class IniFile   // revision 11
{
string Path;
string EXE = Assembly.GetExecutingAssembly().GetName().Name;


[DllImport("kernel32", CharSet = CharSet.Unicode)]
static extern long WritePrivateProfileString(string Section, string Key, string Value, string FilePath);


[DllImport("kernel32", CharSet = CharSet.Unicode)]
static extern int GetPrivateProfileString(string Section, string Key, string Default, StringBuilder RetVal, int Size, string FilePath);


public IniFile(string IniPath = null)
{
Path = new FileInfo(IniPath ?? EXE + ".ini").FullName;
}


public string Read(string Key, string Section = null)
{
var RetVal = new StringBuilder(255);
GetPrivateProfileString(Section ?? EXE, Key, "", RetVal, 255, Path);
return RetVal.ToString();
}


public void Write(string Key, string Value, string Section = null)
{
WritePrivateProfileString(Section ?? EXE, Key, Value, Path);
}


public void DeleteKey(string Key, string Section = null)
{
Write(Key, null, Section ?? EXE);
}


public void DeleteSection(string Section = null)
{
Write(null, null, Section ?? EXE);
}


public bool KeyExists(string Key, string Section = null)
{
return Read(Key, Section).Length > 0;
}
}
}

如何使用

以以下三种方式之一打开INI文件:

// Creates or loads an INI file in the same directory as your executable
// named EXE.ini (where EXE is the name of your executable)
var MyIni = new IniFile();


// Or specify a specific name in the current dir
var MyIni = new IniFile("Settings.ini");


// Or specify a specific name in a specific dir
var MyIni = new IniFile(@"C:\Settings.ini");

你可以这样写一些值:

MyIni.Write("DefaultVolume", "100");
MyIni.Write("HomePage", "http://www.google.com");

创建一个这样的文件:

[MyProg]
DefaultVolume=100
HomePage=http://www.google.com

从INI文件中读取值:

var DefaultVolume = MyIni.Read("DefaultVolume");
var HomePage = MyIni.Read("HomePage");

你可以选择设置[Section]的值:

MyIni.Write("DefaultVolume", "100", "Audio");
MyIni.Write("HomePage", "http://www.google.com", "Web");

创建一个这样的文件:

[Audio]
DefaultVolume=100


[Web]
HomePage=http://www.google.com

你也可以像这样检查一个键的存在:

if(!MyIni.KeyExists("DefaultVolume", "Audio"))
{
MyIni.Write("DefaultVolume", "100", "Audio");
}

你可以像这样删除一个键:

MyIni.DeleteKey("DefaultVolume", "Audio");

你也可以像这样删除整个section(包括所有键):

MyIni.DeleteSection("Web");

请随时评论任何改进!

joerage回答中的代码是鼓舞人心的。

不幸的是，它改变了键的字符大小写，并且不处理注释。所以我写了一些足够健壮的东西，可以读取(只)非常脏的INI文件，并允许按原样检索密钥。

它使用一些LINQ，一个嵌套的不区分大小写的字符串字典来存储节，键和值，并一次性读取文件。

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


class IniReader
{
Dictionary<string, Dictionary<string, string>> ini = new Dictionary<string, Dictionary<string, string>>(StringComparer.InvariantCultureIgnoreCase);


public IniReader(string file)
{
var txt = File.ReadAllText(file);


Dictionary<string, string> currentSection = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);


ini[""] = currentSection;


foreach(var line in txt.Split(new[]{"\n"}, StringSplitOptions.RemoveEmptyEntries)
.Where(t => !string.IsNullOrWhiteSpace(t))
.Select(t => t.Trim()))
{
if (line.StartsWith(";"))
continue;


if (line.StartsWith("[") && line.EndsWith("]"))
{
currentSection = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
ini[line.Substring(1, line.LastIndexOf("]") - 1)] = currentSection;
continue;
}


var idx = line.IndexOf("=");
if (idx == -1)
currentSection[line] = "";
else
currentSection[line.Substring(0, idx)] = line.Substring(idx + 1);
}
}


public string GetValue(string key)
{
return GetValue(key, "", "");
}


public string GetValue(string key, string section)
{
return GetValue(key, section, "");
}


public string GetValue(string key, string section, string @default)
{
if (!ini.ContainsKey(section))
return @default;


if (!ini[section].ContainsKey(key))
return @default;


return ini[section][key];
}


public string[] GetKeys(string section)
{
if (!ini.ContainsKey(section))
return new string[0];


return ini[section].Keys.ToArray();
}


public string[] GetSections()
{
return ini.Keys.Where(t => t != "").ToArray();
}
}

我想介绍一个完全用c#创建的IniParser库，所以它不包含任何操作系统的依赖关系，这使得它与Mono兼容。MIT许可的开源软件——所以它可以在任何代码中使用。

你可以在GitHub中查看源代码，它是也可以作为NuGet包使用

它是高度可配置的和使用起来非常简单。

很抱歉我不要脸的插播，但我希望它能对那些重新审视这个答案的人有所帮助。

您应该从xml文件读取和写入数据，因为您可以将整个对象保存到xml，也可以从保存的xml填充对象。它最好是一个易于操作的对象。

如果你只是想要一个简单的阅读器没有部分和任何其他dll这里是一个简单的解决方案:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace Tool
{
public class Config
{
Dictionary <string, string> values;
public Config (string path)
{
values = File.ReadLines(path)
.Where(line => (!String.IsNullOrWhiteSpace(line) && !line.StartsWith("#")))
.Select(line => line.Split(new char[] { '=' }, 2, 0))
.ToDictionary(parts => parts[0].Trim(), parts => parts.Length>1?parts[1].Trim():null);
}
public string Value (string name, string value=null)
{
if (values!=null && values.ContainsKey(name))
{
return values[name];
}
return value;
}
}
}

使用示例:

    file = new Tool.Config (Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + "\\config.ini");
command = file.Value ("command");
action = file.Value ("action");
string value;
//second parameter is default value if no key found with this name
value = file.Value("debug","true");
this.debug = (value.ToLower()=="true" || value== "1");
value = file.Value("plain", "false");
this.plain = (value.ToLower() == "true" || value == "1");

配置文件内容同时(如你所见，支持#符号的行注释):

#command to run
command = php


#default script
action = index.php


#debug mode
#debug = true


#plain text mode
#plain = false


#icon = favico.ico

下面是我自己的版本，使用正则表达式。这段代码假设每个节名都是唯一的——如果不是这样的话——用List替换Dictionary是有意义的。此函数支持.ini文件注释，从';'字符开始。Section正常启动[Section]，键值对也正常出现“key = value”。与节相同的假设-键名是唯一的。

/// <summary>
/// Loads .ini file into dictionary.
/// </summary>
public static Dictionary<String, Dictionary<String, String>> loadIni(String file)
{
Dictionary<String, Dictionary<String, String>> d = new Dictionary<string, Dictionary<string, string>>();


String ini = File.ReadAllText(file);


// Remove comments, preserve linefeeds, if end-user needs to count line number.
ini = Regex.Replace(ini, @"^\s*;.*$", "", RegexOptions.Multiline);


// Pick up all lines from first section to another section
foreach (Match m in Regex.Matches(ini, "(^|[\r\n])\\[([^\r\n]*)\\][\r\n]+(.*?)(\\[([^\r\n]*)\\][\r\n]+|$)", RegexOptions.Singleline))
{
String sectionName = m.Groups[2].Value;
Dictionary<String, String> lines = new Dictionary<String, String>();


// Pick up "key = value" kind of syntax.
foreach (Match l in Regex.Matches(ini, @"^\s*(.*?)\s*=\s*(.*?)\s*$", RegexOptions.Multiline))
{
String key = l.Groups[1].Value;
String value = l.Groups[2].Value;


// Open up quotation if any.
value = Regex.Replace(value, "^\"(.*)\"$", "$1");


if (!lines.ContainsKey(key))
lines[key] = value;
}


if (!d.ContainsKey(sectionName))
d[sectionName] = lines;
}


return d;
}

试试这个方法:

public static Dictionary<string, string> ParseIniDataWithSections(string[] iniData)
{
var dict = new Dictionary<string, string>();
var rows = iniData.Where(t =>
!String.IsNullOrEmpty(t.Trim()) && !t.StartsWith(";") && (t.Contains('[') || t.Contains('=')));
if (rows == null || rows.Count() == 0) return dict;
string section = "";
foreach (string row in rows)
{
string rw = row.TrimStart();
if (rw.StartsWith("["))
section = rw.TrimStart('[').TrimEnd(']');
else
{
int index = rw.IndexOf('=');
dict[section + "-" + rw.Substring(0, index).Trim()] = rw.Substring(index+1).Trim().Trim('"');
}
}
return dict;
}

它创建键为“-”的字典。你可以这样加载它:

var dict = ParseIniDataWithSections(File.ReadAllLines(fileName));

如果你只需要读访问而不需要写访问，并且你正在使用Microsoft.Extensions.Confiuration(默认情况下与ASP。你可以使用NuGet包Microsoft.Extensions.Configuration.Ini将ini文件导入到你的配置设置中。

public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddIniFile("SomeConfig.ini", optional: false);
Configuration = builder.Build();
}

PeanutButter.INI是一个用于INI文件操作的nuget打包类。它支持读/写，包括注释-写时保留注释。它似乎相当受欢迎，经过测试，易于使用。它也是完全免费和开源的。

免责声明:我是花生酱ini的作者。

我迟到了，但我今天遇到了同样的问题，我写了下面的实现:

using System.Text.RegularExpressions;


static bool match(this string str, string pat, out Match m) =>
(m = Regex.Match(str, pat, RegexOptions.IgnoreCase)).Success;


static void Main()
{
Dictionary<string, Dictionary<string, string>> ini = new Dictionary<string, Dictionary<string, string>>();
string section = "";


foreach (string line in File.ReadAllLines(.........)) // read from file
{
string ln = (line.Contains('#') ? line.Remove(line.IndexOf('#')) : line).Trim();


if (ln.match(@"^[ \t]*\[(?<sec>[\w\-]+)\]", out Match m))
section = m.Groups["sec"].ToString();
else if (ln.match(@"^[ \t]*(?<prop>[\w\-]+)\=(?<val>.*)", out m))
{
if (!ini.ContainsKey(section))
ini[section] = new Dictionary<string, string>();


ini[section][m.Groups["prop"].ToString()] = m.Groups["val"].ToString();
}
}




// access the ini file as follows:
string content = ini["section"]["property"];
}

要将Dictionary<string, Dictionary<string, string>>的实例序列化为__abc1 -文件，我使用以下代码:

string targetpath = .........;
Dictionary<string, Dictionary<string, string>> ini = ........;
StringBuilder sb = new StringBuilder();


foreach (string section in ini.Keys)
{
sb.AppendLine($"[{section}]");


foreach (string property in ini[section].Keys)
sb.AppendLine($"{property}={ini[section][property]");
}


File.WriteAllText(targetpath, sb.ToString());

这是我的班级，效果非常好:

public static class IniFileManager
{




[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.dll")]
private static extern int GetPrivateProfileSection(string lpAppName,
byte[] lpszReturnBuffer, int nSize, string lpFileName);




/// <summary>
/// Write Data to the INI File
/// </summary>
/// <PARAM name="Section"></PARAM>
/// Section name
/// <PARAM name="Key"></PARAM>
/// Key Name
/// <PARAM name="Value"></PARAM>
/// Value Name
public static void IniWriteValue(string sPath,string Section, string Key, string Value)
{
WritePrivateProfileString(Section, Key, Value, sPath);
}


/// <summary>
/// Read Data Value From the Ini File
/// </summary>
/// <PARAM name="Section"></PARAM>
/// <PARAM name="Key"></PARAM>
/// <PARAM name="Path"></PARAM>
/// <returns></returns>
public static string IniReadValue(string sPath,string Section, string Key)
{
StringBuilder temp = new StringBuilder(255);
int i = GetPrivateProfileString(Section, Key, "", temp,
255, sPath);
return temp.ToString();


}

｝

使用是显而易见的，因为它是一个静态类，只需调用IniFileManager。IniWriteValue用于读取section或IniFileManager。IniReadValue用于读取section。

如果你不需要铃铛和口哨(即部分)，这里有一个班轮:

List<(string, string)> ini = File.ReadLines(filename)
.Select(s => {
var spl = s.Split('=', 2);
return spl.Length == 2 ? (spl[0], spl[1]) : (s, "");
})
.Select(vt => (vt.Item1.Trim(), vt.Item2.Trim()))
.Where(vt => vt.Item1 != "")
.ToList();

写:

File.WriteAllLines(filename, ini.Select(vt => $"{vt.Item1}={vt.Item2}"));

(如果你不关心重复，使用.ToDictionary()代替.ToList()更容易访问)