Leer / escribir un archivo INI


263

¿Hay alguna clase en .NET Framework que pueda leer / escribir archivos .ini estándar:

[Section]
<keyname>=<value>
...

Delphi tiene el TIniFilecomponente y quiero saber si hay algo similar para C #?


RemObjects tiene una biblioteca Delphi Prism llamada ShineOn que incluye una clase de archivo INI similar. Pero debe tener Delphi Prism para compilarlo para .NET desde el origen, ya que aún no hay un ensamblado compilado disponible. code.remobjects.com/p/shineon
Lex Li

1
Tengo el mismo problema e hice mi propia biblioteca para analizar archivos ini: github.com/rickyah/ini-parser Espero que ayude
Ricardo Amores

55
Al igual que Ricky, decidí hacer mi propia solución a esto. Está disponible en: github.com/MarioZ/MadMilkman.Ini
Mario Z

Respuestas:


185

Los creadores de .NET Framework quieren que use archivos de configuración basados ​​en XML, en lugar de archivos INI. Entonces no, no hay un mecanismo incorporado para leerlos.

Sin embargo, hay soluciones de terceros disponibles.


24
Aunque es cierto que los archivos de configuración XML son el camino a seguir, esto aún no es una respuesta a la pregunta, o es VLQ solo para enlaces.
Danny Beckett

66
@aloneguid Yo diría que el gran conjunto de características disponibles realmente contribuyó a que los archivos de configuración de .NET terminen siendo monstruos extraños con mucha magia en ellos. Se han convertido en "código en el archivo de configuración", y esto genera mucha complejidad, comportamientos extraños y dificulta la administración de la configuración. (Te estoy mirando a ti, a los "proveedores" de la base de datos y a las cadenas de conexión). Por lo tanto, los archivos INI también son generalmente mejores para la edición no manual.
jpmc26

1
me gusta el método antiguo (P / Inovke) y puede usar unicode con un método antiguo como este: File.WriteAllBytes (ruta, nuevo byte [] {0xFF, 0xFE});
sailfish009

2
Buen paquete pero podría ser mejor. No puede analizar un valor que contenga '=' O '\ n' completamente
Ahmad Behjati

211

Prefacio

En primer lugar, lea esta publicación de blog de MSDN sobre las limitaciones de los archivos INI . Si se adapta a tus necesidades, sigue leyendo.

Esta es una implementación concisa que escribí, utilizando el Windows P / Invoke original, por lo que es compatible con todas las versiones de Windows con .NET instalado (es decir, Windows 98 - Windows 10). Por la presente, lo libero al dominio público: puede usarlo comercialmente sin atribución.

La pequeña clase

Agregue una nueva clase llamada IniFile.csa su proyecto:

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

Cómo usarlo

Abra el archivo INI de una de las 3 formas siguientes:

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

Puede escribir algunos valores así:

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

Para crear un archivo como este:

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

Para leer los valores del archivo INI:

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

Opcionalmente, puede configurar [Section]:

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

Para crear un archivo como este:

[Audio]
DefaultVolume=100

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

También puede verificar la existencia de una clave como esta:

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

Puede eliminar una clave así:

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

También puede eliminar una sección completa (incluidas todas las teclas) así:

MyIni.DeleteSection("Web");

¡No dude en comentar con cualquier mejora!


44
Llego un poco tarde, pero falta el GetSections()método.
todavía el

2
Tal vez un valor predeterminado más tradicional sería archivos .ini por aplicación (no por ensamblaje) Path.GetFullPath(IniPath ?? Path.ChangeExtension(Application.ExecutablePath, ".ini")).
Eugene Ryabtsev

3
Realmente grandioso ! Ponlo en github?
Emrys Myrooin

2
@danny Beckett, bien hecho. Esto es casi exactamente igual a lo que he usado en los últimos um años de .Net. Actualizado del antiguo código hace años.
Damian

10
Ahora, y por mucho que respeto a Raymond Chen, muchas de las limitaciones en ese artículo eran limitaciones de la biblioteca INI específica en Windows, y no el formato INI en sí. Otros, como los permisos granulares, se pueden eludir fácilmente a través de múltiples archivos. Una biblioteca INI modernizada y oficial sería bienvenida, incluso hoy.
Joel Coehoorn el

68

Este artículo sobre CodeProject " Una clase de manejo de archivos INI usando C # " debería ayudar.

El autor creó una clase de C # "Ini" que expone dos funciones de KERNEL32.dll. Estas funciones son: WritePrivateProfileStringy GetPrivateProfileString. Necesitará dos espacios de nombres: System.Runtime.InteropServicesy System.Text.

Pasos para usar la clase Ini

En la definición del espacio de nombres de su proyecto, agregue

using INI;

Cree un archivo INIF como este

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

Use IniWriteValuepara escribir un nuevo valor en una clave específica en una sección o use IniReadValuepara leer un valor DESDE una clave en una Sección específica.

Nota: si comienza desde cero, puede leer este artículo de MSDN : Cómo: Agregar archivos de configuración de aplicaciones a proyectos de C # . Es una mejor manera de configurar su aplicación.


1
Quiero leer el archivo INI completo. Cómo hacer lo mismo en lugar de leer la sección, clave
venkat

esto funcionó para mí, y luego dejó de funcionar desde otro punto. Ni idea de lo que sigue fue diferente bajo el capó
nawfal

1
Tenga cuidado al usar estas funciones obsoletas de la API Win32. Más información: stackoverflow.com/questions/11451641/…
Pedro77

Utilicé este enfoque durante un tiempo, pero las mejoras de seguridad que comenzaron en Win7 prácticamente me han matado. Todavía puede usar este enfoque, pero tendrá que almacenar el .ini en ProgramData y hacer que su aplicación lea / escriba allí.
Jess

No guarde los archivos ini de configuración de la aplicación en ProgramData. No pertenecen ni al Registro ni a ProgramData. Se supone que los archivos de configuración están en las carpetas LocalApplicationData.
deegee

47

Encontré esta implementación simple:

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

Funciona bien para lo que necesito.

Así es como lo usas:

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

Aquí está el código:

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

38
+1 para compensar el voto negativo anterior. ¿De qué te quejas realmente? Dijo que lo ENCONTRÓ. ¿Lo rechazas por no encontrar uno con acceso genérico y uso de stringbuilder?
Tormod

1
@Tormod: Ojalá pudiera rechazar el comentario. Es un foro técnico cuando votamos por soluciones, no por la intención (obviamente positiva). Si una solución publicada por el mismo Knuth tuviera fallas, debería, y debería, señalarse. No importa si la solución fue encontrada o escrita por el afiche.
ya23

77
Creo que extiendes la definición de "defecto". Si la solución no enfatiza sus sensibilidades, entonces simplemente no vote. Acabo de dejar una nota diciendo que ya negué su voto negativo para que los otros 7 tipos que votaron por mi comentario no lo hicieran ellos mismos.
Tormod

21

El código en la respuesta de joerage es inspirador.

Desafortunadamente, cambia la carcasa de caracteres de las teclas y no maneja los comentarios. Así que escribí algo que debería ser lo suficientemente robusto como para leer (solo) archivos INI muy sucios y permitir recuperar las claves tal como están.

Utiliza algo de LINQ, un diccionario de cadenas insensible a mayúsculas y minúsculas para almacenar secciones, claves y valores, y leer el archivo de una vez.

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

44
y gracias por no poner eso catch (Exception ex) { throw ex; }allí
Mark Schultheiss

1
¡Bueno! Se requieren al menos algunos cambios para funcionar mejor. Línea 16: ini [""] = currentSection; Para: // ini [""] = currentSection; Esto debe eliminarse ya que cada vez que el primer elemento [0] será un segmento vacío debido a esta inicialización. Línea 36: currentSection [line.Substring (0, idx)] = line.Substring (idx + 1); Para: currentSection [line.Substring (0, idx) .Trim ()] = line.Substring (idx + 1) .Trim (); La clave y los valores deben recortarse independientemente, no solo en la línea Recortar. En INI, los archivos de configuración similares a los que agregan pares K-> V tienden a alinear estos iguales dentro de las secciones. ¡Gracias!
LXSoft

Habíamos pasado mucho tiempo. Muchas gracias por tus sugerencias. Todos tienen sentido y merece este código para tener una buena actualización.
Larry

13

Quiero presentar una biblioteca IniParser que he creado completamente en C #, por lo que no contiene dependencias en ningún sistema operativo, lo que lo hace compatible con Mono. Código abierto con licencia MIT, por lo que se puede usar en cualquier código.

Puede consultar la fuente en GitHub , y también está disponible como paquete NuGet

Es muy configurable y realmente fácil de usar .

Perdón por el descarado complemento, pero espero que pueda ser de ayuda para cualquiera que revise esta respuesta.


4

Si solo necesita acceso de lectura y no acceso de escritura y está utilizando el Microsoft.Extensions.Confiuration(viene incluido de forma predeterminada con ASP.NET Core pero también funciona con programas regulares), puede usar el paquete NuGet Microsoft.Extensions.Configuration.Inipara importar archivos ini a sus ajustes de configuración.

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

Solo para agregar que luego obtienes llaves conConfiguration["keyname"]
kofifus

@scott, el problema que tengo es por cualquier razón que IIS no lo reconoce cuando la aplicación se está ejecutando. está desplegado y allí, pero no se está consumiendo. Se devolvió HTTP 500.30 y el registro de la aplicación IIS dice "no se encontró el archivo de configuración y no es opcional".
one.beat.consumer

3

Por lo general, cuando crea aplicaciones usando C # y .NET framework, no usará archivos INI. Es más común almacenar configuraciones en un archivo de configuración basado en XML o en el registro. Sin embargo, si su software comparte configuraciones con una aplicación heredada, puede ser más fácil usar su archivo de configuración, en lugar de duplicar la información en otro lugar.

.NET Framework no admite el uso de archivos INI directamente. Sin embargo, puede utilizar las funciones de la API de Windows con los Servicios de invocación de plataforma (P / Invoke) para escribir y leer los archivos. En este enlace creamos una clase que representa archivos INI y utiliza las funciones de la API de Windows para manipularlos. Por favor, vaya a través del siguiente enlace.

Lectura y escritura de archivos INI


44
¡Manténgase fuera del registro! Los datos de configuración de la aplicación no deben guardarse en el Registro.
deegee

3

Si desea un lector simple sin secciones y cualquier otro dlls, aquí hay una solución simple:

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

Muestra de uso:

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

Mientras tanto, el contenido del archivo de configuración (como ve, admite el símbolo # para el comentario de línea):

#command to run
command = php

#default script
action = index.php

#debug mode
#debug = true

#plain text mode
#plain = false

#icon = favico.ico

3

Prueba este método:

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

Crea el diccionario donde la clave es "-". Puedes cargarlo así:

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

3

PeanutButter.INI es una clase empaquetada por Nuget para la manipulación de archivos INI. Admite lectura / escritura, incluidos los comentarios: sus comentarios se conservan en la escritura. Parece ser razonablemente popular, probado y fácil de usar. También es totalmente gratuito y de código abierto.

Descargo de responsabilidad: soy el autor de PeanutButter.INI.


¿Podría proporcionar un enlace a la documentación de PeanutButter.INI?
Shroombaker


3

Llego tarde a unirme a la fiesta, pero tuve el mismo problema hoy y escribí la siguiente implementación:

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

Cabe señalar que esta implementación no maneja secciones o propiedades que no se encuentran. Para lograr esto, debe extender la Dictionary<,>clase-para manejar claves no encontradas.


Para serializar una instancia de Dictionary<string, Dictionary<string, string>>a .ini-file, utilizo el siguiente código:

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

2

Hay un analizador Ini disponible en CommonLibrary.NET

Esto tiene varias sobrecargas muy convenientes para obtener secciones / valores y es muy ligero.


1
En caso de que no sea obvio mirar el nivel superior de la biblioteca (¡no fue obvio para mí!), La clase IniDcoument y otros están en ComLib.IO.
Tim Keating

2
Para cualquiera que esté mirando esta ruta, CommonLibrary.NET no parece seguir las convenciones .INI. Utiliza dos puntos ":" como delimitador en lugar de signo igual, y no maneja los comentarios (comenzar una línea con un punto y coma o un signo de libra causará que el análisis falle).
jmmr

2

Aquí está mi propia versión, usando expresiones regulares. Este código asume que el nombre de cada sección es único, si esto no es cierto, tiene sentido reemplazar Diccionario por Lista. Esta función admite comentarios de archivos .ini, comenzando desde ';' personaje. La sección comienza normalmente [sección], y los pares de valores clave también vienen normalmente "clave = valor". El mismo supuesto que para las secciones: el nombre de la clave es único.

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

Esa función no funciona, para mí: olvida una sección en dos. Intenté con y sin líneas vacías antes de [Sección].
iksess

¿Puedes copiar un ejemplo de tu .ini que no funciona?
TarmoPikaro

-3

Aquí está mi clase, funciona como un encanto:

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

    }

}

El uso es obvio ya que es una clase estática, solo llame a IniFileManager.IniWriteValue para leer una sección o IniFileManager.IniReadValue para leer una sección.


Este enfoque ya se ha mostrado y explicado en otra respuesta . ¿Qué agrega su respuesta que no está cubierta por esa?
Palec

Tenga en cuenta que solo funciona si el archivo .ini se guarda en UNICODE (16bit LE). Use Notepad ++ para convertir el texto a unicode, porque si lo guarda en UTF-8 no funcionará. También ANSI es aceptable, pero no puede leer letras acentuadas
user2991288

-6

Debe leer y escribir datos de archivos xml ya que puede guardar un objeto completo en xml y también puede completar un objeto desde un xml guardado. Es mejor un objeto fácil de manipular.

Aquí se explica cómo hacerlo: escriba datos de objetos en un archivo XML: https://msdn.microsoft.com/en-us/library/ms172873.aspx Lea datos de objetos de un archivo XML: https://msdn.microsoft. com / es-us / library / ms172872.aspx


1
Se recomiendan enlaces a recursos externos, pero agregue contexto alrededor del enlace para que sus usuarios tengan una idea de qué es y por qué está allí. Siempre cite la parte más relevante de un enlace importante, en caso de que no se pueda acceder al sitio de destino o se desconecte permanentemente.
davejal

Creo que los títulos de los enlaces son muy claros sobre sus referencias / contexto. Si crees que no es suficiente, edítalo.
Daniel

1
No aborda la pregunta real.
Erik Knowles
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.