UserSettingsProvider (Persistieren von UserSettings)

RodFromGermany · 11. Dezember 2014, 09:52

@VB1963 Ich hab das ganze mal nach C# übertragen.
Ergebnis: Die Settings in C# funktionieren etwas anders als in VB.NET. Das ist vielleicht für den @ErfinderDesRades interessant.
Der linear übersetzte Code generiert auch mit SetDataFile() den DLL-Namen als Settings-File.
Deswegen bin ich da wieder auf die Lösung mit GetModuleFileName() zurückgegangen. Vielleicht findetr ja jemand da auch noch eine elegante Lösung ohne explizite separate Initialisierung.

UserSettingsProvider

UserSettingsProvider.cs

C#-Quellcode

using System;
using System.Configuration;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
namespace MyProvider
{
/// <summary>
/// Dieser Provider speichert die betroffenen Settings-Einstellungen in eine eigene .exe.config.xml-Datei.
/// Diese Datei liegt im Arbeitsverzeichnis der Anwendung.
/// HINWEISE:
/// Die ApplicationName-Property erstellt die ProduktName-Eigenschaft von der My.Application.Info.ProduktName
/// Hier sollte in den Projekteigenschaften/Anwendung/Assemblyinformationen die Eigenschaft ProduktName = AssemblyName gestellt sein!
/// </summary>
public class UserSettingsProvider : SettingsProvider, IApplicationSettingsProvider
{
[DllImport("kernel32.dll", SetLastError = true)]
[PreserveSig]
public static extern uint GetModuleFileName
([In]IntPtr hModule, [Out]StringBuilder lpFilename, [In][MarshalAs(UnmanagedType.U4)] int nSize);
public override string ApplicationName { get; set; }
// hier wird der Produktname von der Assembly angegeben
public override string Name { get { return "UserSettingsProvider"; } }
private Dictionary<string, object> Datas;
private FileInfo DataFile { get; set; }
private string AppPath { get; set; }
public UserSettingsProvider()
{
// Will write the current executable's complete path into exePath
StringBuilder sb = new StringBuilder(1024);
uint pathLen = UserSettingsProvider.GetModuleFileName(IntPtr.Zero, sb, sb.Capacity);
if (pathLen >= 1024)
{
throw new ArgumentOutOfRangeException("StringBuilder() too small");
}
string exePath = sb.ToString();
FileInfo fi = new FileInfo(exePath);
this.ApplicationName = System.IO.Path.GetFileNameWithoutExtension(exePath);
// in der Debug-Version auf dieselben Settings zugreifen
if (ApplicationName.ToLower().EndsWith(".vshost"))
{
this.ApplicationName = System.IO.Path.GetFileNameWithoutExtension(this.ApplicationName);
}
this.AppPath = fi.DirectoryName;
this.DataFile = new FileInfo(Path.Combine(this.AppPath, string.Concat(ApplicationName, ".exe.config.dat")));
this.Datas = new Dictionary<string, object>();
}
public override void Initialize(string name, NameValueCollection config)
{
base.Initialize(this.ApplicationName, config);
}
/// <summary>
/// SetPropertyValues wird erst abgearbeitet, wenn ApplicationSettingsBase.Save durchgeführt wird.
/// ApplicationSettingsBase stellt sicher, dass für jeden einzelnen Provider nur seine markierten Werte herangenommen werden.
/// Egal, ob der Provider auf einer Einzel-Einstellung angesetzt ist oder ob klassenweit die Einstellung angegeben wurde.
/// Wenn Einstellungen nicht verändert wurden, müssen sie nicht gespeichert werden!
/// Anwendungsspezifische Einstellungen können nicht geändert werden und werden daher auch nicht gespeichert!
/// </summary>
/// <param name="context"></param>
/// <param name="collection"></param>
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection)
{
foreach (SettingsPropertyValue prpValue in collection)
{
if (!prpValue.IsDirty || (prpValue.SerializedValue == null))
{
continue;
}
if (this.IsApplicationScoped(prpValue.Property))
{
continue;
}
this.Datas[prpValue.Name] = prpValue.SerializedValue;
}
this.SaveBinary(this.DataFile, this.Datas);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
if (this.DataFile.Exists)
{
this.Datas = this.LoadBinary(DataFile);
}
SettingsPropertyValueCollection col = new SettingsPropertyValueCollection();
foreach (SettingsProperty prp in collection)
{
SettingsPropertyValue Value = new SettingsPropertyValue(prp);
if (this.Datas.ContainsKey(prp.Name))
{
Value = GetPropertyValue(prp);
}
// Wert von Datas einlesen
col.Add(Value);
}
return col;
}
/// <summary>
/// Nur benutzerspezifische Eigenschaften sind zulässig.
/// Wenn eine Eigenschaft keinen Wert hat, wird der Defaultwert geladen.
/// </summary>
/// <param name="prp"></param>
private SettingsPropertyValue GetPropertyValue(SettingsProperty prp)
{
SettingsPropertyValue value = new SettingsPropertyValue(prp);
if (this.IsUserScoped(prp))
{
value.SerializedValue = this.Datas[prp.Name];
}
value.IsDirty = false;
return value;
}
/// <summary>
/// Test auf anwendungsspezifische Eigenschaft
/// </summary>
/// <param name="prop"></param>
private bool IsApplicationScoped(SettingsProperty prop)
{
return this.HasSettingScope(prop, typeof(ApplicationScopedSettingAttribute));
}
/// <summary>
/// Test auf benutzerdefinierte Eigenschaft
/// </summary>
/// <param name="prop"></param>
private bool IsUserScoped(SettingsProperty prop)
{
return this.HasSettingScope(prop, typeof(UserScopedSettingAttribute));
}
/// <summary>
/// prüft auf erlaubte Einstellung, so wie es der LocalFileSettingsProvider auch macht ...
/// </summary>
/// <param name="prop"></param>
/// <param name="attributeType"></param>
private bool HasSettingScope(SettingsProperty prop, Type attributeType)
{
bool isAppScoped = prop.Attributes[typeof(ApplicationScopedSettingAttribute)] != null;
bool isUserScoped = prop.Attributes[typeof(UserScopedSettingAttribute)] != null;
if (isUserScoped && isAppScoped)
{
throw new ConfigurationErrorsException("BothScopeAttributes: " + prop.Name);
}
if (!isUserScoped && !isAppScoped)
{
throw new ConfigurationErrorsException("NoScopeAttributes: " + prop.Name);
}
if (object.ReferenceEquals(attributeType, typeof(ApplicationScopedSettingAttribute)))
{
return isAppScoped;
}
if (object.ReferenceEquals(attributeType, typeof(UserScopedSettingAttribute)))
{
return isUserScoped;
}
return false;
}
/// <summary>
/// Daten binär speichern
/// </summary>
/// <param name="DataFile"></param>
/// <param name="Datas"></param>
private void SaveBinary(FileInfo DataFile, Dictionary<string, object> Datas)
{
this.DeleteLocalPathUserSettings();
using (Stream fs = File.Create(DataFile.FullName))
{
BinaryFormatter binfmt = new BinaryFormatter();
binfmt.Serialize(fs, Datas);
}
}
/// <summary>
/// falls der LocalUserAppDataPath vorhanden ist,
/// wird der Ordner mit allen untergeordneten Verzeichnissen gelöscht
/// </summary>
private void DeleteLocalPathUserSettings()
{
DirectoryInfo di = new DirectoryInfo(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal).FilePath);
di = di.Parent.Parent.Parent;
if (di.Exists)
{
di.Delete(true);
}
}
/// <summary>
/// binäre Daten laden
/// </summary>
/// <param name="DataFile"></param>
private Dictionary<string, object> LoadBinary(FileInfo DataFile)
{
using (Stream fs = File.Open(DataFile.FullName, FileMode.Open))
{
BinaryFormatter binfmt = new BinaryFormatter();
return (Dictionary<string, object>)binfmt.Deserialize(fs);
}
}
#region "IApplicationSettingsProvider Members"
/// <summary>
/// Abrufen der letzten Version der Settingseigenschaft
/// </summary>
/// <param name="context"></param>
/// <param name="property"></param>
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
SettingsPropertyValue prpValue = new SettingsPropertyValue(property);
if (this.Datas.ContainsKey(property.Name))
{
prpValue.PropertyValue = this.Datas[property.Name];
}
return prpValue;
}
/// <summary>
/// wieder auf die Defaultwerte der Settings zurücksetzen!
/// </summary>
/// <param name="context"></param>
public void Reset(SettingsContext context)
{
if (this.DataFile.Exists)
{
this.Datas.Clear();
this.SaveBinary(this.DataFile, this.Datas);
}
}
/// <summary>
/// ErfinderDesRades
/// fehlende Settings werden sofort der Sammlung entfernt
/// neue hinzugekommene Settings werden beim nächsten Speichervorgang gesichert
/// </summary>
/// <param name="context"></param>
/// <param name="properties"></param>
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
{
if (this.Datas.Count == 0 && this.DataFile.Exists)
{
this.Datas = this.LoadBinary(this.DataFile);
}
List<string> toDelete = this.Datas.Keys.Except(
from SettingsProperty prop in properties
select prop.Name).ToList<string>();
toDelete.ForEach(delegate(string str)
{
this.Datas.Remove(str);
});
}
#endregion
}
}

MySettings.cs

C#-Quellcode

namespace TestApplication.Properties
// Der Name dieses Namespaces muss an die Applikationangepasst werden
{
/// <summary>
/// mit diesem Verweis wird der eigene UserSettingsProvider dem Programm untergeschoben
/// </summary>
[System.Configuration.SettingsProvider(typeof(MyProvider.UserSettingsProvider))]
internal sealed partial class Settings
{
}
}

VB1963 · 11. Dezember 2014, 15:17

Hi Rod,
ich habe heute zum ersten mal ein Formprojekt in C# erstellt und mit dem Designer einige Controls mit den Settings gebunden.
Meinen (aber in VB generierten Provider) UserSettingsProvider.dll wurde in den Verweisen angegeben...

Bekannt gegeben habe ich den Provider in Settings.cs wie folgt:

C#-Quellcode

namespace C_Test_Settings.Properties {
[System.Configuration.SettingsProvider(typeof(UserSettingsProvider.MyProvider.UserSettingsProvider))]
internal sealed partial class Settings {
}
}

~~Mir fällt da auf, dass es bei mir~~ ~~UserSettingsProvider.MyProvider.UserSettingsProvider heißen muss~~ und bei dir sehe ich MyProvider.UserSettingsProvider???
Edit: sehe gerade, geht auch so...
Des Weiteren musste ich aber meine Settings explizit beim Schließen der Form noch zum Speichern angeben.
Das autom. Speichern der Settings beim Schließen der Form dürfte es in C# nicht so geben wie in VB (Diese Option habe ich nicht finden können...):

C#-Quellcode

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
Properties.Settings.Default.Save();
}

Und es funktioniert, wie gewollt...
PS: Ich glaube, es ist egal, in welcher .net-Sprache eine .dll verfasst wurde...

VB1963 · 13. Dezember 2014, 10:43

RodFromGermany schrieb:

Ergebnis: Die Settings in C# funktionieren etwas anders als in VB.NET. Das ist vielleicht für den @ErfinderDesRades interessant.
Der linear übersetzte Code generiert auch mit SetDataFile() den DLL-Namen als Settings-File.

bei mir nicht?
Hier ist es wichtig, dass bei der AssemblyInfo der ProduktName verschieden angegeben ist.
[assembly: AssemblyProduct("Fremdanwendung")]
Ich habe jetzt ein C#-Sample angehängt und ein Bildchen, wie das bei mir aussieht...

RodFromGermany · 13. Dezember 2014, 18:07

@VB1963
Gug mal hier rein.
Da werden die Settings lokal im XML-Format gespeichert.

VB1963 · 14. Dezember 2014, 10:56

Ich habe das Initialisieren des Providers nochmals überarbeitet - Vorlage war der standardmäßige Anbieter 'LocalFileSettingsProvider'...

VB.NET-Quellcode

Namespace MyProvider
Public Class IrgendEinSettingsProvider
Inherits SettingsProvider
''' <summary>
''' Initialisiert den Anbieter (Provider)
''' </summary>
Public Overrides Sub Initialize(name As String, config As NameValueCollection)
If String.IsNullOrEmpty(name) Then name = Me.Name
MyBase.Initialize(name, config)
End Sub
''' <summary>
''' Anbieternamen angeben (Provider)
''' </summary>
''' <value></value>
Public Overrides ReadOnly Property Name As String
Get
Return "IrgendEinSettingsProvider"
End Get
End Property
''' <summary>
''' Der Provider ruft den Namen der aktuell ausgeführten Anwendung ab oder legt diesen fest.
''' </summary>
Public Overrides Property ApplicationName() As String
'
'
'

funktioniert dein Settings in C# jetzt?

RodFromGermany · 14. Dezember 2014, 11:06

VB1963 schrieb:

dein Settings in C# jetzt?

Dein "altes" ja, das "neue" noch nicht.
Ich überarbeite da gerade den Code. Wenn ich haben fertich poste ich ihn.

RodFromGermany · 15. Dezember 2014, 09:26

@VB1963 Haben fertich.
Ich hab mal die Namen der Klassen etwas angepasst. Deinen Provider hab ich umbenannt in UserSettingsProviderBin, den neuen analog in UserSettingsProviderXml.
Nutzer bitte ich, den Link auf die Lizenzbedingungen im Code stehen zu lassen.

UserSettingsProviderXml

C#-Quellcode

//************************************************************
// PortableSettingsProvider.cs
// Portable Settings Provider for C# applications
//
// 2010- Michael Nathan
// http://www.Geek-Republic.com
//
// Licensed under Creative Commons CC BY-SA
// http://creativecommons.org/licenses/by-sa/3.0/legalcode
//
//************************************************************
// Original Sources from
// http://www.geek-republic.com/2010/11/c-portable-settings-provider/
//************************************************************
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
namespace MyProvider
{
public class UserSettingsProviderXml
: SettingsProvider
{
// Define some static strings later used in our XML creation
// XML Root node
const string XmlRoot = "configuration";
// Configuration declaration node
const string ConfigNode = "configSections";
// Configuration section group declaration node
const string GroupNode = "sectionGroup";
// User section node
const string UserNode = "userSettings";
// Application Specific Node
private string AppNode;
private XmlDocument DataXml; // XmlDoc
// Override the ApplicationName property, returning the solution name. No need to set anything, we just need to
// retrieve information, though the set method still needs to be defined.
public override string ApplicationName { get; set; }
public UserSettingsProviderXml()
{
dynamic fi = new FileInfo(Assembly.GetExecutingAssembly().Location);
this.ApplicationName = fi.Name.Replace(fi.Extension, string.Empty);
this.DataXml = null;
this.AppNode = null;
}
private void InitAppNode()
{
this.AppNode = this.ApplicationName + ".Properties.Settings";
}
// Override the Initialize method
public override void Initialize(string name, NameValueCollection config)
{
System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(ApplicationName), "ApplicationName is empty");
base.Initialize(this.ApplicationName, config);
}
// Simply returns the name of the settings file, which is the solution name plus ".config"
public virtual string GetSettingsFilename()
{
// hier den Namen der Exe reinschreiben
return System.IO.Path.Combine(this.GetAppPath(), this.ApplicationName + ".exe.config");
}
// Gets current executable path in order to determine where to read and write the config file
public virtual string GetAppPath()
{
return new System.IO.FileInfo(Assembly.GetExecutingAssembly().Location).DirectoryName;
}
// Retrieve settings from the configuration file
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sContext, SettingsPropertyCollection settingsColl)
{
// Create a collection of values to return
SettingsPropertyValueCollection retValues = new SettingsPropertyValueCollection();
// Create a temporary SettingsPropertyValue to reuse
SettingsPropertyValue propVal;
// Loop through the list of settings that the application has requested and add them
// to our collection of return values.
foreach (SettingsProperty val in settingsColl)
{
propVal = new SettingsPropertyValue(val);
propVal.IsDirty = false;
propVal.SerializedValue = GetSetting(val);
retValues.Add(propVal);
}
return retValues;
}
// Save any of the applications settings that have changed (flagged as "dirty")
public override void SetPropertyValues(SettingsContext sContext, SettingsPropertyValueCollection settingsColl)
{
// Set the values in XML
foreach (SettingsPropertyValue val in settingsColl)
{
this.SetSetting(val);
}
// Write the XML file to disk
try
{
this.XMLConfig.Save(this.GetSettingsFilename());
}
catch (Exception ex)
{
// Create an informational message for the user if we cannot save the settings.
// Enable whichever applies to your application type.
// Uncomment the following line to enable a MessageBox for forms-based apps
//System.Windows.Forms.MessageBox.Show(ex.Message, "Error writting configuration file to disk", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
// Uncomment the following line to enable a console message for console-based apps
Console.WriteLine("Error writing configuration file to disk: " + ex.Message);
throw;
}
}
private XmlDocument XMLConfig
{
get
{
// Check if we already have accessed the XML config file. If the xmlDoc object is empty, we have not.
if (this.DataXml == null)
{
this.DataXml = new XmlDocument();
// If we have not loaded the config, try reading the file from disk.
try
{
// If the file does not exist on disk, catch the exception then create the XML template for the file.
this.DataXml.Load(this.GetSettingsFilename());
}
catch
{
this.InitAppNode();
// XML Declaration
// <?xml version="1.0" encoding="utf-8"?>
XmlDeclaration dec = this.DataXml.CreateXmlDeclaration("1.0", "utf-8", null);
this.DataXml.AppendChild(dec);
// Create root node and append to the document
// <configuration>
XmlElement rootNode = this.DataXml.CreateElement(XmlRoot);
this.DataXml.AppendChild(rootNode);
// Create Configuration Sections node and add as the first node under the root
// <configSections>
XmlElement configNode = this.DataXml.CreateElement(ConfigNode);
this.DataXml.DocumentElement.PrependChild(configNode);
// Create the user settings section group declaration and append to the config node above
// <sectionGroup name="userSettings"...>
XmlElement groupNode = this.DataXml.CreateElement(GroupNode);
groupNode.SetAttribute("name", UserNode);
groupNode.SetAttribute("type", "System.Configuration.UserSettingsGroup");
configNode.AppendChild(groupNode);
// Create the Application section declaration and append to the groupNode above
// <section name="AppName.Properties.Settings"...>
XmlElement newSection = this.DataXml.CreateElement("section");
newSection.SetAttribute("name", this.AppNode);
newSection.SetAttribute("type", "System.Configuration.ClientSettingsSection");
groupNode.AppendChild(newSection);
// Create the userSettings node and append to the root node
// <userSettings>
XmlElement userNode = this.DataXml.CreateElement(UserNode);
this.DataXml.DocumentElement.AppendChild(userNode);
// Create the Application settings node and append to the userNode above
// <AppName.Properties.Settings>
XmlElement appNode = this.DataXml.CreateElement(this.AppNode);
userNode.AppendChild(appNode);
}
}
return this.DataXml;
}
}
// Retrieve values from the configuration file, or if the setting does not exist in the file,
// retrieve the value from the application's default configuration
private object GetSetting(SettingsProperty setProp)
{
object retVal;
try
{
// Search for the specific settings node we are looking for in the configuration file.
// If it exists, return the InnerText or InnerXML of its first child node, depending on the setting type.
// If the setting is serialized as a string, return the text stored in the config
if (setProp.SerializeAs.ToString() == "String")
{
return XMLConfig.SelectSingleNode("//setting[@name='" + setProp.Name + "']").FirstChild.InnerText;
}
// If the setting is stored as XML, deserialize it and return the proper object. This only supports
// StringCollections at the moment - I will likely add other types as I use them in applications.
else
{
string settingType = setProp.PropertyType.ToString();
string xmlData = XMLConfig.SelectSingleNode("//setting[@name='" + setProp.Name + "']").FirstChild.InnerXml;
XmlSerializer xs = new XmlSerializer(typeof(string[]));
string[] data = (string[])xs.Deserialize(new XmlTextReader(xmlData, XmlNodeType.Element, null));
switch (settingType)
{
case "System.Collections.Specialized.StringCollection":
StringCollection sc = new StringCollection();
sc.AddRange(data);
return sc;
default:
return "";
}
}
}
catch
{
// Check to see if a default value is defined by the application.
// If so, return that value, using the same rules for settings stored as Strings and XML as above
if ((setProp.DefaultValue != null))
{
if (setProp.SerializeAs.ToString() == "String")
{
retVal = setProp.DefaultValue.ToString();
}
else
{
string settingType = setProp.PropertyType.ToString();
string xmlData = setProp.DefaultValue.ToString();
XmlSerializer xs = new XmlSerializer(typeof(string[]));
string[] data = (string[])xs.Deserialize(new XmlTextReader(xmlData, XmlNodeType.Element, null));
switch (settingType)
{
case "System.Collections.Specialized.StringCollection":
StringCollection sc = new StringCollection();
sc.AddRange(data);
return sc;
default:
return "";
}
}
}
else
{
retVal = "";
}
}
return retVal;
}
private void SetSetting(SettingsPropertyValue setProp)
{
// Define the XML path under which we want to write our settings if they do not already exist
XmlNode SettingNode = null;
try
{
// Search for the specific settings node we want to update.
// If it exists, return its first child node, (the <value>data here</value> node)
SettingNode = XMLConfig.SelectSingleNode("//setting[@name='" + setProp.Name + "']").FirstChild;
}
catch
{
SettingNode = null;
}
// If we have a pointer to an actual XML node, update the value stored there
if (SettingNode != null)
{
if (setProp.Property.SerializeAs.ToString() == "String")
{
SettingNode.InnerText = setProp.SerializedValue.ToString();
}
else
{
// Write the object to the config serialized as Xml - we must remove the Xml declaration when writing
// the value, otherwise .Net's configuration system complains about the additional declaration.
SettingNode.InnerXml = setProp.SerializedValue.ToString().Replace(@"<?xml version=""1.0"" encoding=""utf-16""?>", "");
}
}
else
{
this.InitAppNode();
// If the value did not already exist in this settings file, create a new entry for this setting
// Search for the application settings node (<Appname.Properties.Settings>) and store it.
XmlNode tmpNode = XMLConfig.SelectSingleNode("//" + this.AppNode);
// Create a new settings node and assign its name as well as how it will be serialized
XmlElement newSetting = this.DataXml.CreateElement("setting");
newSetting.SetAttribute("name", setProp.Name);
if (setProp.Property.SerializeAs.ToString() == "String")
{
newSetting.SetAttribute("serializeAs", "String");
}
else
{
newSetting.SetAttribute("serializeAs", "Xml");
}
// Append this node to the application settings node (<Appname.Properties.Settings>)
tmpNode.AppendChild(newSetting);
// Create an element under our named settings node, and assign it the value we are trying to save
XmlElement valueElement = this.DataXml.CreateElement("value");
if (setProp.Property.SerializeAs.ToString() == "String")
{
valueElement.InnerText = setProp.SerializedValue.ToString();
}
else
{
// Write the object to the config serialized as Xml - we must remove the Xml declaration when writing
// the value, otherwise .Net's configuration system complains about the additional declaration
valueElement.InnerXml = setProp.SerializedValue.ToString().Replace(@"<?xml version=""1.0"" encoding=""utf-16""?>", "");
}
// Append this new element under the setting node we created above
newSetting.AppendChild(valueElement);
}
}
}
}

VB1963 · 17. Dezember 2014, 07:07

Jetzt kann man den Speicherpfad, wo die Settings gehalten werden, selbst bestimmen...

DirectorySettingsProvider

VB.NET-Quellcode

Imports System.Configuration
Imports System.ComponentModel
Imports System.Reflection
Imports System.IO
Imports System.Security.Cryptography
Imports System.Runtime.Serialization.Formatters.Binary
Imports System.Collections.Specialized
Namespace MyProvider
''' <summary>
''' Dieser Provider speichert Settings-Einstellungen in einer eigenen .exe.config.dat-Datei.
''' Diese Datei liegt im Arbeitsverzeichnis der Anwendung.
''' Sie kann aber auch benutzerspezifisch abgelegt werden...
''' HINWEISE:
''' Die ApplicationName-Property erstellt die ProduktName-Eigenschaft von der My.Application.Info.ProduktName
''' Hier sollte in den Projekteigenschaften/Anwendung/Assemblyinformationen die Eigenschaft ProduktName=AssemblyName gestellt sein!
'''
''' Es liegt dem Provider eine eigene DirectorySettings-Class zu Grunde, die die benutzerdefinierte Path-Einstellung bereit hält.
''' (siehe weiter unten in der #Region "Directory Settings")
''' </summary>
Public Class DirectorySettingsProvider
Inherits SettingsProvider
Implements IApplicationSettingsProvider
Private Enum IO
Load = 0
Save = 1
End Enum
Private Datas As New Dictionary(Of String, Object)()
Private Property DataFile As FileInfo
''' <summary>
''' Initialisiert den Anbieter (Provider)
''' </summary>
Public Overrides Sub Initialize(name As String, config As NameValueCollection)
If String.IsNullOrEmpty(name) Then name = Me.Name
MyBase.Initialize(name, config)
End Sub
''' <summary>
''' Anbieternamen festlegen (Provider)
''' </summary>
Public Overrides ReadOnly Property Name As String
Get
Return "DirectorySettingsProvider"
End Get
End Property
''' <summary>
''' Der Provider ruft den Namen der aktuell ausgeführten Anwendung ab oder legt diesen fest.
''' Hinweis: hier wird der Produktname von der AssemblyInfo ausgewertet
''' </summary>
Public Overrides Property ApplicationName() As String
''' <summary>
''' SetPropertyValues wird erst abgearbeitet, wenn ApplicationSettingsBase.Save durchgeführt wird.
''' ApplicationSettingsBase stellt sicher, dass für jeden einzelnen Provider nur seine markierten Werte herangenommen werden.
''' Egal, ob der Provider auf einer Einzel-Einstellung angesetzt ist oder ob klassenweit die Einstellung angegeben wurde.
''' Wenn Einstellungen nicht verändert wurden, müssen sie nicht gespeichert werden!
''' Anwendungsspezifische Einstellungen können nicht geändert werden und werden daher auch nicht gespeichert!
''' </summary>
''' <param name="context"></param>
''' <param name="collection"></param>
Public Overrides Sub SetPropertyValues(ByVal context As SettingsContext, ByVal collection As SettingsPropertyValueCollection)
For Each prpValue As SettingsPropertyValue In collection
If Not prpValue.IsDirty OrElse (prpValue.SerializedValue Is Nothing) Then Continue For
If IsApplicationScoped(prpValue.Property) Then Continue For
Datas(prpValue.Name) = prpValue.SerializedValue
Next
persistsFile(IO.Save, context)
End Sub
Public Overrides Function GetPropertyValues(ByVal context As SettingsContext, ByVal collection As SettingsPropertyCollection) As SettingsPropertyValueCollection
persistsFile(IO.Load, context)
Dim col As New SettingsPropertyValueCollection()
For Each prp As SettingsProperty In collection
Dim Value As New SettingsPropertyValue(prp)
If Datas.ContainsKey(prp.Name) Then Value = GetPropertyValue(prp) ' Wert von Datas einlesen
col.Add(Value)
Next
Return col
End Function
''' <summary>
''' Nur benutzerspezifische Eigenschaften sind zulässig.
''' Wenn eine Eigenschaft keinen Wert hat, wird der Defaultwert geladen.
''' </summary>
''' <param name="prp"></param>
Private Function GetPropertyValue(ByVal prp As SettingsProperty) As SettingsPropertyValue
Dim value As New SettingsPropertyValue(prp)
If IsUserScoped(prp) Then value.SerializedValue = Datas(prp.Name)
value.IsDirty = False
Return value
End Function
''' <summary>
''' Test auf anwendungsspezifische Eigenschaft
''' </summary>
''' <param name="prop"></param>
Private Function IsApplicationScoped(ByVal prop As SettingsProperty) As Boolean
Return HasSettingScope(prop, GetType(ApplicationScopedSettingAttribute))
End Function
''' <summary>
''' Test auf benutzerdefinierte Eigenschaft
''' </summary>
''' <param name="prop"></param>
Private Function IsUserScoped(prop As SettingsProperty) As Boolean
Return HasSettingScope(prop, GetType(UserScopedSettingAttribute))
End Function
''' <summary>
''' prüft auf erlaubte Einstellung, so wie es der LocalFileSettingsProvider auch macht ...
''' </summary>
''' <param name="prop"></param>
''' <param name="attributeType"></param>
Private Function HasSettingScope(ByVal prop As SettingsProperty, ByVal attributeType As Type) As Boolean
Dim isAppScoped As Boolean = prop.Attributes(GetType(ApplicationScopedSettingAttribute)) IsNot Nothing
Dim isUserScoped As Boolean = prop.Attributes(GetType(UserScopedSettingAttribute)) IsNot Nothing
If isUserScoped AndAlso isAppScoped Then Throw New Exception("BothScopeAttributes: " & prop.Name)
If Not isUserScoped AndAlso Not isAppScoped Then Throw New Exception("NoScopeAttributes: " & prop.Name)
Select Case True
Case attributeType Is GetType(ApplicationScopedSettingAttribute) : Return isAppScoped
Case attributeType Is GetType(UserScopedSettingAttribute) : Return isUserScoped
Case Else : Return False
End Select
End Function
#Region "IApplicationSettingsProvider Members"
''' <summary>
''' Abrufen der letzten Version der Settingseigenschaft
''' </summary>
''' <param name="context"></param>
''' <param name="property"></param>
Public Function GetPreviousVersion(ByVal context As SettingsContext, ByVal [property] As SettingsProperty) As SettingsPropertyValue Implements IApplicationSettingsProvider.GetPreviousVersion
Dim prpValue As New SettingsPropertyValue([property])
If Datas.ContainsKey([property].Name) Then prpValue.PropertyValue = Datas([property].Name)
Return prpValue
End Function
''' <summary>
''' Wieder auf die Defaultwerte der Settings zurücksetzen!
''' </summary>
''' <param name="context"></param>
Public Sub Reset(ByVal context As SettingsContext) Implements IApplicationSettingsProvider.Reset
SetDataFile(context)
If DataFile.Exists Then Datas.Clear() : PersistsFile(IO.Save, context)
End Sub
''' <summary>
''' ErfinderDesRades
''' Fehlende Settings werden sofort in der Sammlung entfernt
''' Neue hinzugekommene Settings werden beim nächsten Speichervorgang gesichert
''' </summary>
''' <param name="context"></param>
''' <param name="properties"></param>
Public Sub Upgrade(ByVal context As SettingsContext, ByVal properties As SettingsPropertyCollection) Implements IApplicationSettingsProvider.Upgrade
If Datas.Count = 0 Then PersistsFile(IO.Load, context)
Dim toDelete = Datas.Keys.Except(properties.Cast(Of SettingsProperty).Select(Function(p) p.Name)).ToList
toDelete.ForEach(AddressOf Datas.Remove)
End Sub
#End Region
#Region "Load/Save Binary"
''' <summary>
''' Nach Inhalt des SettingsContext wird die Zuteilung des DataFiles bestimmt.
''' </summary>
''' <param name="context"></param>
Private Sub SetDataFile(context As SettingsContext)
Dim fi = New FileInfo(Assembly.GetExecutingAssembly.Location)
Dim AppPath = fi.Directory.ToString
Select Case True
Case context("SettingsClassType").ToString.Contains("DirectorySettings") ' Directory-Daten werden im Anwendungspfad gehalten
DataFile = New FileInfo(Path.Combine(AppPath, String.Concat(ApplicationName, ".dat")))
Case Else ' Settings-Daten
Dim dir As New DirectorySettings
Dim tmpPath = dir.DirectoryName
Dim tmpFile = dir.FileName
If String.IsNullOrEmpty(tmpPath) OrElse String.IsNullOrEmpty(tmpFile) Then
DataFile = New FileInfo(Path.Combine(AppPath, String.Concat(ApplicationName, ".exe.config.dat"))) ' Anwendungspfad
Else
DataFile = New FileInfo(Path.Combine(tmpPath, tmpFile)) ' benutzerdefinierter Pfad
End If
End Select
End Sub
Private Sub PersistsFile(Method As IO, context As SettingsContext)
SetDataFile(context)
If Method = IO.Load Then
If DataFile.Exists Then Datas = LoadBinary(DataFile)
ElseIf Method = IO.Save Then
SaveBinary(DataFile, Datas)
End If
End Sub
''' <summary>
''' Daten binär speichern
''' </summary>
''' <param name="DataFile"></param>
''' <param name="Datas"></param>
Private Sub SaveBinary(DataFile As FileInfo, Datas As Dictionary(Of String, Object))
' DeleteLocalPathUserSettings()
Using fs As Stream = File.Create(DataFile.FullName)
Dim binfmt As New BinaryFormatter()
binfmt.Serialize(fs, Datas)
End Using
End Sub
' ''' <summary>
' ''' falls der LocalUserAppDataPath vorhanden ist,
' ''' wird der Ordner mit allen untergeordneten Verzeichnissen gelöscht
' ''' </summary>
' Private Sub DeleteLocalPathUserSettings()
' Dim di As New DirectoryInfo(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal).FilePath)
' di = di.Parent.Parent.Parent
' If di.Exists Then di.Delete(True)
' End Sub
''' <summary>
''' binäre Daten laden
''' </summary>
''' <param name="DataFile"></param>
Private Function LoadBinary(DataFile As FileInfo) As Dictionary(Of String, Object)
Using fs As Stream = File.Open(DataFile.FullName, FileMode.Open)
Dim binfmt As New BinaryFormatter()
Return CType(binfmt.Deserialize(fs), Dictionary(Of String, Object))
End Using
End Function
#End Region
End Class
End Namespace

Dieser Provider benötigt noch eine extra Settings-Klasse, wo der benutzerdefinierte Pfad abgelegt wird:

DirectorySettings-Class

VB.NET-Quellcode

Namespace MyProvider
''' <summary>
''' Diese Klasse versorgt den benutzerdefinierten SettingsPath.
''' </summary>
<SettingsProvider(GetType(DirectorySettingsProvider))> _
Public NotInheritable Class DirectorySettings
Inherits ApplicationSettingsBase
''' <summary>
''' Hier wird das Verzeichnis gehalten
''' </summary>
<UserScopedSettingAttribute(), DefaultSettingValueAttribute("")> _
Public Property DirectoryName As String
Get
Return CType(Me("DirectoryName"), String)
End Get
Set(ByVal value As String)
Me("DirectoryName") = value
End Set
End Property
''' <summary>
''' Hier wird der Filename gehalten
''' </summary>
<UserScopedSettingAttribute(), DefaultSettingValueAttribute("")> _
Public Property FileName As String
Get
Return CType(Me("FileName"), String)
End Get
Set(ByVal value As String)
Me("FileName") = value
End Set
End Property
End Class
End Namespace

Per Code kann man dann seinen selbstdefinierten Speicherpfad für die Settings angeben...
(d.h. außerhalb des Providers...)

VB.NET-Quellcode

'Beispiel:
Dim mySettings As New DirectorySettings
mySettings.DirectoryName = "C:\"
mySettings.FileName = "DirectorySettingsTest.config.dat"
mySettings.Save() ' muss explizit gepeichert werden...

RodFromGermany · 22. März 2015, 11:19

@VB1963 @ErfinderDesRades
Das dürfte Euch beide interessieren.

habe ich festgestellt, dass beim Binden des Settings FormSize an die Property ClientSize das Form-Design Anchor flöten geht.
Leider hab ich da erst mal nix anderes gefunden, als das zu Fuß zu binden:
C#-Quellcode
1. Settings.Default.FormSize = this.Size; // Form_Closing
2. Properties.Settings.Default.Save();
3. // bzw.
4. this.Size = Settings.Default.FormSize; // Form1_Load
habe ich wieder mit XML-Settings experimentiert, weil mir die von mir vorgeschlagene Methode bei einem Projekt um die Ohren geflogen ist.
Daraufhin habe ich den SettingsProviderBin von @VB1963 dahingehend modifiziert, dass ich das Dictionary<string, object> in ein SerializableDictionary<TKey, TValue> (Quelle hier) überführt habe.
Desweiteren habe ich festgestellt, dass (wahrscheinlich) alle Typen von Settings als String serialisiert werden, auch eine System.Collections.Specialized.StringCollection, so dass bei Verwendung von XmlSerializer(typeof(string)) das ganze XML-Handling elementar einfach wird. Unter Weglassung der vielen XML-Start- und Endelemente sieht die Klasse SerializableDictionary nun so aus:

Spoiler anzeigen

C#-Quellcode

/// <summary>
/// Represents an XML serializable collection of keys and values.
/// </summary>
/// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
/// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
[XmlRoot("Settings")]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{
#region Constants
/// <summary>
/// The default XML tag name for an item.
/// </summary>
private const string ItemTagName = "Item";
/// <summary>
/// The default XML tag name for a key.
/// </summary>
private const string KeyTagName = "Key";
/// <summary>
/// The default XML tag name for a value.
/// </summary>
private const string ValueTagName = "Value";
#endregion
#region Public Methods
/// <summary>
/// Gets the XML schema for the XML serialization.
/// </summary>
/// <returns>An XML schema for the serialized object.</returns>
public XmlSchema GetSchema()
{
// für IXmlSerializable
return null;
}
/// <summary>
/// Deserializes the object from XML.
/// </summary>
/// <param name="reader">The XML representation of the object.</param>
public void ReadXml(XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
//XmlSerializer valueSerialObject = new XmlSerializer(typeof(TValue));
XmlSerializer valueSerialString = new XmlSerializer(typeof(string));
object obj;
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemTagName);
obj = reader.ReadElementString(KeyTagName);
TKey key = (TKey)obj;
obj = reader.ReadElementString(ValueTagName);
TValue value = (TValue)obj;
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
/// <summary>
/// Serializes this instance to XML.
/// </summary>
/// <param name="writer">The writer to serialize to.</param>
public void WriteXml(XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
//XmlSerializer valueSerialObject = new XmlSerializer(typeof(TValue));
XmlSerializer valueSerialString = new XmlSerializer(typeof(string));
foreach (TKey key in this.Keys)
{
TValue value = this[key];
Type T = value.GetType();
writer.WriteStartElement(ItemTagName);
writer.WriteElementString(KeyTagName, key.ToString());
writer.WriteElementString(ValueTagName, value.ToString());
writer.WriteEndElement();
}
}
#endregion
}

Die generierte XML-Datei sieht so aus:
TestUserSettingsPovider.exe.config.xml
-------
Sorry, die ganze neue Klasse UserSettingsProviderXml mit Serialisierung und Deserialisierung:

Spoiler anzeigen

C#-Quellcode

using System;
using System.Configuration;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Reflection;
using System.Linq;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;
// http://stackoverflow.com/questions/12554186/how-to-serialize-deserialize-to-dictionaryint-string-from-custom-xml-not-us
namespace UserSettingsProvider
{
/// <summary>
/// Dieser Provider speichert die betroffenen Settings-Einstellungen in eine eigene .exe.config.dat-Datei.
/// Diese Datei liegt im Arbeitsverzeichnis der Anwendung.
/// HINWEISE:
/// Die ApplicationName-Property erstellt die ProduktName-Eigenschaft von der My.Application.Info.ProduktName
/// Hier sollte in den Projekteigenschaften/Anwendung/Assemblyinformationen die Eigenschaft ProduktName = AssemblyName gestellt sein!
/// </summary>
/// <remarks></remarks>
public class UserSettingsProviderXml
: SettingsProvider, IApplicationSettingsProvider
{
/// <summary>
/// Represents an XML serializable collection of keys and values.
/// </summary>
/// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
/// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
[XmlRoot("Settings")]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{
#region Constants
/// <summary>
/// The default XML tag name for an item.
/// </summary>
private const string ItemTagName = "Item";
/// <summary>
/// The default XML tag name for a key.
/// </summary>
private const string KeyTagName = "Key";
/// <summary>
/// The default XML tag name for a value.
/// </summary>
private const string ValueTagName = "Value";
#endregion
#region Public Methods
/// <summary>
/// Gets the XML schema for the XML serialization.
/// </summary>
/// <returns>An XML schema for the serialized object.</returns>
public XmlSchema GetSchema()
{
// für IXmlSerializable
return null;
}
/// <summary>
/// Deserializes the object from XML.
/// </summary>
/// <param name="reader">The XML representation of the object.</param>
public void ReadXml(XmlReader reader)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
//XmlSerializer valueSerialObject = new XmlSerializer(typeof(TValue));
XmlSerializer valueSerialString = new XmlSerializer(typeof(string));
object obj;
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemTagName);
obj = reader.ReadElementString(KeyTagName);
TKey key = (TKey)obj;
obj = reader.ReadElementString(ValueTagName);
TValue value = (TValue)obj;
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
/// <summary>
/// Serializes this instance to XML.
/// </summary>
/// <param name="writer">The writer to serialize to.</param>
public void WriteXml(XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
//XmlSerializer valueSerialObject = new XmlSerializer(typeof(TValue));
XmlSerializer valueSerialString = new XmlSerializer(typeof(string));
foreach (TKey key in this.Keys)
{
TValue value = this[key];
//Type T = value.GetType();
writer.WriteStartElement(ItemTagName);
writer.WriteElementString(KeyTagName, key.ToString());
writer.WriteElementString(ValueTagName, value.ToString());
writer.WriteEndElement();
}
}
#endregion
}
private SerializableDictionary<string, object> DataXml;
// hier wird der Produktname von der Assembly angegeben
public override string ApplicationName { get; set; }
private FileInfo DataFile { get; set; }
private string AppPath { get; set; }
public UserSettingsProviderXml()
{
dynamic fi = new FileInfo(Assembly.GetExecutingAssembly().Location);
this.ApplicationName = fi.Name.Replace(fi.Extension, string.Empty);
this.DataXml = new SerializableDictionary<string, object>();
this.DataFile = null;
}
public override void Initialize(string name, NameValueCollection config)
{
System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(ApplicationName), "ApplicationName is empty");
base.Initialize(this.ApplicationName, config);
}
/// <summary>
/// SetPropertyValues wird erst abgearbeitet, wenn ApplicationSettingsBase.Save durchgeführt wird.
/// ApplicationSettingsBase stellt sicher, dass für jeden einzelnen Provider nur seine markierten Werte herangenommen werden.
/// Egal, ob der Provider auf einer Einzel-Einstellung angesetzt ist oder ob klassenweit die Einstellung angegeben wurde.
/// Wenn Einstellungen nicht verändert wurden, müssen sie nicht gespeichert werden!
/// Anwendungsspezifische Einstellungen können nicht geändert werden und werden daher auch nicht gespeichert!
/// </summary>
/// <param name="context"></param>
/// <param name="collection"></param>
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection)
{
foreach (SettingsPropertyValue prpValue in collection)
{
if (!prpValue.IsDirty || (prpValue.SerializedValue == null))
{
continue;
}
if (this.IsApplicationScoped(prpValue.Property))
{
continue;
}
this.DataXml[prpValue.Name] = prpValue.SerializedValue;
}
this.SaveSettings();
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
this.SetDataFile();
if (this.DataFile.Exists)
{
this.LoadSettings();
}
SettingsPropertyValueCollection col = new SettingsPropertyValueCollection();
foreach (SettingsProperty prp in collection)
{
SettingsPropertyValue value = new SettingsPropertyValue(prp);
if (this.DataXml.ContainsKey(prp.Name))
{
value = GetPropertyValue(prp);
}
// Wert von Datas einlesen
col.Add(value);
}
return col;
}
/// <summary>
/// Nur benutzerspezifische Eigenschaften sind zulässig.
/// Wenn eine Eigenschaft keinen Wert hat, wird der Defaultwert geladen.
/// </summary>
/// <param name="prp"></param>
private SettingsPropertyValue GetPropertyValue(SettingsProperty prp)
{
SettingsPropertyValue value = new SettingsPropertyValue(prp);
if (this.IsUserScoped(prp))
{
value.SerializedValue = this.DataXml[prp.Name];
}
value.IsDirty = false;
return value;
}
/// <summary>
/// Test auf anwendungsspezifische Eigenschaft
/// </summary>
/// <param name="prop"></param>
private bool IsApplicationScoped(SettingsProperty prop)
{
return HasSettingScope(prop, typeof(ApplicationScopedSettingAttribute));
}
/// <summary>
/// Test auf benutzerdefinierte Eigenschaft
/// </summary>
/// <param name="prop"></param>
private bool IsUserScoped(SettingsProperty prop)
{
return HasSettingScope(prop, typeof(UserScopedSettingAttribute));
}
/// <summary>
/// prüft auf erlaubte Einstellung, so wie es der LocalFileSettingsProvider auch macht ...
/// </summary>
/// <param name="prop"></param>
/// <param name="attributeType"></param>
private bool HasSettingScope(SettingsProperty prop, Type attributeType)
{
bool isAppScoped = prop.Attributes[typeof(ApplicationScopedSettingAttribute)] != null;
bool isUserScoped = prop.Attributes[typeof(UserScopedSettingAttribute)] != null;
if (isUserScoped && isAppScoped)
{
throw new ConfigurationErrorsException("Both Scope Attributes: " + prop.Name);
}
if (!isUserScoped && !isAppScoped)
{
throw new ConfigurationErrorsException("No Scope Attributes: " + prop.Name);
}
if (object.ReferenceEquals(attributeType, typeof(ApplicationScopedSettingAttribute)))
{
return isAppScoped;
}
if (object.ReferenceEquals(attributeType, typeof(UserScopedSettingAttribute)))
{
return isUserScoped;
}
return false;
}
/// <summary>
/// Datenfile der gerade aktiven Anwendung bestimmen
/// </summary>
/// <remarks></remarks>
private void SetDataFile()
{
FileInfo fi = new FileInfo(Assembly.GetExecutingAssembly().Location);
this.AppPath = fi.DirectoryName;
this.DataFile = new FileInfo(Path.Combine(this.AppPath, string.Concat(this.ApplicationName, ".config.xml")));
}
/// <summary>
/// binäre Daten laden
/// </summary>
/// <param name="DataFile"></param>
private void LoadSettings()
{
this.SetDataFile();
using (XmlReader reader = XmlReader.Create(this.DataFile.FullName))
{
reader.ReadStartElement("Settings");
this.DataXml.ReadXml(reader);
}
}
/// <summary>
/// Daten binär speichern
/// </summary>
/// <param name="DataFile"></param>
/// <param name="Datas"></param>
private void SaveSettings()
{
this.SetDataFile();
this.DeleteLocalPathUserSettings();
using (XmlWriter writer = XmlWriter.Create(this.DataFile.FullName))
{
writer.WriteStartElement("Settings");
this.DataXml.WriteXml(writer);
writer.WriteEndElement();
writer.Flush();
}
}
/// <summary>
/// falls der LocalUserAppDataPath vorhanden ist,
/// wird der Ordner mit allen untergeordneten Verzeichnissen gelöscht
/// </summary>
/// <remarks></remarks>
private void DeleteLocalPathUserSettings()
{
DirectoryInfo di = new DirectoryInfo(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal).FilePath);
di = di.Parent.Parent.Parent;
if (di.Exists)
{
di.Delete(true);
}
}
#region "IApplicationSettingsProvider Members"
/// <summary>
/// Abrufen der letzten Version der Settingseigenschaft
/// </summary>
/// <param name="context"></param>
/// <param name="property"></param>
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
SettingsPropertyValue prpValue = new SettingsPropertyValue(property);
if (this.DataXml.ContainsKey(property.Name))
{
prpValue.PropertyValue = this.DataXml[property.Name];
}
return prpValue;
}
/// <summary>
/// wieder auf die Defaultwerte der Settings zurücksetzen!
/// </summary>
/// <param name="context"></param>
public void Reset(SettingsContext context)
{
if (this.DataFile.Exists)
{
this.DataXml.Clear();
this.SaveSettings();
}
}
/// <summary>
/// ErfinderDesRades
/// fehlende Settings werden sofort der Sammlung entfernt
/// neue hinzugekommene Settings werden beim nächsten Speichervorgang gesichert
/// </summary>
/// <param name="context"></param>
/// <param name="properties"></param>
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
{
if (this.DataXml.Count == 0 && this.DataFile.Exists)
{
this.LoadSettings();
}
List<string> toDelete = this.DataXml.Keys.Except(from SettingsProperty prop in properties select prop.Name).ToList<string>();
toDelete.ForEach(delegate(string str)
{
this.DataXml.Remove(str);
});
}
#endregion
}
}

UserSettingsProvider (Persistieren von UserSettings)

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

RodFromGermany schrieb:

VB.NET-Quellcode

VB1963 schrieb:

C#-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

Tags

Ähnliche Themen

3 Benutzer haben hier geschrieben