Odczyt/zapis pliku INI

Przedmowa

Po pierwsze, przeczytaj ten wpis na blogu MSDN na temat ograniczeń plików INI. Jeśli odpowiada twoim potrzebom, Czytaj dalej.

Jest to zwięzła implementacja, którą napisałem, wykorzystująca Oryginalny Windows P / Invoke, więc jest obsługiwana przez wszystkie wersje Windows z zainstalowanym. NET (tj. Windows 98 - Windows 10). Niniejszym wypuszczam go do domeny publicznej - możesz używać go komercyjnie bez atrybucji.

Mała klasa

Dodaj nową klasę o nazwie IniFile.cs do twojego projektu:

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;
        }
    }
}

Jak go używać

Otwórz plik INI na jeden z 3 następujących sposobów:

// 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");

Możesz napisać kilka wartości w ten sposób:

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

Aby utworzyć taki plik:

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

Aby odczytać wartości z pliku INI:

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

Opcjonalnie można ustawić [Section] ' S:

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

Aby utworzyć taki plik:

[Audio]
DefaultVolume=100

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

Możesz również sprawdzić istnienie klucza w ten sposób:

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

Możesz usunąć klucz taki jak więc:

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

Możesz również usunąć całą sekcję (łącznie ze wszystkimi kluczami) w następujący sposób:

MyIni.DeleteSection("Web");

Zapraszam do komentowania wszelkich ulepszeń!

Ten artykuł o CodeProject " Klasa obsługi plików INI przy użyciu C#" powinien pomóc.

Autor stworzył klasę C# "Ini", która eksponuje dwie funkcje z KERNEL32.dll. Funkcje te to: WritePrivateProfileString i GetPrivateProfileString. Będziesz potrzebował dwóch przestrzeni nazw: System.Runtime.InteropServices i System.Text.

Kroki do użycia klasy Ini

W definicji przestrzeni nazw projektu Dodaj

using INI;

Utwórz plik INIFile w ten sposób

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

Użyj IniWriteValue, aby zapisać nową wartość do określonego klucza w sekcji lub użyj IniReadValue, aby odczytać wartość z klucza w określonej sekcji.

uwaga: jeśli zaczynasz od zera, możesz przeczytać ten artykuł MSDN: Jak: dodać pliki konfiguracyjne aplikacji do projektów C# . To lepszy sposób na konfigurację aplikacji.

Znalazłem taką prostą implementację:

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

Oto jak go używasz:

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();
    }
}

Oto kod:

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);
    }
}

Kod w odpowiedzi joerage ' a jest inspirujący.

Niestety zmienia obudowę znaków klawiszy i nie obsługuje komentarzy. Napisałem więc coś, co powinno być wystarczająco wytrzymałe, aby odczytać (tylko) bardzo brudne pliki INI i umożliwić odzyskanie kluczy w takim stanie, w jakim są.

Używa LINQ, zagnieżdżonego słownika znaków niewrażliwych na wielkość liter do przechowywania sekcji, kluczy i wartości oraz odczytu pliku za jednym zamachem.

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();
    }
}

Chcę wprowadzić bibliotekę Iniparsera, którą stworzyłem całkowicie w c#, więc nie zawiera żadnych zależności w żadnym systemie operacyjnym, co czyni ją kompatybilną Mono. Open Source z licencją MIT-dzięki czemu można go używać w dowolnym kodzie.

Możesz sprawdzić źródło w GitHub , i jest również dostępny jako pakiet NuGet

Jest to mocno konfigurowalne , i naprawdę proste w użyciu .

Przepraszam za bezwstydną wtyczkę, ale mam nadzieję, że przyda się każdemu wracając do tej odpowiedzi.

Jeśli potrzebujesz tylko dostępu do odczytu, a nie zapisu i używasz Microsoft.Extensions.Confiuration (jest domyślnie dołączony z ASP.NET Core, ale współpracuje również ze zwykłymi programami) można użyć pakietu NuGet Microsoft.Extensions.Configuration.Ini Aby zaimportować pliki ini do ustawień konfiguracyjnych.

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

PeanutButter.INI jest klasą NuGet-packaged służącą do manipulacji plikami INI. Obsługuje odczyt/zapis, w tym Komentarze – Twoje komentarze są zachowywane podczas zapisu. Wydaje się być dość popularny, jest testowany i łatwy w użyciu. Jest również całkowicie darmowy i open-source.

Disclaimer: jestem autorem PeanutButter.INI.

Jeśli chcesz tylko prosty czytnik bez sekcji i żadnych innych DLL tutaj jest proste rozwiązanie:

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;
        }
    }
}

Próbka użycia:

    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");

Zawartość pliku konfiguracyjnego (jak widzisz obsługuje symbol # dla komentarza linii):

#command to run
command = php

#default script
action = index.php

#debug mode
#debug = true

#plain text mode
#plain = false

#icon = favico.ico

Zazwyczaj, gdy tworzysz aplikacje używając C# i. NET framework, nie będziesz używać plików INI. Bardziej powszechne jest przechowywanie ustawień w pliku konfiguracyjnym opartym na XML lub w rejestrze. Jeśli jednak twoje oprogramowanie współdzieli ustawienia ze starszą aplikacją, może być łatwiejsze użycie jej pliku konfiguracyjnego zamiast powielania informacji w innym miejscu.

. NET framework nie obsługuje bezpośrednio plików INI. Można jednak korzystać z funkcji Windows API z Platform Invocation Services (P / Invoke) do zapisu i odczytu plików. W tym linku tworzymy klasę, która reprezentuje pliki INI i używa funkcji Windows API do manipulowania nimi. Proszę przejść przez poniższy link.

Odczyt i zapis plików INI

Wypróbuj tę metodę:

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;
}

Tworzy słownik, w którym kluczem jest" -". Możesz go załadować TAK:

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

Jestem spóźniony, aby dołączyć do partii, ale miałem dziś ten sam problem i napisałem następującą implementację:

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"];
}

Należy zauważyć, że implementacja ta nie obsługuje sekcji lub właściwości, które nie zostały znalezione. Aby to osiągnąć, należy rozszerzyć klasę Dictionary<,>-tak, aby obsługiwała klucze unfound.

Aby serializować instancję Dictionary<string, Dictionary<string, string>> do pliku .ini, używam następującego kodu:

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());

Istnieje Parser Ini dostępny w CommonLibrary.NET

Ma to różne bardzo wygodne przeciążenia dla uzyskania sekcji / wartości i jest bardzo lekki.

Oto moja własna wersja, używająca wyrażeń regularnych. Ten kod zakłada, że każda nazwa sekcji jest unikalna - jeśli jednak nie jest to prawdą-sensowne jest zastąpienie słownika listą. Ta funkcja obsługuje .komentowanie pliku ini, zaczynające się od znaku';'. Sekcja zaczyna się normalnie [section], A pary wartości klucza również są normalnie "klucz = wartość". To samo założenie co dla sekcji - Nazwa klucza jest unikalna.

/// <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;
}

Oto moja klasa, działa jak czar:

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();

    }

}

Użycie jest obviouse ponieważ jest klasą statyczną, wystarczy wywołać IniFileManager.IniWriteValue do odczytu sekcji lub Inifilemanagera.IniReadValue do czytania sekcji.

Powinieneś odczytywać i zapisywać dane z plików xml, ponieważ możesz zapisać cały obiekt do xml, a także możesz wypełnić obiekt z zapisanego xml. Lepiej jest łatwo manipulować obiektami.

Oto Jak to zrobić: Zapis danych obiektu do pliku XML: https://msdn.microsoft.com/en-us/library/ms172873.aspx Odczyt Danych obiektu z pliku XML: https://msdn.microsoft.com/en-us/library/ms172872.aspx