¿El .NET tiene un equivalente a los archivos .properties de Java?

Question

la memoria de

Para correr todos, Java tiene estos archivos con la extensión ".properties", que son, básicamente, un archivo de texto ASCII lleno de pares de valores clave. El marco tiene algunas maneras muy fáciles para chupar ese archivo en (esencialmente) un HashMap fantasía.

Los dos grandes ventajas (como yo lo veo) que es la extrema facilidad de ambos y la lectura de la mano de edición / escritura.

¿El .NET tienen un equivalente al horno en? Claro, yo podría hacer lo mismo con un archivo XML, pero yo prefiero no tener a mano tipo todos los soportes de ángulo, si sabes lo que quiero decir. Además, una manera de aspirar todos los datos en una estructura de datos en la memoria en una sola línea es también muy bueno.

(Recuadro: Yo como que no se puede creer que esto no se ha pedido aquí ya, pero no pude encontrar tal pregunta.)

Editar:

Para responder a la pregunta implícita en algunos de los comentarios, yo no estoy buscando una manera de archivos .properties java leer específicamente en .NET, estoy buscando el equivalente funcional en el universo .NET. (Y esperaba que no sería, al parecer, haber olvidado que se trata de .NET que estamos hablando basado en XML.)

Y, mientras que los archivos de configuración son cerrar , necesito manera de almacenar algunas cadenas arbitrarias, no la información de configuración de la aplicación, por lo que el enfoque y el diseño de los archivos de configuración parecían fuera de la base.

Answer 1

Se puede lograr una pieza similar de funcionalidad para archivos de propiedades utilizando el construido en el configuración de archivos (en VS, añadir un nuevo "archivo de configuración") -. pero sigue siendo basada en XML

Se puede acceder a la configuración utilizando la clase configuración generada automáticamente, e incluso actualizar ellos y volver a guardarlos en el archivo de configuración - todo sin necesidad de escribir código repetitivo de la. Los ajustes son fuertemente tipos, y pueden especificarse como "Usuario" (se guardan en la carpeta de datos de aplicación del usuario) o "aplicación" (guardado en la misma carpeta que el archivo ejecutable en ejecución).

Answer 2

La forma .NET es el uso de un archivo de configuración . Las ofertas incluso marco .NET una API para trabajar con ellos .

Answer 3

Hay un tercer componente parte llamada nini que se puede encontrar en sourceforge.net

Para un ejemplo:

using Nini;
using Nini.Config;

namespace niniDemo{
   public class niniDemoClass{
       public bool LoadIni(){
            string configFileName = "demo.ini";
            IniConfigSource configSource = new IniConfigSource(configFileName);

            IConfig demoConfigSection = configSource.Configs["Demo"];
            string demoVal = demoConfigSection.Get("demoVal", string.Empty);
       }
   }

}

file 'demo.ini' del ejemplo anterior sería:

[Demo]
demoVal = foobar

Si el valor de demoVal es nulo o vacío, que por defecto es string.Empty.

Answer 4

Yo aún no ha podido encontrar una solución similer para el archivo de propiedades de lectura mediante el uso de C #. Yo era capaz de escribir un código propio mediante el uso de C # para obtener el mismo resultado que el mismo que en java.

Seguimiento es el código:

 // watchValue- Property attribute which you need to get the value;
 public string getProperty(string watchValue) 
    {
       // string propertiesfilename= @"readFile.properties";

        string[] lines = System.IO.File.ReadAllLines(propertiesfilename);
            for (int i = 0; i < lines.Length; i++)
            {
                string prop_title = Regex.Split(lines[i], "=")[0].Trim();
                if (prop_title == watchValue)
                    return Regex.Split(lines[i], "=")[1].Trim();
            }
            return null;
    }

Mi idea-

En lo personal creo que el acceso a archivos de propiedades es mucho más fácil para el usuario de acceder a archivos XML.

Así que si intenta exteriorizar alguna propiedad atributo mejor utilizar el archivo de propiedades de XML.

Answer 5

He escrito una pequeña biblioteca de configuración de .NET llamada DotNet.Config que los usos de texto simple archivos de propiedades basadas inspiran en los archivos .property de Java. Incluye algunas características interesantes para facilitar la carga. Puede hacerse con una copia aquí:

https://github.com/jknight/DotNet.Config

Answer 6

Personalmente, me gusta esta pieza de código que encontré en la web. Es una manera personalizados existentes para leer / escribir en un archivo de propiedades.

public class Properties
{
    private Dictionary<String, String> list;

    private String filename;

    public Properties(String file)
    {
        reload(file);
    }

    public String get(String field, String defValue)
    {
        return (get(field) == null) ? (defValue) : (get(field));
    }
    public String get(String field)
    {
        return (list.ContainsKey(field))?(list[field]):(null);
    }

    public void set(String field, Object value)
    {
        field = this.trimUnwantedChars(field);
        value = this.trimUnwantedChars(value);

        if (!list.ContainsKey(field))
            list.Add(field, value.ToString());
        else
            list[field] = value.ToString();
    }

    public string trimUnwantedChars(string toTrim)
    {
        toTrim = toTrim.Replace(";", string.Empty);
        toTrim = toTrim.Replace("#", string.Empty);
        toTrim = toTrim.Replace("'", string.Empty);
        toTrim = toTrim.Replace("=", string.Empty);
        return toTrim;
    }

    public void Save()
    {
        Save(this.filename);
    }

    public void Save(String filename)
    {
        this.filename = filename;

        if (!System.IO.File.Exists(filename))
            System.IO.File.Create(filename);

        System.IO.StreamWriter file = new System.IO.StreamWriter(filename);

        foreach(String prop in list.Keys.ToArray())
            if (!String.IsNullOrWhiteSpace(list[prop]))
                file.WriteLine(prop + "=" + list[prop]);

        file.Close();
    }

    public void reload()
    {
        reload(this.filename);
    }

    public void reload(String filename)
    {
        this.filename = filename;
        list = new Dictionary<String, String>();

        if (System.IO.File.Exists(filename))
            loadFromFile(filename);
        else
            System.IO.File.Create(filename);
    }

    private void loadFromFile(String file)
    {
        foreach (String line in System.IO.File.ReadAllLines(file))
        {
            if ((!String.IsNullOrEmpty(line)) &&
                (!line.StartsWith(";")) &&
                (!line.StartsWith("#")) &&
                (!line.StartsWith("'")) &&
                (line.Contains('=')))
            {
                int index = line.IndexOf('=');
                String key = line.Substring(0, index).Trim();
                String value = line.Substring(index + 1).Trim();

                if ((value.StartsWith("\"") && value.EndsWith("\"")) ||
                    (value.StartsWith("'") && value.EndsWith("'")))
                {
                    value = value.Substring(1, value.Length - 2);
                }

                try
                {
                    //ignore duplicates
                    list.Add(key, value);
                }
                catch { }
            }
        }
    }
}

Ejemplo de uso:

//load
Properties config = new Properties(fileConfig);
//get value whith default value
com_port.Text = config.get("com_port", "1");
//set value
config.set("com_port", com_port.Text);
//save
config.Save()