Does .NET haben ein Äquivalent zu Java .properties-Dateien?

Question

Um Jog jeden Speicher, hat Java diese Dateien mit der Erweiterung „.properties“, die im Grunde eine ASCII-Textdatei Paare volle Schlüssel-Wertes sind. Der Rahmen hat einige wirklich einfache Möglichkeiten, die Datei in (im Wesentlichen) ein schickes hashmap zu saugen.

Die beiden großen Vorteile (wie ich es sehe) ist extreme Einfachheit in der Hand Bearbeitung und Lesen / Schreiben.

Does .NET haben ein Äquivalent eingebrannt? Sicher, ich könnte das gleiche mit einer XML-Datei tun, aber ich habe lieber nicht zu handart alle diesen spitzen Klammern, wenn Sie wissen, was ich meine. Auch eine Möglichkeit, alle die Daten in eine Datenstruktur im Speicher in einer Linie zu saugen ist schön zu.

(Sidebar: Ich Art kann nicht glauben, dies war hier nicht gefragt, schon, aber ich konnte eine solche Frage nicht finden.)

Edit:

die Frage von einigen der Kommentare implizierten zu beantworten, ich bin nicht auf der Suche nach einem Weg, um speziell lesen java .properties Dateien unter .NET, ich bin für die funktionale Äquivalent in .NET Universum suchen. (Und ich hatte gehofft, dass es nicht auf XML-Basis wäre, offenbar vergessen zu haben, dass dies .NET wir reden.)

Und während Konfigurationsdateien sind schließen , ich brauche Weg, um einige willkürliche Zeichenfolgen zu speichern, nicht app Config-Informationen, so dass die Ausrichtung und Gestaltung von Konfigurationsdateien schien off-base.

Answer 1

Sie können ein ähnliches Stück Funktionalität zu Eigenschaftsdateien erreichen mit dem eingebauten in Einstellungsdateien (in VS, fügen sie eine neue "Einstellungsdatei".) - aber es ist immer noch XML-basierte

Sie können die Einstellungen Zugriff auf die automatisch generierte Settings-Klasse verwendet wird, und aktualisieren Sie sie selbst und speichern Sie sie in der Konfigurationsdatei zurück - und das alles, ohne dass der Textvorschlag Code zu schreiben. Die Einstellungen sind stark Typen und können als „User“ angegeben werden (gespeichert auf den Anwendungsdatenordner des Benutzers) oder „Application“ (im selben Ordner wie der Lauf exe gespeichert).

Answer 2

Der .NET-Weg ist die Verwendung eines Konfigurationsdatei . Die .NET-Framework auch Angebote eine API für die Arbeit mit ihnen .

Answer 3

Es gibt eine dritte Partei Komponente Nini genannt, die unter sourceforge.net

Ein Beispiel:

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

}

Die von oben Probe 'demo.ini' Datei wäre:

[Demo]
demoVal = foobar

Wenn der Wert von demoVal null oder leer ist, wird standardmäßig string.Empty.

Answer 4

Ich nicht die Lage, eine similer Lösung für die Leseeigenschaften Datei zu finden, indem c # verwenden. Ich konnte durch die Verwendung c # einen eigenen Code schreiben, um das gleiche Ergebnis wie gleiche wie in Java zu erhalten.

Folgen ist der Code:

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

Meine Ideen-

Ich persönlich glaube, dass Eigenschaften Dateizugriff viel mehr ist einfach zu Benutzer als XML-Dateien zugreifen.

Also, wenn Sie versuchen, besser, einige Attributeigenschaft externalisieren als XML Properties-Datei zu verwenden.

Answer 5

Ich habe eine kleine .NET-Konfigurationsbibliothek geschrieben namens DotNet.Config dass Anwendungen einfacher Text Basis Eigenschaftsdateien inspiriert von Java .property Dateien. Es enthält einige nette Features für eine einfache Beladung. Sie können hier eine Kopie greifen:

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

Answer 6

Ich persönlich mag dieses Stück Code fand ich im Internet. Es ist ein Personnalized Weg / Schreiben in einer Properties-Datei zu lesen.

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

Beispiel für die Verwendung:

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