Fa .NET dispone di un equivalente di Java .i file di proprietà?

Question

Per fare jogging la memoria di tutti, Java ha questi file con estensione ".proprietà", che sono fondamentalmente un file di testo ASCII pieno di coppie chiave-valore.Il quadro è veramente alcuni semplici modi per succhiare il file in (essenzialmente) una fantasia hashmap.

I due grandi vantaggi (per come la vedo io) di essere estrema facilità sia a mano, l'editing e la lettura/scrittura.

Fa .NET hanno un equivalente cotta nel forno?Certo, potrei fare lo stesso con un file XML, ma preferisco non avere a che tipo di mano di tutti coloro parentesi angolari, se sai cosa voglio dire.Inoltre, un modo per succhiare tutti i dati in una struttura di dati in memoria in una sola riga è troppo bella.

(Barra laterale:Io non posso credere che questo non è stato chiesto già qui, ma non riuscivo a trovare una tale domanda).

Edit:

Per rispondere alla domanda implicita da alcuni commenti, io non sto cercando un modo per specificamente leggere java .i file di proprietà sotto .NET, sto cercando l'equivalente funzionale nel .NET universo.(E speravo che non sarebbe basato su XML, avendo apparentemente dimenticato che questo è .NET stiamo parlando).

E, mentre i file di configurazione sono chiudere, Ho bisogno di memorizzare alcune stringhe arbitrarie, non app config informazioni, in modo che la messa a fuoco e di design dei file di configurazione sembrava off-base.

Answer 1

È possibile ottenere un simile pezzo di funzionalità per le proprietà di file utilizzando il built in i file di impostazioni (in VS, aggiungere un nuovo "file delle Impostazioni") - ma è ancora basato su XML.

È possibile accedere alle impostazioni di utilizzare l'auto-generato Impostazioni di classe, e anche al loro aggiornamento e salvare il file di configurazione di tutti, senza scrivere il codice boilerplate.Le impostazioni sono fortemente tipi, e può essere specificato come "Utente" (salvati all'utente cartella Application Data) o "Applicazione" (salvato nella stessa cartella dell'exe in esecuzione).

Answer 2

L' .NET modo è quello di utilizzare un file di configurazione.L' .NET framework offre anche un'API per lavorare con loro.

Answer 3

C'è una componente di terze parti chiamato nini, che può essere trovato alla sourceforge.net

Per un esempio:

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

}

L'esempio precedente 'la demo.ini " file sarebbe:

[Demo]
demoVal = foobar

Se il valore di demoVal è null o vuoto, per impostazione predefinita string.Empty.

Answer 4

I didnt in grado di trovare un similer soluzione per la lettura di file di proprietà utilizzando c#.Sono stato in grado di scrivere un codice in c# per ottenere lo stesso risultato come in java.

Seguire è il codice:

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

La Mia Idea-

Personalmente credo che le Proprietà di accesso ai file è molto più facile per l'utente di accedere ai file XML.

Quindi, Se si tenta di esternare alcune proprietà dell'attributo migliore per utilizzare le Proprietà del file di XML.

Answer 5

Ho scritto un piccolo .Configurazione di rete libreria chiamata DotNet.Config che usa un testo semplice in base file di proprietà ispirato da Java .i file di proprietà.Esso include alcune caratteristiche per facilitare il caricamento.È possibile prendere una copia qui:

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

Answer 6

Personalmente mi piace questo pezzo di codice che ho trovato sul Web.Si tratta di un personale modo di leggere/scrivere in un file di proprietà.

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

Esempio di utilizzo:

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