18. Feb 2019
Lesedauer 21 Min.
Software konfigurieren
XML, SOAP, JSON, TOML, YAML und co.
Formate für Konfigurationsdaten und wie Sie diese verarbeiten.
Bild: Vietmeier
Schon seit es Windows-Programme gibt, lassen diese sich von außen konfigurieren, beispielsweise durch die im System hinterlegten Umgebungsvariablen, durch Initialisierungsdateien, über in der Systemregistrierung (Registry) hinterlegte Werte oder durch explizit dafür geschaffene Konfigurationsdateien. Reine Konsolenanwendungen nutzten auch schon vor Windows Kommandozeilenschalter, um zum Zeitpunkt des Programmstarts eine Konfiguration auswählen zu können. In modernen Anwendungen mit grafischen Benutzeroberflächen stehen weitaus mehr Optionen für die Konfiguration der Software zur Verfügung, und selbstverständlich kann jedes Programm mehrere oder alle Optionen für sich nutzen – von Umgebungsvariablen über die Registry bis zu individuellen Konfigurationsdateien.Selbst Programme, die keine offengelegten Konfigurationsfunktionen bieten, nutzen in der Regel diverse Systemeinstellungen, die über die Registry verwaltet werden. Sie regeln beispielsweise das Aussehen von Dialogen, das Verhalten von Eingabegeräten, geben die Systemfarben vor oder nutzen die interne Konfiguration von Druckern, Netzwerk, System oder Internet. Dies erklärt auch, dass viele Anwendungen Systemdialoge zur Konfiguration anbinden, um Anwendern diese Einstellungen direkt im Programm anzubieten.Die Registry als Zentrum für Konfigurationsdaten zu nutzen birgt den Nachteil, dass diese – da sie schon mit einer großen Menge Betriebssystemdaten beladen ist – mit der Zeit sehr, sehr groß wird. Zumal viele Anwendungen beim Deinstallieren die von ihnen in der Registry abgelegten Daten nicht entfernen.Bei der Konzeption eigener Programme müssen Sie deshalb entscheiden, ob Sie Einstellungen, die der Anwender vornimmt, in der Registry oder in einer externen Konfigurationsdatei ablegen wollen. Wichtig ist außerdem, zu entscheiden, ob das Bearbeiten der Konfigurationsdaten ausschließlich in der eigenen Anwendung oder auch über externe Programme möglich sein soll – etwa über Texteditoren oder den Registrierungseditor. Abhängig von Ihrer Entscheidung wählen Sie ein Konfigurationsdateiformat, das Sie wahlweise komprimieren und/oder verschlüsseln. Optional schränken Sie die Bearbeitung der Einstellungen über Benutzer-Accounts oder Rechte ein.
Einstellungen verwalten
In Bild 1 sehen Sie die allgemeine Vorgehensweise beim Verwalten von Konfigurationsdaten. Einstellungen, die der Anwender nicht ändern darf, werden auf feste Werte gesetzt und intern verwaltet. Das Ändern der Standardwerte erfordert eine Änderung des Quelltextes.
Programmeinstellungenverwalten(Bild 1)
Autor
Für Einstellungen, die der Anwender ändern darf, werden ebenfalls Vorgabewerte vergeben. Das Anpassen dieser Werte erfolgt bevorzugt über einen Optionendialog, den die Anwendung selbst verwaltet und nach Bedarf anzeigt. Der Dialog sorgt dafür, dass nur gültige Werte akzeptiert werden. Die Einstellungen werden direkt übernommen und gesichert, und zwar wahlweise in der Registry oder in einer beziehungsweise mehreren Konfigurationsdateien. Beim Speichern in der Registry geben Sie den Zielknoten an. Die Einstellungen werden im Zielknoten über Schlüsselnamen und zugeordnete Werte abgelegt.Bei den externen Konfigurationsdateien geben Sie an, welcher Speicherort – sinnvoll sind zum Beispiel das AppData-Verzeichnis, das Programmverzeichnis oder das Datenverzeichnis der Anwendung – und welches Format genutzt werden. Ferner vergeben Sie einen eindeutigen Dateinamen. Der Hauptdateiname entspricht hier häufig dem Namen der Anwendung oder gibt den Funktionsbereich wieder, wenn Einstellungen in unterschiedliche Konfigurationsdateien gesplittet werden – zum Beispiel Folder.ini für das Verwalten von Arbeitsverzeichnissen.Die Verwaltung von Werten variiert je nachdem, für welches Format Sie sich entschieden haben. Neben Standardformaten (zum Beispiel INI, XML, JSON) sind auch benutzerdefinierte Formate denkbar.Sind die aus der Registry oder aus externen Konfigurationsdateien gelesenen Daten fehlerhaft, beispielsweise weil sie über externe Programme ohne Prüflogik verändert wurden, oder weil sie aufgrund von Defekten nicht mehr lesbar sind, sind die im Quellcode hinterlegten Vorgabewerte über interne Kontrollfunktionen wiederherzustellen.Die im Code hinterlegten Vorgabewerte stellen sicher, dass immer alle wichtigen Einstellungswerte vorhanden sind. Nicht nur, wenn sie noch nicht in der Registry oder in einer Konfigurationsdatei hinterlegt wurden – etwa beim ersten Aufruf der Anwendung, oder wenn die Werte nicht durch ein Installationsprogramm angelegt worden sind. Das Überschreiben der Vorgabewerte findet folglich nur statt, wenn die Werte geändert wurden, gültig sind und sich aus der Registry oder einer Konfigurationsdatei auslesen lassen.Die Anwendung kennt den Speicherort, das Format und auch die Schlüsselnamen für den Zugriff auf die Einstellungen. Wird mit externen Konfigurationsdateien gearbeitet, so werden die Standard-Konfigurationsdaten häufig als Ressourcen in der Programmdatei abgelegt und beim ersten Programmstart extrahiert.Die Entscheidung, ob Sie für das Speichern von Konfigurationsdaten eigenständige Konfigurationsdateien oder die Registry benutzen, sollten Sie davon abhängig machen, um wie viele Werte es dabei geht und ob diese verschleiert werden sollen (etwa Aktivierungsschlüssel). Externe Konfigurationsdateien haben Vorteile, da sie nicht auf bestimmte Formate beschränkt sind, die Serialisierungsfunktionen von .NET nutzen können und man durch Verschlüsselung das unerwünschte Editieren unterbinden kann. Auch mit binären Formaten oder komprimierten Daten lässt sich das Bearbeiten der Daten erschweren. Übrigens lassen sich auch in der Registry hinterlegte Daten verschlüsseln und damit das direkte Auslesen verhindern.Ist das Ziel, das Bearbeiten der Konfiguration so einfach wie möglich zu gestalten, nutzen Sie für die externen Konfigurationsdateien einfache Textformate, wie beispielsweise INI, XML, JSON oder SOAP.Bleibt abschließend, noch einmal auf die Speicherorte für externe Konfigurationsdateien hinzuweisen. Obgleich diese in der Regel im Anwendungsverzeichnis oder dem anwendungsspezifischen Ordner im AppData-Verzeichnis abgelegt werden, können Sie auch ein gesondertes Konfigurationsdatenverzeichnis eines Herstellers oder ein beliebiges Datenverzeichnis nutzen.Für das Verarbeiten von Konfigurationsdateien und den Zugriff auf die Registry stellt das .NET Framework diverse Klassen bereit. Für Formate, die durch .NET nicht direkt unterstützt werden, greifen Sie auf das Windows-API oder auf Komponenten und Klassen von Drittherstellern zurück. Die wichtigsten Formate für Konfigurationsdateien und dafür bereitgestellte Klassen und Tools werden nachfolgend zusammengestellt.
INI-Dateien
Das Initialisierungsdateiformat wurde unter Windows schon mit den ersten 16-Bit-Versionen eingeführt und wird auch heute noch von Anwendungen genutzt. Noch heute bekannt sind die Initalisierungsdateien win.ini und user.ini. Sie sorgten für eine Trennung zwischen System- und Anwendungseinstellungen.INI-Dateien verwenden reinen Text ohne jegliche Formatierung und können daher mit dem Windows-Systemprogramm Notepad.exe bearbeitet werden. Die Einstellungen werden in Bereiche, die sogenannten Sektionen, unterteilt. Eindeutige Bezeichner in eckigen Klammern definieren die Sektionsnamen. Einzelne Einstellungen werden in der Form Schlüsselname = Wert unter den Sektionsnamen geschrieben. In unterschiedlichen Sektionen können gleiche Schlüsselnamen verwendet werden.
[Menuesowner]
ShowFileMenue = True
ShowEditMenue = True
ShowExtrasMenue = False
ShowHelpMenue = True
[Colors]
BackgroundColor = Gray
ForegroundColor = Black
[Settings]
MaxLoginTries = 1
LastUser = Andreas
[Users]
User1 = Andreas
User2 = Pia
User3 = Dominik
User4 = Natascha
INI-Dateien verwenden ein einfaches Textformat, das sich sehr leicht bearbeiten lässt (sequenziell, StreamWriter, StreamReader). In .NET finden Sie keine Klasse und keine Methoden, um direkt auf INI-Dateien und deren Sektionen und Schlüsselnamen zuzugreifen. Allerdings gibt es Windows-API-Funktionen dafür: GetPrivateProfileString und SetPrivateProfileString. Mit GetPrivateProfileString lesen Sie einen Wert aus und mit SetPrivateProfileString legen Sie einen Wert in einer INI-Datei ab. Deklariert werden die API-Funktionen wie folgt – hier in der Syntax für Visual Basic .NET:
Public Declare Function
GetPrivateProfileString Lib
"kernel32" Alias "GetPrivateProfileStringA" (
ByVal lpApplicationName As String,
ByVal lpKeyName As String,
ByVal lpDefault As String,
ByVal lpReturnedStr As String,
ByVal nSize As Integer,
ByVal lpFileName As String) As Integer
Public Declare Function
SetPrivateProfileString Lib
"kernel32" Alias "WritePrivateProfileStringA" (
ByVal lpApplicationName As String,
ByVal lpKeyName As String,
ByVal lpValue As String,
ByVal lpFileName As String) As Integer
Die nachfolgend gezeigten benutzerdefinierten Funktionen GetIni und SetIni vereinfachen die Nutzung der beiden API-Funktionen. Der Routine GetIni zum Einlesen eines Wertes übergeben Sie den Dateinamen samt Suchpfad zur INI-Datei (zum Beispiel Anwendungspfad\Anwendungsname.ini) über den Parameter File, die Sektion mit dem auszulesenden Schlüssel über den Parameter Sektion, den Schlüsselnamen über den Parameter Key sowie über den sDefault einen Vorgabewert. Der Vorgabewert wird übernommen, sofern die INI-Datei keinen Wert für den angegebenen Schlüssel enthalten sollte.Innerhalb der Funktion wird zunächst die Existenz der INI-Datei geprüft. Existiert die Datei nicht, wird der Standardwert zurückgegeben. Das Ergebnis der API-Funktion wird als Zeichenkette zurückgeliefert. Das aufrufende Programm muss selbst dafür sorgen, dass Strings, die Zahlenwerte repräsentieren, passend umgewandelt werden.
Public Function GetIni(ByVal File as String,
ByVal Sektion As String, ByVal Key As String,
ByVal sDefault As String)
Dim ret As Integer
Dim Wert As String
Dim File As String
Wert = Space(255)
If System.IO.File.Exists(File) Then
ret = GetPrivateProfileString(Sektion, Key,
sDefault, Wert, Len(Wert), File)
Return Left(Wert, ret)
Else
Return sDefault
End If
End Function
Mithilfe von SetIni vereinfachen Sie die Nutzung der API-Funktion SetPrivateProfileString. Sie erwartet den Namen der Initialisierungsdatei samt Suchpfad, den Sektions- und Schlüsselnamen sowie einen zuzuordnenden Zeichenkettenwert. Bitte beachten Sie: Die Länge eines einzelnen Schlüsselwertes ist auf 255 Zeichen beschränkt. Unter Umständen müssen längere Zeichenketten also auf mehrere Schlüssel aufgeteilt werden.
Public Sub SetIni(
ByVal File As String,
ByVal Sektion As String,
ByVal Key As String,
ByVal Value As String)
SetPrivateProfileString(
Sektion, Key, Value, File)
End Function
Tabelle 1 stellt weiterführende Informationen zu INI-Dateien und Klassen zusammen.
Tabelle 1: Infos und Klassen zu INI-Dateien
|
Die Registry in Windows
Die Registrierungsdatenbank wurde bereits in den 1990er Jahren eingeführt. In allen aktuellen Windows-Versionen ist sie der Hauptspeicherort für System- und Programmeinstellungen. Gegenüber einfachen INI-Dateien erlaubt die Registry nicht nur größere Datenmengen, sondern bietet auch einen strukturierten Zugriff auf die Daten.Mithilfe des Registrierungseditors kann man die Daten anzeigen und ändern. Er zeigt auf der linken Seite die Datenstruktur und rechts die Werte zum angewählten Registrierknoten. Jeder Knoten kann einen Standardwert, der auch als Standard gekennzeichnet ist, und einen oder mehrere Schlüssel verwalten. Jedem Schlüssel weisen Sie einen Wert mit einem bestimmten Datentyp zu. Sie verwalten binäre Daten, Zeichenketten, Ganzzahlwerte (32 oder 64 Bit) sowie mehrzeilige und erweiterbare Zeichenfolgen.Das Lesen, Schreiben und Anlegen (Bild 2) von Registrierknoten und Schlüsseln erfolgt über den Registrierungseditor oder in Anwendungsprogrammen auf Quelltextebene.
Die Registrykennt sechs unterschiedliche Datentypen(Bild 2)
Autor
Aufgrund der Vielzahl an Daten und trotz strukturierter Verwaltung ist der Zugriff auf die Daten dennoch unübersichtlich. Häufig wird intern mit Klassenkennungen gearbeitet (per GUIDs), deren Bezug auf den ersten Blick nicht erkennbar ist. Außerdem werden Informationen zu Programmen und Komponenten (zum Beispiel COM-Steuerelementen) getrennt verwaltet.Hinzu kommt, dass sich auf Dauer fehlerhafte Inhalte ansammeln und die Verarbeitung aufgrund der wachsenden Datenmengen langsamer wird. Die Datenstruktur ist zudem in mehrere Hauptschlüssel gegliedert. Teilweise sind Informationen zu Programmen und Komponenten auf zwei oder mehr Hauptschlüssel verteilt. So finden Sie Anwendungseinstellungen im Hauptschlüssel HKEY_CLASSES_ROOT, Benutzereinstellungen für den aktuellen Benutzer im Hauptschlüssel HKEY_CURRENT_USER, Einstellungen, die für alle Benutzer gelten, im Hauptschlüssel HKEY_USERS, Geräteeinstellungen zum aktuellen Rechner im Hauptschlüssel HKEY_LOCAL_MACHINE und Einstellungen zur aktuellen Systemkonfiguration im Hauptschlüssel HKEY_CURRENT_CONFIG(Bild 3).
Hauptknotender Registry(Bild 3)
Autor
Anwendungseinstellungen werden in der Registry im Knoten HKEY_CURRENT_USER\Software verwaltet. Bleibt anzuführen, dass im Hierarchiezweig HKEY_USERS Einstellungen verwaltet werden, die nur für bestimmte Benutzer gelten. Darüber wird beispielsweise sichergestellt, dass Einstellungen zwischen den Benutzern variierbar sind, wie bei den auf dem Desktop angezeigten Symbolen. Jeder Benutzer wird über eine eindeutige Kennung verwaltet und der Standardbenutzer wird dabei unter .DEFAULT verwaltet. Untergeordnet unter jedem Benutzerhauptschlüssel finden Sie erneut den Eintrag Software mit entsprechenden Hersteller- und Programmknoten.Das Windows-API stellt die Basisfunktionen zum Zugriff auf die Registry bereit. Die Nutzung ist jedoch für C++ ausgelegt und eine Anpassung der Deklarationsanweisungen ist zu aufwendig, insbesondere weil .NET entsprechende Verarbeitungsfunktionen bietet. Ferner bietet auch Visual Basic .NET Sonderfunktionen für den Registrierungszugriff im Namespace Microsoft.VisualBasic (auch in C# nutzbar), der von VBA (Visual Basic for Applications) übernommen wurde, aber nur Daten im Zeichenkettenformat unterstützt. Der einzige Unterschied gegenüber den API-Registry-Funktionen ist ansonsten, dass Sie die Information nicht beliebig hierarchisch in die Registrierdatenbank einordnen können. Stattdessen werden die Daten immer unter dem Schlüssel HKEY_USERS\.Default\Software\VB and VBA Program Settings beziehungsweise HKEY_CURRENT_USER\Software\VB and VBA Program Settings eingetragen, und zwar geordnet nach Programmnamen und nicht nach Herstellern. Mit der Funktion GetSetting rufen Sie den Wert einer Programmeinstellung ab:
'Syntax
Dim value as String = GetSetting (
AppName, Section, KeyName, [[Default]="Wert"])
'Beispiel
Dim value as String = GetSetting(
"RegistryTest", "User", "Benutzername",
[Default]="unbekannt")
Mit GetAllSettings lesen Sie eine Liste mit Werten ein, die Sie in ein Zeichenkettendatenfeld übernehmen:
'Syntax (Ergebnis als 2-dimensionales Datenfeld)
Dim values as String(,) =
GetAllSettings (AppName, Section)
'Beispiel
Dim values as String(,) =
GetAllSettings ("RegistryTest", "User")
Mit DeleteSetting löschen Sie eine Sektion (Hauptschlüssel zu einer Anwendung) oder einen Schlüsselwert:
'Syntax
DeleteSetting (AppName, Section)
DeleteSetting (AppName, Section, Key)
'Beispiel zum Löschen einer Sektion/eines Schlüssels
DeleteSetting("RegistryTest", "User")
DeleteSetting("RegistryTest", "User", "Benutzername")
Das Sichern eines Einstellungswertes klappt mit der Methode SaveSetting:
'Syntax
SaveSetting(AppName, Section, Key)
'Beispiel
SaveSetting("RegistryTest", "User", "Benutzername")
Mit dem Registrierungseditor können Sie Änderungen in der Registrierdatenbank jederzeit überprüfen. Auch im Namespace My.Computer.Registry von Visual Basic .NET stehen Methoden für den Zugriff auf die Registry bereit, die auch in C# nutzbar sind, sofern Sie den entsprechenden Verweis herstellen. Die darüber bereitgestellten Methoden werden intern auf die Methoden der Klasse Microsoft.Win32.Registry umgeleitet und können alternativ dazu verwendet werden. Praktische Beispiele sowie alternative Tools, Bibliotheken und erweiterte Informationen zum Zugriff auf die Registry stellt Tabelle 2 zusammen.
Tabelle 2: Registry: Infos und Klassen
|
Konfigurationsverwaltung im XML-Format
XML, die Extensible Markup Language, ist eine erweiterbare Auszeichnungssprache, die für den Austausch strukturierter Daten genutzt wird. Das eingangs zu INI-Dateien angeführte Beispiel kann auch mit XML umgesetzt werden. Hier werden Inhalte erneut Schlüsseln zugeordnet, wobei immer ein Eingangs- und Abschluss-Tag verwendet wird.Die Schlüssel werden in XML als Elemente bezeichnet. Das Format ist plattformübergreifend und sprachunabhängig einsetzbar. XML ist zwar ein reines Textformat, optional können Sie aber die in der Struktur abzulegenden Werte auch verschlüsseln.
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Configuration>
<Menues>
<ShowFileMenue>True</ShowFileMenue>
<ShowEditMenue>True</ShowEditMenue>
<ShowExtrasMenue>False</ShowExtrasMenue>
<ShowHelpMenue>True</ShowHelpMenue>
</Menues>
<Colors>
<BackgroundColor>Gray</BackgroundColor>
<ForegroundColor>Black</ForegroundColor>
</Colors>
<Settings>
<MaxLoginTries>1</MaxLoginTries>
<LastUser>Andreas</LastUser>
</Settings>
<Users>
<User1>Andreas</User1>
<User2>Pia</User2>
<User3>Dominik</User3>
<User4>Natascha</User4>
</Users>
</Configuration>
In .NET steht das XML-Format für die Serialisierung von Objekten zur Verfügung. Dazu definieren Sie ein Objekt, sichern es per Serialisierung und stellen es bei Bedarf per Deserialisierung wieder her. Das XML-Speicherformat wird über die Klasse XmlSeralizer realisiert, welche die Methoden Serialize und Deserialize bietet.Verglichen mit einfachen INI-Dateien sind die Inhalte von XML-Dateien, insbesondere bei komplexen Datenstrukturen, für Menschen schlechter lesbar. Dafür sind die Daten per Serialisierung einfach zu schreiben und zu lesen, wobei allerdings die Objektdefinition für die zu verwaltenden Daten gesondert zu behandeln ist.Ein weiterer Nachteil ist, dass das Format aufgrund der Elementnamen und deren Tags viel Speicherplatz belegt, zumindest dann, wenn Sie aussagekräftige Bezeichner verwenden. Nutzen Sie keinen XML-Editor zur Dateneingabe, ergibt sich aufgrund von Schreibfehlern eine hohe Fehleranfälligkeit. Wollen Sie das XML-Format nicht nur im Rahmen der Serialisierung nutzen, so verwenden Sie die Klassen System.Xml, System.Xml.XPath, System.Xml.Xsl, System.Xml.Schema und System.Xml.Linq. Weiterführende Informationen zu XML, zur XML-Verarbeitung sowie zu Projekten, Beispielen, Serialisierungsbibliotheken und Komponenten finden Sie in Tabelle 3.
Tabelle 3: Infos und Klassen zu XML-Dateien
|
Das JSON-Format
Die JavaScript Object Notification (JSON) ist ebenfalls ein strukturiertes Textformat, das sich gut zum Verwalten von Konfigurationseinstellungen nutzen lässt. Es ist leicht lesbar, kann per Editor bearbeitet werden und taugt zum Austausch von Daten zwischen Anwendungsprogrammen und Systemplattformen. Zum Schreiben und Einlesen von JSON-Dateien stellt .NET in der Klasse System.Runtime.Serialization.Json geeignete Methoden bereit. Prinzipiell ist ein JSON-Dokument auch ein gültiges JavaScript-Dokument. Die Daten können beliebig verschachtelt sein und diverse Datentypen enthalten (Nullwerte, Wahrheitswerte, Zahlen, Zeichenketten, Datenfelder, Objekte).
{
"Books": [
{
"Kennung": "056844",
"Autor": "Pan, Peter",
"Titel": "Mein Leben mit .NET",
"Genre": "EDV",
"Preis": 19.99,
"Beschreibung": "Einführung in .NET"
}
...
]
}
Das Format ist kompakt uund einfach zu schreiben sowie zu lesen. Die Inhalte von eckigen Klammern verwalten Datenfelder, geschweifte Klammern definieren Datensätze, und zwei durch einen Doppelpunkt getrennte Werte definieren einen Schlüssel nebst zugehörigem Wert. Alle Schlüsselnamen sind, ebenso wie Zeichenkettenwerte, in Anführungszeichen einzufassen. Damit ist das Format effektiver als XML. Mit JSON.NET steht eine komplexe Open-Source-Bibliothek bereit, über die Sie JSON-Dateien verarbeiten. Alternative Tools, weiterführende Informationen, Parser, Serialisierer und Lösungen zum Verarbeiten von Dateien im JSON-Format unter .NET finden Sie in Tabelle 4.
Tabelle 4: JSON-Dateien
|
SOAP-Format
Das Simple Object Access Protocol (SOAP) ist ein XML-basiertes Format, das im Netzwerk und im Internet zum Datenaustausch verwendet wird. Es ist im Rahmen der Serialisierung unter Verwendung der .NET-Klasse SoapFormatter nutzbar. Auch hier definieren Sie zunächst ein Datenobjekt. Nach der Wertzuweisung sichern Sie die Daten per Serialisierung und stellen diese dann per Deserialisierung jederzeit wieder her. SOAP ist zwar nicht als Format für Konfigurationsdaten optimiert, lässt sich aber dennoch zur Serialisierung nutzen. In SOAP-Dateien legen Sie beispielsweise auch Bilddaten im Textformat ab, die Sie jederzeit wieder einlesen und anzeigen lassen können. Gegenüber XML ist das SOAP-Format speicherintensiver und je nach Datenbestand auch schwieriger zu lesen. Leistungsfähige Komponenten, um SOAP-Dateien detailliert anzulegen, sind rar. Beispielprogramme und weiterführende Infos zum Format sowie zur SOAP-Serialisierung liefert Tabelle 5.Tabelle 5: Infos und Klassen zum SOAP-Format
|
Konfigurationsverwaltung im TOML-Format
Tom’s Obvious, Minimal Language (TOML) ist ein Textformat, das sich am Aufbau herkömmlicher INI-Dateien orientiert, aber das strukturiertere Verwalten von Konfigurationsdaten erlaubt. Es wurde von Tom Preston-Werner entwickelt.Gegenüber herkömmlichen INI-Dateien hat TOML den Vorteil, dass Sie darüber auch mehrzeilige Zeichenketten sowie unterschiedliche Datentypen verwalten (String, Integer, Float, Boolean, Datetime, Array und Table). TOML verwaltet Schlüssel-Wert-Paare, wobei zwischen Groß- und Kleinbuchstaben unterschieden wird.Jede TOML-Datei muss ein UTF8-codiertes Unicode-Dokument sein. Es werden Standardzeichen für Leerzeichen (Chr(20)), Tabulatoren (Chr(9)) und Zeilenumbrüche genutzt. Nebenstehend sehen Sie ein Beispiel eines gültigen TOML-Dokuments:# Dies ist ein TOML Dokument.
Title = "Configuration"
[Menues]
ShowFileMenue = True
ShowEditMenue = True
ShowExtrasMenue = False
ShowHelpMenue = True
[Colors]
BackgroundColor = Gray
ForegroundColor = Black
[Settings]
MaxLoginTries = 1
LastUser = "Andreas"
OpenDialog = true
[Users]
[Users.User1]
Name = "Andreas"
[Users.User2]
Name = "Pia"
[Users.User3]
Name = "Dominik"
[Users.User4]
Name = "Natascha"
Weiterführende Hinweise und Detailinformation zum TOML-Format sowie zu Beispielprojekten und Parsern entnehmen Sie der Aufstellung in Tabelle 6.
Tabelle 6: Infos und Klassen zum TOML-Format
|
Eine direkte Unterstützung für TOML-Dateien gibt es in .NET derzeit nicht. Allerdings können Sie die Textdateien immer direkt einlesen, speichern (zum Beispiel per StreamReader, StreamWriter) und programmintern mit Zeichenkettenmethoden verarbeiten.Weniger steinig ist allerdings der Weg über bereits implementierte Parser, die für unterschiedliche Sprachen verfügbar sind, auch für .NET und .NET Core. TOML ist einfach lesbar und bietet erhebliche Vorteile gegenüber einfachen INI-Dateien. Lediglich die Auswahl an leistungsfähigen Parsern ist derzeit noch sehr eingeschränkt.
Konfigurationsverwaltung im YAML-Format
Mit dem YAML-Format verwalten Sie Datenstrukturen über assoziative Listen, Datenfelder und Einzelwerte. Für die Verwaltung von Konfigurationseinstellungen ist das Format nur eingeschränkt geeignet. Die Datenverwaltung erfolgt angelehnt an XML, Perl, Python und C. Zwar lässt sich das Format einfach lesen und schreiben, für die komplexe Einstellungsverwaltung ist es jedoch nicht geeignet. In YAML-Dateien werden Kommentare mit Doppelkreuz (#) eingeleitet. Abschnitte führen Sie mit drei Bindestrichen (---) ein:# Configuration
---
# Menues
- {ShowFileMenue: True}
- {ShowEditMenue: True}
- {ShowExtrasMenue: False}
- {ShowHelpMenue: True}
# Colors
BackgroundColor = Gray
ForegroundColor = Black
In YAML-Dateien abzulegende Werte definieren Sie als Block in einer der beiden folgenden Formen:
# Person
Vorname: Peter
Nachname: Pan
# Person inline
{Vorname: Peter, Nachname: Pan}
Eine direkte Unterstützung für das YAML-Format gibt es im .NET Framework nicht, allerdings sind einige Bibliotheken für .NET verfügbar. Diese und weiterführende Informationen enthält Tabelle 7.
Tabelle 7: Infos und Klassen zu YAML-Dateien
|
Konfigurationsverwaltung im CSON-Format
Für das CSON-Format gibt es zwei Spezifikationen, die CoffeeScript Object Notation und die Cursive Script Object Notation. An dieser Stelle soll die erste Variante berücksichtigt werden, bei der es sich um eine Beschreibung für Objekte in der Skriptsprache CoffeeScript handelt.CoffeeScript ist eine Sprache, die per Compiler verarbeitet wird und dadurch JavaScript-Quelltext generiert. Ziel von CoffeeScript ist es, mit einer optimierten kompakteren Syntax Quellcode in JavaScript zu generieren. Das Format CSON hat gegenüber JSON den Vorteil, dass es ohne geschweifte Klammern auskommt.
Books: [
Kennung: '056844'
Autor: 'Pan, Peter'
Titel: 'Mein Leben mit .NET'
Genre: 'EDV'
Preis: 19.99,
Beschreibung: 'Einführung in .NET'
]
Hierarchien werden durch Einrückungen nachgebildet. CSON ist dementsprechend ein sehr einfach zu verarbeitendes und gegenüber JSON ein speicherplatzsparendes Format. Ansonsten verwalten Sie mehrzeilige Zeichenketten, nutzen per Doppelkreuz (#) eingeleitete Kommentare, und Schlüssel-Wert-Paare sind nicht durch Kommata zu trennen. Die Verarbeitung erfolgt mit CoffeeScript.Eine CoffeeScript-Implementierung für .NET ist ebenso erhältlich wie Parser zum Verarbeiten der CSON-Dateien. In Tabelle 8 finden Sie weiterführende Informationen zu CoffeeScript, zum .NET-CoffeeScript-Compiler sowie detaillierte Infos zum Dateiformat und zur Verwendung von CoffeeScript in .NET.
Tabelle 8: Infos und Klassen zu CSON-Dateien
|
Weitere Dateiformate
Wenn Sie Konfigurationseinstellungen über Klassen und Objekte zusammenfassen, speichern Sie diese vereinfacht über die von .NET bereitgestellten Serialisierungsfunktionen. Ein erneutes Laden der Werte ist mit den Deserialisierungsfunktionen von .NET möglich. Dabei werden die Formate binär, JSON, SOAP und XML von .NET unterstützt. Dazu definieren Sie zunächst eine Klasse mit den Eigenschaften für die zu sichernden Einstellungen. Das Speichern erfolgt durch Methoden zur Serialisierung und das Laden durch gesonderte Methoden zur Deserialisierung. Beispiele dazu finden Sie unter [1 bis 4].Neben den beschriebenen Dateitypen für Konfigurationsdateien können Sie jederzeit auch eigene Formate definieren. Sie nutzen dazu wahlweise angebundene Datenbanken, sequenzielle, binäre oder Direktzugriffsdateien oder speichern und laden Einstellungen über zuvor definierte Klassen oder Datenstrukturen. Dazu nutzen Sie die von .NET bereitgestellten Anweisungen – zum Beispiel in den Klassen System.IO, FileSystem, StreamReader und StreamWriter. Weitere Infos dazu listet Tabelle 9.Tabelle 9: Eigene Dateiformate aufbauen
|
Der Vorteil ist, dass Sie dabei ein auf Ihre Anforderungen abgestimmtes Format wählen können. Allerdings müssen Sie die Parser selbst implementieren. Zum Austausch mit anderen Anwendungen eignen sich die Daten dann jedoch nicht. Eine Liste mit bereits vorhandenen anwendungsspezifischen Konfigurationsdateien von ACF-Dateien für Adobe Photoshop-Filter bis zu XLW-Dateien für Excel finden Sie auf der Webseite unter [5].Ob Sie einfache INI-Dateien, die Registry oder komplexere XML-, JSON-, XAML-, YAML- oder auch TOML-Dateien nutzen, hängt von der jeweiligen Aufgabenstellung ab. Ein ausführliches Beispiel zur Verwaltung von Konfigurationseinstellungen über benannte und anonyme Typen unter Visual Basic .NET können Sie in der kommenden Ausgabe der dotnetpro in der Rubrik Basic Instinct kennenlernen.
Fussnoten
- Andreas Maslo, Objektdaten laden und speichern, Teil 6, Flexibel serialisieren, dotnetpro 12/2018, Seite 130 ff., http://www.dotnetpro.de/A1812BasicInstinct
- Andreas Maslo, Objektdaten laden und speichern, Teil 7, Vier Varianten einbinden, dotnetpro 1/2019, Seite 132 ff., http://www.dotnetpro.de/A1901BasicInstinct
- Andreas Maslo, Objektdaten laden und speichern, Teil 8, Serialisierung und Datenexport, dotnetpro 2/2019, Seite 136 ff., http://www.dotnetpro.de/A1902/BasicInstinct
- Andreas Maslo, Objektdaten laden und speichern, Teil 9, Export und Import, dotnetpro 3/2019, Seite 136 ff., http://www.dotnetpro.de/A1903/BasicInstinct
- Dateitypen proprietärer Konfigurationsdateien, http://www.dateiendung.com/type/config
