ruta - leer archivo properties java web

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

Question

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

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

¿Tiene .NET un equivalente horneado? Claro, podría hacer lo mismo con un archivo XML, pero preferiría no tener que escribir manualmente 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 buena.

(Barra lateral: No puedo creer que esto no haya sido preguntado aquí, pero no pude encontrar esa pregunta).

Editar:

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

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

Answer 1

Hay un componente de terceros llamado 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); } } }

El archivo ''demo.ini'' de la muestra anterior sería:

[Demo] demoVal = foobar

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

Answer 2

He escrito una pequeña biblioteca de configuración de .NET llamada DotNet.Config que utiliza archivos de propiedad simples basados ​​en texto inspirados en los archivos de propiedad de Java. Incluye algunas características agradables para facilitar la carga. Puedes tomar una copia aquí:

DotNet.Config

Answer 3

La forma .NET es usar un archivo de configuración . El marco .NET incluso ofrece una API para trabajar con ellos .

Answer 4

No pude encontrar una solución de similer para el archivo de propiedades de lectura usando c #. Pude escribir un código propio usando c # para obtener el mismo resultado que en Java.

Sigue 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 los archivos de propiedades es mucho más fácil de usar que el acceso a los archivos XML.

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

Answer 5

Personalmente me gusta esta pieza 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 6

Puede lograr una funcionalidad similar a los archivos de propiedades utilizando los archivos de configuración incorporados (en VS, agregue un nuevo "Archivo de configuración"), pero aún está basado en XML.

Puede acceder a la configuración utilizando la clase de Configuración generada automáticamente, e incluso actualizarla y guardarla de nuevo en el archivo de configuración, todo sin escribir ninguno de los códigos de la plantilla. Los ajustes son muy de tipo y se pueden especificar como "Usuario" (guardado en la carpeta de datos de la aplicación) o "Aplicación" (guardado en la misma carpeta que el archivo ejecutable).