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

Question

Para activar la memoria de todos, Java tiene estos archivos con una extensión de ".properties", que básicamente son un archivo de texto ASCII lleno de pares clave-valor. El marco tiene algunas maneras realmente fáciles de chupar ese archivo en (esencialmente) un hashmap de lujo.

Las dos grandes ventajas (como yo lo veo) son la facilidad extrema de la edición manual y la lectura/escritura.

¿.NET tiene un horno cocido equivalente? Claro, podría hacer lo mismo con un archivo XML, pero preferiría no tener que escribir a mano todos esos corchetes angulares, si sabes a qué me refiero. Además, una forma de absorber todos los datos en una estructura de datos en la memoria en una línea también es agradable.

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

Editar:

Para responder a la pregunta implícita en algunos de los comentarios, no estoy buscando una manera de leer específicamente archivos java .properties bajo .NET, estoy buscando el equivalente funcional en el universo .NET. (Y esperaba que no estuviera basado en XML, aparentemente había olvidado que esto es .NET de lo que estamos hablando.)

Y, mientras que los archivos de configuración son cerrar, necesito forma de almacenar algunos cadenas arbitrarias, no 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 base.

Answer 1

Puede lograr una funcionalidad similar a los archivos de propiedades usando el built in settings files (en VS, agregue un nuevo "archivo de configuración") - pero todavía está basado en XML.

Puede acceder a la configuración utilizando la clase de configuraciones generadas automáticamente, e incluso actualizarlas y guardarlas nuevamente en el archivo de configuración, todo sin escribir ningún código repetitivo. Los ajustes son de tipo fuerte y pueden especificarse como "Usuario" (guardado en la carpeta de Datos de aplicación del usuario) o "Aplicación" (guardados en la misma carpeta que el ejecutable).

Answer 2

La forma de .NET es usar un configuration file. El .NET framework incluso ofrece an API for working with them.

Answer 3

Hay un componente de terceros llamado nini que se pueden encontrar en sourceforge.net

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

} 

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

 
[Demo] 
demoVal = foobar 

Si el valor de demoVal es nulo o está vacío, su valor predeterminado es string.Empty.

Answer 4

Personalmente, me gusta este fragmento de código que encontré en la Web. Es una forma personalizada de 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() 

Answer 5

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

seguir 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-

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

Por lo tanto, si intenta externalizar alguna propiedad de atributo mejor utilizar el archivo de propiedades que XML.

Answer 6

He escrito una pequeña biblioteca de configuración .NET llamada DotNet.Config que utiliza archivos de propiedades basados ​​en texto simple inspirados en los archivos .property de Java. Incluye algunas características agradables para una carga fácil. Puede hacerse con una copia aquí:

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