{"id":55000023,"date":"2016-02-01T00:00:00","date_gmt":"2020-03-27T19:17:23","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=23"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Anwendungskonfigurationsdateien","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Anwendungskonfigurationsdateien\/","title":{"rendered":"Anwendungskonfigurationsdateien"},"content":{"rendered":"

Während Sie etwa in einer Access-Anwendung leicht die Konfigurationsdaten in einer eigens dafür vorgesehenen Tabelle speichern können oder in einer benutzerdefinierten Text- oder XML-Datei, gibt es unter C# andere Möglichkeiten. Wie für alles finden Sie unter C# auch für das Verwalten von Konfigurationsdaten einen eigenen Namespace – in diesem Fall heißt dieser ConfigurationManager. Dieser Artikel zeigt, wie Sie damit Daten für Desktop-Anwendungen speichern und wieder abrufen können.<\/b><\/p>\n

Beispielanwendung<\/h2>\n

Als Beispielanwendung legen wir ein C#-Projekt des Typs Konsolenanwendung an und speichern es unter dem Namen Konfigurationsdateien<\/b>.<\/p>\n

Ausprobieren<\/h2>\n

Wenn Sie die Methoden dieses Artikels selbst in ein neues Projekt eingeben und ausprobieren möchten, fügen Sie diese zur Klasse Program.cs <\/b>hinzu und tragen den Aufruf der Methoden in die Methode static void Main <\/b>ein – etwa wie in folgendem Beispiel:<\/p>\n

static void Main(string[] args) {\r\n     KonfigurationsdatenLesen\r\n}<\/pre>\n
Alternativ nutzen Sie die im Artikel Methodenstarter als Vorlage <\/b>vorgestellte Variante zum Aufrufen von Beispielmethoden.<\/p>\n
Wozu Konfigurationsdateien<\/h2>\n
Wozu nutzt man überhaupt Konfigurationsdateien Darin speichert man Daten, die nicht unbedingt zu den Geschäftsdaten der Anwendung gehören (die in Tabellen landen), sondern die Informationen zur Anwendung wie etwa die Verbindungszeichenfolge enthalten. Diese könnten wir zwar für Anwendungen, die nur auf dem eigenen Rechner laufen und jederzeit neu kompiliert werden können, auch etwa in einer Konstanten speichern. Sobald Sie eine Anwendung jedoch weitergeben möchten, sollten Sie Mechanismen vorsehen, mit denen Konfigurationsdaten an Orten gespeichert werden, die auch der Benutzer zur Laufzeit ändern kann.<\/p>\n
Ein gutes Beispiel ist die Verbindungszeichenfolge einer Datenbankanwendung. Ob es sich dabei um eine Verbindung zu einem SQL Server handelt oder auch nur die Angabe des Speicherpfades einer als Backend verwendeten Access-Datenbank, spielt dabei keine Rolle. Tatsache ist, dass es während der Laufzeit geschehen kann, dass der Benutzer diese Daten ändern können sollte, um beispielsweise den Servernamen einer SQL Server-Verbindung zu ändern oder auch einen neuen Speicherpfad einer Access-Datenbank einzugeben.<\/p>\n
Eine solche Konfigurationsdatei mit einer Verbindungszeichenfolge für eine Access-Datenbank sieht beispielsweise wie folgt aus:<\/p>\n
<xml version=\"1.0\" encoding=\"utf-8\">\r\n<configuration>\r\n   <connectionStrings>\r\n     <add name=\"Accessdatenbank\" \r\n         connectionString=\"c:\\Suedsturm.mdb\" \/>\r\n   <\/connectionStrings>\r\n<\/configuration><\/pre>\n
Speicherort der Konfigurationsdateien<\/h2>\n
Für eine C#-Anwendung legt Visual Studio drei Konfigurationsdateien an, die Sie im Projektverzeichnis finden. Direkt im Hauptverzeichnis landet die Datei App.config<\/b>. Im Verzeichnis bin\\Debug <\/b>finden Sie beim Debuggen die beiden Dateien .exe.config <\/b>und .vshost.exe.config<\/b>. Später, wenn Sie die Anwendung erstellen, ist zunächst keine .config<\/b>-Datei vorhanden. Diese wird erstellt, sobald die Anwendung Konfigurationsinformationen speichert – und zwar ebenfalls unter dem Namen .exe.config<\/b>.<\/p>\n
Wenn Sie eine Anwendungskonfigurationsdatei zu einem Projekt hinzufügen möchten, das nach der Installation bereitsteht, legen Sie die gewünschte Datei im XML-Format an und speichern diese im Anwendungsverzeichnis.<\/p>\n
Konfigurationsdatei manuell hinzufügen<\/h2>\n
Wenn Sie eine Konfigurationsdatei hinzufügen möchten, statt diese per Code zu erzeugen, erledigen Sie dies am einfachsten über den Menüeintrag Projekt|Neues Element hinzufügen<\/b>. Dies öffnet den Dialog Neues Element hinzufügen<\/b>, wo Sie den Eintrag Anwendungskonfigurationsdatei <\/b>auswählen (siehe Bild 1). Geben Sie den gewünschten Namen für die Anwendungskonfigurationsdatei ein und klicken Sie auf die Schaltfläche Hinzufügen<\/b>.<\/p>\n
\"Anlegen<\/p>\n
Bild 1: Anlegen einer Anwendungskonfigurationsdatei<\/span><\/b><\/p>\n
Die neue Anwendungskonfigurationsdatei sieht nun wie in Bild 2 aus und wird auch im Projektmappen-Explorer angezeigt. Prinzipiell benötigen Sie aber keine neue Konfigurationsdatei, denn das Projekt bringt mit app.config <\/b>bereits eine solche mit. Sollten Sie diese Datei jedoch einmal versehentlich löschen, können Sie diese mit der oben beschriebenen Vorgehensweise wieder herstellen.<\/p>\n
\"Die<\/p>\n
Bild 2: Die neue Anwendungskonfigurationsdatei<\/span><\/b><\/p>\n
Konfigurationsdaten anlegen<\/h2>\n
Um Konfigurationsdateien mit Eigenschaften auszustatten, verwenden Sie den Einstellungen-Editor von Visual Studio. Um diesen zu öffnen, klicken Sie doppelt auf den Eintrag Properties <\/b>im Projektmappen-Explorer. Wechseln Sie dann zum Bereich Einstellungen <\/b>und fügen Sie die benötigten Eigenschaften samt Datentyp, Bereich (Benutzer <\/b>oder Anwendung<\/b>) sowie den Standardwert fest (siehe Bild 3). Warum Standardwert Weil die Konfigurationsdatei erst beim Erstellen der Anwendung erzeugt und mit Werten gefüllt wird.<\/p>\n
\"Einstellungen<\/p>\n
Bild 3: Einstellungen zu einer Anwendung hinzufügen<\/span><\/b><\/p>\n
Um dies zu prüfen, erstellen Sie die Anwendung zum Debuggen (F5<\/b>) und schauen sich anschließend den Inhalt der Datei app.config <\/b>im Hauptverzeichnis des Projekts an. Diese sieht nun in gekürzter Form wie in Listing 1 aus. Im Bereich userSettings <\/b>finden Sie die Eigenschaft mit der Bezeichnung Eigenschaft1 <\/b>und dem Wert Wert1<\/b>, unter applicationSettings <\/b>die Eigenschaft namens Eigenschaft2 <\/b>mit dem Wert Wert2<\/b>.<\/p>\n
<xml version=\"1.0\" encoding=\"utf-8\" >\r\n<configuration>\r\n     <configSections>\r\n         <sectionGroup name=\"userSettings\" ... >\r\n             <section name=\"Konfigurationsdateien.Properties.Settings\" ... \/>\r\n         <\/sectionGroup>\r\n         <sectionGroup name=\"applicationSettings\" ... >\r\n             <section name=\"Konfigurationsdateien.Properties.Settings\" ... \/>\r\n         <\/sectionGroup>\r\n     <\/configSections>\r\n     <startup> \r\n         <supportedRuntime version=\"v4.0\" sku=\".NETFramework,Version=v4.5.2\" \/>\r\n     <\/startup>\r\n     <userSettings>\r\n         <Konfigurationsdateien.Properties.Settings>\r\n             <setting name=\"Eigenschaft1\" serializeAs=\"String\">\r\n                 <value>Wert1<\/value>\r\n             <\/setting>\r\n         <\/Konfigurationsdateien.Properties.Settings>\r\n     <\/userSettings>\r\n     <applicationSettings>\r\n         <Konfigurationsdateien.Properties.Settings>\r\n             <setting name=\"Eigenschaft2\" serializeAs=\"String\">\r\n                 <value>Wert2<\/value>\r\n             <\/setting>\r\n         <\/Konfigurationsdateien.Properties.Settings>\r\n     <\/applicationSettings>\r\n<\/configuration><\/pre>\n
Listing 1: Konfigurationsdatei app.config mit einer Benutzer- und einer Anwendungseinstellung<\/span><\/b><\/p>\n
Einlesen der Konfigurationsdateien<\/h2>\n
Wenn Sie die so angelegten Einstellungen von einer C#-Anwendung aus einlesen möchten, erledigen Sie das etwa mit einer Methode wie der folgenden:<\/p>\n
public static void KonfigurationsdatenLesen() {\r\n     Settings settings = new Settings();\r\n     Console.WriteLine(\"Wert von Eigenschaft1: {0}\", \r\n         settings.Eigenschaft1);\r\n     Console.WriteLine(\"Wert von Eigenschaft2: {0}\", \r\n         settings.Eigenschaft2);\r\n     Console.ReadLine();\r\n}<\/pre>\n
Bei der Eingabe dieser Methode wird Visual Studio meckern, weil es das Objekt Settings <\/b>nicht kennt. Settings <\/b>ist eine Klasse, die automatisch angelegt wird, sobald Sie im Bereich Properties <\/b>der Anwendungseinstellungen eine Eigenschaft angelegt haben. Diese Klasse sehen Sie auch im Projektmappen-Explorer (siehe Bild 4). Damit Sie im Code komfortabel auf die Elemente der Settings<\/b>-Klasse zugreifen können, fügen Sie dem Klassenmodul mit der using<\/b>-Direktive einen Verweis auf das Element .Properties <\/b>hinzu:<\/p>\n
\"Die<\/p>\n
Bild 4: Die Klasse Settings stellt die benutzerdefinierten Einstellungen bereit.<\/span><\/b><\/p>\n
using Konfigurationsdateien.Properties;<\/pre>\n
Danach ist der Zugriff auf die Klasse Settings <\/b>per Code problemlos möglich, und Sie können die Werte der per Benutzeroberfläche hinzugefügten Einstellungen über settings.Eigenschaft1 <\/b>und settings.Eigenschaft2 <\/b>ausgeben. Die Klasse Settings <\/b>wird automatisch bei Änderungen an den Eigenschaften neu erstellt und arbeitet wie eine benutzerdefinierte Klasse – sie stellt die Eigenschaften per Set<\/b>– und Get<\/b>-Methode zum Lesen und Schreiben zur Verfügung. Ein Blick in den Code dieser Klasse zeigt jedoch direkt, dass die Einstellungen des Bereichs Benutzer <\/b>gelesen und geändert, die Einstellungen des Bereichs Anwendung <\/b>jedoch nur gelesen werden können.<\/p>\n
Benutzereinstellungen ändern<\/h2>\n
Wenn Sie also per Code Einstellungen ändern möchten, gelingt dies ohne Weiteres nur bei den Benutzereinstellungen – und zwar beispielsweise wie folgt:<\/p>\n
public static void KonfigurationsdatenAendern() {\r\n     Settings settings = new Settings();\r\n     settings.Eigenschaft1 = \"Test1_Neu\";\r\n     settings.Save();\r\n     Console.ReadLine(); }<\/pre>\n
Dies ändert den Wert von Eigenschaft1 <\/b>auf Test1_Neu<\/b>. Wenn Sie diese Methode aufrufen und anschließend nochmals die Methode KonfigurationsdatenLesen<\/b>, wird der neue Wert ausgegeben.<\/p>\n
Speicherort nach der Weitergabe<\/h2>\n
Wo sich die Konfigurationsdatei beim Debuggen befindet, haben wir bereits weiter oben erläutert. Aber wo finden Sie die entsprechenden Dateien, wenn Sie die .exe<\/b>-Datei weitergeben und auf einem anderen Rechner ausführen Genau genommen handelt es sich in diesem Fall um zwei Konfigurationsdateien. Die erste enthält die Benutzereinstellungen, die zweite die Anwendungseinstellungen. Die Benutzereinstellungen finden Sie etwa unter Windows 7 in einem Verzeichnis, das sich wie folgt zusammensetzt:<\/p>\n
C:\\Users\\<Benutzername>\\AppData\\Local\\<Hersteller>\\<Anwendungsname>.exe_<Evidence Type>_<Evidence Hash>\\<Version>\\user.config<\/pre>\n
Wenn Sie für  <\/b>keine Angabe in der Datei AssemblyInfo.cs <\/b>gemacht haben, verwendet die Anwendung die Bezeichnung des Namespace (hier nsKonfigurationsdateien<\/b>).  <\/b>und  <\/b>werden vom System generiert. Diese Datei enthält nur den Bereich userSettings <\/b>der weiter oben vorgestellten Konfigurationsdatei:<\/p>\n
<configuration>\r\n     <userSettings>\r\n         <Konfigurationsdateien.Properties.Settings>\r\n             <setting name=\"Eigenschaft1\" serializeAs=\"String\">\r\n                 <value>Test1_Neu<\/value>\r\n             <\/setting>\r\n         <\/Konfigurationsdateien.Properties.Settings>\r\n     <\/userSettings>\r\n<\/configuration><\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t