public static string GetDescription(SettingsProperty property) { SettingsDescriptionAttribute a = CollectionUtils.SelectFirst(property.Attributes, attribute => attribute is SettingsDescriptionAttribute) as SettingsDescriptionAttribute; return a == null ? "" : a.Description; }
private void CreatePropNode(SettingsProperty setting, SettingsPropertyValue value, SettingsContext context) { string xPathQuery = getXPathQuerySection(setting, context); XmlNode groupNode = doc.SelectSingleNode(xPathQuery); if (groupNode == null) { groupNode = doc.CreateElement(GetSectionName(context)); if (this.IsUserScoped(setting)) { userSettings.AppendChild(groupNode); } else { appSettings.AppendChild(groupNode); } } //if (node == null) XmlNode nodeProp = doc.CreateElement(setting.Name); nodeProp.AppendChild(this.SerializeToXmlElement(setting, value)); groupNode.AppendChild(nodeProp); }
public Settings() { // // To add event handlers for saving and changing settings, uncomment the lines below: // // this.SettingChanging += this.SettingChangingEventHandler; // // this.SettingsSaving += this.SettingsSavingEventHandler; // for (int i = 0; i < MaxExternalTools; i++) { SettingsProperty newProp = new SettingsProperty( "ExternalTool" + i, typeof(ExternalTool), this.Providers[Path.GetFileName(System.Reflection.Assembly.GetEntryAssembly().Location)], false, null, SettingsSerializeAs.String, null, true, true ); this.Properties.Add(newProp); } this.SettingsLoaded += new System.Configuration.SettingsLoadedEventHandler(Settings_SettingsLoaded); }
public void SettingValuesCreatesAnAppAndUserId() { MySQLProfileProvider provider = InitProfileProvider(); SettingsContext ctx = new SettingsContext(); ctx.Add("IsAuthenticated", false); ctx.Add("UserName", "user1"); SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); SettingsProperty property1 = new SettingsProperty("color"); property1.PropertyType = typeof(string); property1.Attributes["AllowAnonymous"] = true; SettingsPropertyValue value = new SettingsPropertyValue(property1); value.PropertyValue = "blue"; values.Add(value); provider.SetPropertyValues(ctx, values); DataTable dt = FillTable("SELECT * FROM my_aspnet_applications"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_users"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_profiles"); Assert.AreEqual(1, dt.Rows.Count); values["color"].PropertyValue = "green"; provider.SetPropertyValues(ctx, values); dt = FillTable("SELECT * FROM my_aspnet_applications"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_users"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_profiles"); Assert.AreEqual(1, dt.Rows.Count); }
private SettingsProperty CreateSetting(PropertyInfo propInfo) { object[] customAttributes = propInfo.GetCustomAttributes(false); SettingsProperty property = new SettingsProperty(this.Initializer); bool flag = this._explicitSerializeOnClass; property.Name = propInfo.Name; property.PropertyType = propInfo.PropertyType; for (int i = 0; i < customAttributes.Length; i++) { Attribute attribute = customAttributes[i] as Attribute; if (attribute != null) { if (attribute is DefaultSettingValueAttribute) { property.DefaultValue = ((DefaultSettingValueAttribute) attribute).Value; } else if (attribute is ReadOnlyAttribute) { property.IsReadOnly = true; } else if (attribute is SettingsProviderAttribute) { string providerTypeName = ((SettingsProviderAttribute) attribute).ProviderTypeName; Type type = Type.GetType(providerTypeName); if (type == null) { throw new ConfigurationErrorsException(System.SR.GetString("ProviderTypeLoadFailed", new object[] { providerTypeName })); } SettingsProvider provider = SecurityUtils.SecureCreateInstance(type) as SettingsProvider; if (provider == null) { throw new ConfigurationErrorsException(System.SR.GetString("ProviderInstantiationFailed", new object[] { providerTypeName })); } provider.Initialize(null, null); provider.ApplicationName = ConfigurationManagerInternalFactory.Instance.ExeProductName; SettingsProvider provider2 = this._providers[provider.Name]; if (provider2 != null) { provider = provider2; } property.Provider = provider; } else if (attribute is SettingsSerializeAsAttribute) { property.SerializeAs = ((SettingsSerializeAsAttribute) attribute).SerializeAs; flag = true; } else { property.Attributes.Add(attribute.GetType(), attribute); } } } if (!flag) { property.SerializeAs = this.GetSerializeAs(propInfo.PropertyType); } return property; }
public ProfilePropertyViewModel(SettingsProperty property, ProfilePropertyInputModel value) { Type = PropTypeFromPropertyType(property); Description = property.Name + " must be of type " + property.PropertyType.Name; if (property.PropertyType.IsValueType) Description += " and is required"; Description += "."; Data = value; }
public ProfilePropertyViewModel(SettingsProperty property, string value) : this(property, new ProfilePropertyInputModel { Name = property.Name, Value = value }) { }
private Property CreateProperty(PropertyInfo property, SettingsProperty settingsProperty, SettingsPropertyValueCollection settingsPropertyValues) { var descriptor = new SettingsPropertyDescriptor(property); var settingsPropertyValue = settingsPropertyValues[settingsProperty.Name]; var defaultValue = settingsProperty.DefaultValue; var serializedValue = settingsPropertyValue == null ? null : settingsPropertyValue.SerializedValue; return new Property(descriptor, (serializedValue ?? defaultValue).ToString()); }
public ProfilePropertyViewModel(SettingsProperty property, ProfilePropertyInputModel value) { Type = PropTypeFromPropertyType(property); Description = string.Format(property.PropertyType.IsValueType ? Resources.ProfilePropertyViewModel.RequiredPropertyMustBeOfType : Resources.ProfilePropertyViewModel.RequiredProperty, property.Name, property.PropertyType.Name); Data = value; }
public void Add () { SettingsPropertyCollection col = new SettingsPropertyCollection (); SettingsProperty test_prop = new SettingsProperty ("test_prop"); Assert.AreEqual (0, col.Count, "A1"); col.Add (test_prop); Assert.AreEqual (1, col.Count, "A2"); }
private static SettingsProperty AddSettingItem(string Name, Type type) { System.Configuration.SettingsProperty Property = new System.Configuration.SettingsProperty(Name); Property.DefaultValue = true; Property.IsReadOnly = false; Property.PropertyType = type; Property.Provider = AppSettings.Default.Providers["LocalFileSettingsProvider"]; Property.Attributes.Add(typeof(System.Configuration.UserScopedSettingAttribute), new System.Configuration.UserScopedSettingAttribute()); AppSettings.Default.Properties.Add(Property); return(Property); }
public void Add (SettingsProperty property) { if (isReadOnly) throw new NotSupportedException (); OnAdd (property); /* actually do the add */ items.Add (property.Name, property); OnAddComplete (property); }
private bool IsRoaming(SettingsProperty prop) { foreach (DictionaryEntry entry in prop.Attributes) { Attribute attribute = (Attribute) entry.Value; if (attribute is SettingsManageabilityAttribute) { return true; } } return false; }
//////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// public SettingsProperty(SettingsProperty propertyToCopy) { _Name = propertyToCopy.Name; _IsReadOnly = propertyToCopy.IsReadOnly; _DefaultValue = propertyToCopy.DefaultValue; _SerializeAs = propertyToCopy.SerializeAs; _Provider = propertyToCopy.Provider; _PropertyType = propertyToCopy.PropertyType; _ThrowOnErrorDeserializing = propertyToCopy.ThrowOnErrorDeserializing; _ThrowOnErrorSerializing = propertyToCopy.ThrowOnErrorSerializing; _Attributes = new SettingsAttributeDictionary(propertyToCopy.Attributes); }
public SettingsProperty (SettingsProperty propertyToCopy) : this (propertyToCopy.Name, propertyToCopy.PropertyType, propertyToCopy.Provider, propertyToCopy.IsReadOnly, propertyToCopy.DefaultValue, propertyToCopy.SerializeAs, new SettingsAttributeDictionary (propertyToCopy.Attributes), propertyToCopy.ThrowOnErrorDeserializing, propertyToCopy.ThrowOnErrorSerializing) { }
private void ValidateProperty(string propertyName, Type propertyType) { System.Configuration.SettingsProperty property = Properties.Settings.Default.Properties[propertyName]; if (property == null) { System.Configuration.SettingsProperty propInitializer = Properties.Settings.Default.Properties["Initializer"]; property = new System.Configuration.SettingsProperty(propInitializer); property.Name = propertyName; property.PropertyType = propertyType; property.DefaultValue = null; Properties.Settings.Default.Properties.Add(property); } }
static SettingsPropertyValue GetSettingConverter(Type type, string name) { TypeConverter c = TypeDescriptor.GetConverter(type); SettingsSerializeAs ssa; if (c.CanConvertFrom(typeof(string)) && c.CanConvertTo(typeof(string))) { ssa = SettingsSerializeAs.String; } else { ssa = SettingsSerializeAs.Xml; } SettingsProperty p = new SettingsProperty(name); p.PropertyType = type; p.SerializeAs = ssa; return new SettingsPropertyValue(p); }
public void Remove () { SettingsPropertyValueCollection col = new SettingsPropertyValueCollection (); SettingsProperty test_prop = new SettingsProperty ("test_prop"); SettingsPropertyValue val = new SettingsPropertyValue (test_prop); col.Add (val); Assert.AreEqual (1, col.Count, "A1"); col.Remove ("test_prop"); Assert.AreEqual (0, col.Count, "A2"); }
private string GetValue(SettingsProperty setting) { try { return this.SettingsXML.SelectSingleNode("Settings/" + setting.Name).InnerText; } catch (Exception) { if (setting.DefaultValue != null) { return setting.DefaultValue.ToString(); } return ""; } }
void AddProperty(String propertyName, Color defaultValue, Type propertyType) { String providerName = "LocalFileSettingsProvider"; var attributes = new System.Configuration.SettingsAttributeDictionary(); var attr = new System.Configuration.UserScopedSettingAttribute(); attributes.Add(attr.TypeId, attr); SettingsProvider settingProvider = Properties.Settings.Default.Providers[providerName]; var prop = new System.Configuration.SettingsProperty( new System.Configuration.SettingsProperty(propertyName, propertyType, settingProvider, false, defaultValue, System.Configuration.SettingsSerializeAs.String, attributes, false, false)); MYAPPCS.Properties.Settings.Default.Properties.Add(prop); }
//////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// public void Add(SettingsProperty property) { if (_ReadOnly) throw new NotSupportedException(); OnAdd(property); _Hashtable.Add(property.Name, property); try { OnAddComplete(property); } catch { _Hashtable.Remove(property.Name); throw; } }
static void TestApplicationSettings() { Console.WriteLine(); Console.WriteLine("Settings Designer Settings"); Console.WriteLine(); string applicationSettingsKey1Name = "ApplicationSettingsKey1"; string applicationSettingsKey1Value = Properties.Settings.Default.ApplicationSettingsKey1; Console.WriteLine("String ApplicationSettings Value of \"{0}\" is \"{1}\"", applicationSettingsKey1Name, applicationSettingsKey1Value); var applicationSettingsPropertyCollection = Properties.Settings.Default.Properties; System.Configuration.SettingsProperty applicationSettingsProperty = applicationSettingsPropertyCollection[applicationSettingsKey1Name]; string applicationSettingsPropertyName1 = applicationSettingsProperty.Name; string applicationSettingsPropertyValue1 = (string)applicationSettingsProperty.DefaultValue; Console.WriteLine("Object ApplicationSettings Value of \"{0}\" is \"{1}\"", applicationSettingsKey1Name, applicationSettingsKey1Value); }
public WindowSettings(SettingsBase settings, Form form, string prefix) { if (settings == null) throw new ArgumentNullException("settings"); if (form == null) throw new ArgumentNullException("form"); _form = form; _settings = settings; if (string.IsNullOrEmpty(prefix)) prefix = form.GetType().Name; var properties = settings.Properties; _location = properties[prefix + "Location"]; _size = properties[prefix + "Size"]; _windowState = properties[prefix + "WindowState"]; form.Load += OnFormLoad; form.Closing += OnFormClosing; form.Disposed += OnFormDisposed; }
public static void Save(MainWindowViewModel vm) { //add lang setting System.Configuration.SettingsProperty langproperty = new System.Configuration.SettingsProperty("SelectedLang"); langproperty.DefaultValue = true; langproperty.IsReadOnly = false; langproperty.PropertyType = typeof(int); langproperty.Provider = AppSettings.Default.Providers["LocalFileSettingsProvider"]; langproperty.Attributes.Add(typeof(System.Configuration.UserScopedSettingAttribute), new System.Configuration.UserScopedSettingAttribute()); AppSettings.Default.Properties.Add(langproperty); AppSettings.Default["SelectedLang"] = vm.settingsTabViewModel.SelectedLangItem; SaveCheckBoxes(vm.cleanerTabViewModel.ListOfWindowsElements); //for plugins SaveCheckBoxes(vm.cleanerTabViewModel.ListOfOtherElemets); //for registry tab SaveRegistryCheckBoxes(vm); // AppSettings.Default.Save(); AppSettings.Default.Properties.Clear(); }
public void Ctor_1 () { SettingsProperty p = new SettingsProperty ("property", typeof (int), null, true, 10, SettingsSerializeAs.Binary, null, true, false); Assert.AreEqual ("property", p.Name, "A1"); Assert.AreEqual (typeof (int), p.PropertyType, "A2"); Assert.AreEqual (null, p.Provider, "A3"); Assert.AreEqual (10, (int)p.DefaultValue, "A4"); Assert.AreEqual (SettingsSerializeAs.Binary, p.SerializeAs, "A5"); Assert.IsNull (p.Attributes, "A6"); Assert.IsTrue (p.ThrowOnErrorDeserializing, "A7"); Assert.IsFalse (p.ThrowOnErrorSerializing, "A8"); Assert.IsTrue (p.IsReadOnly, "A9"); }
public void SaveToConfig(System.Configuration.ApplicationSettingsBase settings) { //settings.MRPath0 = files[0]; for (int q = 0; q < files.Count; q++) { string pName = "MRU" + myName + q.ToString(); try { //if (settings[pName] == null) if (!DoesSettingExist(pName)) { //SettingsProvider prov = Properties.Settings.Default.Providers. SettingsProperty prop = new System.Configuration.SettingsProperty(pName); prop.PropertyType = typeof(string); prop.Attributes.Add(typeof(UserScopedSettingAttribute), new UserScopedSettingAttribute()); //prop.Provider = prov; prop.SerializeAs = SettingsSerializeAs.Xml; SettingsPropertyValue valu = new SettingsPropertyValue(prop); settings.Properties.Add(prop); //settings[pName] = files[q]; settings.Save(); settings.Reload(); } settings[pName] = files[q]; } catch (Exception e) { if (IsWizard) { string msg = e.Message; //System.Diagnostics.Debugger.Break(); } } } settings.Save(); }
public void Properties () { SettingsProperty p = new SettingsProperty ("property", typeof (int), null, true, 10, SettingsSerializeAs.String, null, true, false); SettingsPropertyValue v = new SettingsPropertyValue (p); Assert.IsFalse (v.Deserialized, "A1"); Assert.IsFalse (v.IsDirty, "A2"); Assert.AreEqual ("property", v.Name, "A3"); Assert.AreEqual (p, v.Property, "A4"); Assert.AreEqual ((object)10, v.PropertyValue, "A5"); Assert.AreEqual (null, v.SerializedValue, "A6"); Assert.IsTrue (v.UsingDefaultValue, "A7"); /* test that setting v.PropertyValue to * something else causes SerializedValue to * become not-null */ v.PropertyValue = (object)5; Assert.AreEqual ("5", v.SerializedValue, "A9"); /* test to see whether or not changing * SerializeAs causes SerializedValue to * change */ p.SerializeAs = SettingsSerializeAs.Xml; Assert.AreEqual ("5", v.SerializedValue, "A11"); /* nope.. */ /* only changing PropertyValue does */ v.PropertyValue = (object)7; Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<int>7</int>", ((string)v.SerializedValue).Replace ("\r\n", "\n"), "A13"); }
public void GivenConfirmedUsersWhenSetPropertyValuesWithInvalidColumnsThenThrowNotSupportedException( string providerName, string membershipProviderName) { // arrange var testClass = this.WithProvider(providerName); var memProvider = this.WithMembershipProvider(membershipProviderName); var user = memProvider.WithConfirmedUser().Value; var context = new SettingsContext(); context["UserName"] = user.UserName; var properties = new SettingsPropertyValueCollection { new SettingsPropertyValue( new SettingsProperty("invalidColumn") { PropertyType = typeof(string) }) { SerializedValue = "Value" } }; if (memProvider.AsBetter().HasEmailColumnDefined) { var emailProperty = new SettingsProperty(memProvider.AsBetter().UserEmailColumn) { PropertyType = typeof(string) }; properties.Add( new SettingsPropertyValue(emailProperty) { PropertyValue = user.Email, Deserialized = true }); } // act // assert Assert.Throws<NotSupportedException>(() => testClass.SetPropertyValues(context, properties)); }
public void AuthenticatedDateTime() { ProfileBase profile = ProfileBase.Create("foo", true); ResetAppId(profile.Providers["MySqlProfileProvider"] as MySQLProfileProvider); DateTime date = DateTime.Now; profile["BirthDate"] = date; profile.Save(); SettingsPropertyCollection getProps = new SettingsPropertyCollection(); SettingsProperty getProp1 = new SettingsProperty("BirthDate"); getProp1.PropertyType = typeof(DateTime); getProp1.SerializeAs = SettingsSerializeAs.Xml; getProps.Add(getProp1); MySQLProfileProvider provider = InitProfileProvider(); SettingsContext ctx = new SettingsContext(); ctx.Add("IsAuthenticated", true); ctx.Add("UserName", "foo"); SettingsPropertyValueCollection getValues = provider.GetPropertyValues(ctx, getProps); Assert.AreEqual(1, getValues.Count); SettingsPropertyValue getValue1 = getValues["BirthDate"]; Assert.AreEqual(date, getValue1.PropertyValue); }
public SettingsPropertyValue(SettingsProperty property) { this.property = property; needPropertyValue = true; needSerializedValue = true; }
public SettingsProperty(SettingsProperty propertyToCopy) { throw new NotImplementedException(); }
public SettingsPropertyValue(SettingsProperty property) { Property = property; }
public void SaveToConfig() { if (dirty) { //appSettings.MRPath0 = files[0]; for (int q = 0; q < files.Count; q++) { string pName = "MRU" + myName + q.ToString(); try { //if (settings[pName] == null) if (!DoesSettingExist(pName)) { // Requested Setting pName does NOT already exist amongst the default settings // Thus, we need to create and add it //SettingsProvider prov = Properties.Settings.Default.Providers. // Create it, and set type and other properties SettingsProperty prop = new System.Configuration.SettingsProperty(pName); prop.PropertyType = typeof(string); prop.IsReadOnly = false; prop.DefaultValue = ""; prop.Provider = appSettings.Providers["LocalFileSettingsProvider"]; prop.Attributes.Add(typeof(UserScopedSettingAttribute), new UserScopedSettingAttribute()); //prop.Provider = prov; prop.SerializeAs = SettingsSerializeAs.Xml; SettingsPropertyValue valu = new SettingsPropertyValue(prop); // Add it to the Default Settings appSettings.Properties.Add(prop); //settings[pName] = files[q]; appSettings.Save(); appSettings.Reload(); } if (files[q] == null) { files[q] = ""; } try { //!EXCEPTION HERE string pn = pName; appSettings[pName] = files[q]; } catch (Exception e) { if (IsWizard) { string msg = e.Message; DialogResult dr = MessageBox.Show(msg, "Most-Recently-Used Error", MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Error); if (dr == DialogResult.Abort) { System.Diagnostics.Debugger.Break(); } } } } catch (Exception e) { if (IsWizard) { string msg = e.Message; DialogResult dr = MessageBox.Show(msg, "Most-Recently-Used Error", MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Error); if (dr == DialogResult.Abort) { System.Diagnostics.Debugger.Break(); } } } } appSettings.Save(); } }
// FIXME: implement public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) { return(null); }
void CreateSettingsProperty(PropertyInfo prop, SettingsPropertyCollection properties, ref SettingsProvider local_provider) { SettingsAttributeDictionary dict = new SettingsAttributeDictionary(); SettingsProvider provider = null; object defaultValue = null; SettingsSerializeAs serializeAs = SettingsSerializeAs.String; bool explicitSerializeAs = false; foreach (Attribute a in prop.GetCustomAttributes(false)) { /* the attributes we handle natively here */ if (a is SettingsProviderAttribute) { Type provider_type = Type.GetType(((SettingsProviderAttribute)a).ProviderTypeName); provider = (SettingsProvider)Activator.CreateInstance(provider_type); provider.Initialize(null, null); } else if (a is DefaultSettingValueAttribute) { defaultValue = ((DefaultSettingValueAttribute)a).Value; } else if (a is SettingsSerializeAsAttribute) { serializeAs = ((SettingsSerializeAsAttribute)a).SerializeAs; explicitSerializeAs = true; } else if (a is ApplicationScopedSettingAttribute || a is UserScopedSettingAttribute) { dict.Add(a.GetType(), a); } else { dict.Add(a.GetType(), a); } } if (!explicitSerializeAs) { // DefaultValue is a string and if we can't convert from string to the // property type then the only other option left is for the string to // be XML. // TypeConverter converter = TypeDescriptor.GetConverter(prop.PropertyType); if (converter != null && (!converter.CanConvertFrom(typeof(string)) || !converter.CanConvertTo(typeof(string)))) { serializeAs = SettingsSerializeAs.Xml; } } SettingsProperty setting = new SettingsProperty(prop.Name, prop.PropertyType, provider, false /* XXX */, defaultValue /* XXX always a string? */, serializeAs, dict, false, false); if (providerService != null) { setting.Provider = providerService.GetSettingsProvider(setting); } if (provider == null) { if (local_provider == null) { local_provider = new LocalFileSettingsProvider() as SettingsProvider; local_provider.Initialize(null, null); } setting.Provider = local_provider; // .NET ends up to set this to providers. provider = local_provider; } if (provider != null) { /* make sure we're using the same instance of a * given provider across multiple properties */ SettingsProvider p = Providers[provider.Name]; if (p != null) { setting.Provider = p; } } properties.Add(setting); if (setting.Provider != null && Providers [setting.Provider.Name] == null) { Providers.Add(setting.Provider); } }
private static bool IsRoamingSetting(SettingsProperty setting) { bool flag = !ApplicationSettingsBase.IsClickOnceDeployed(AppDomain.CurrentDomain); bool flag2 = false; if (flag) { SettingsManageabilityAttribute attribute = setting.Attributes[typeof(SettingsManageabilityAttribute)] as SettingsManageabilityAttribute; flag2 = (attribute != null) && (0 == 0); } return flag2; }
void CreateSettingsProperty(PropertyInfo prop, SettingsPropertyCollection properties, ref LocalFileSettingsProvider local_provider) { SettingsAttributeDictionary dict = new SettingsAttributeDictionary(); SettingsProvider provider = null; object defaultValue = null; SettingsSerializeAs serializeAs = SettingsSerializeAs.String; foreach (Attribute a in prop.GetCustomAttributes(false)) { /* the attributes we handle natively here */ if (a is SettingsProviderAttribute) { Type provider_type = Type.GetType(((SettingsProviderAttribute)a).ProviderTypeName); provider = (SettingsProvider)Activator.CreateInstance(provider_type); provider.Initialize(null, null); } else if (a is DefaultSettingValueAttribute) { defaultValue = ((DefaultSettingValueAttribute)a).Value; /* XXX this is a string.. do we convert? */ // note: for StringCollection, TypeDescriptor.GetConverter(prop.PropertyType) returns // CollectionConverter, however this class cannot handle the XML serialized strings if (prop.PropertyType == typeof(StringCollection)) { XmlSerializer xs = new XmlSerializer(typeof(string[])); string[] values = (string[])xs.Deserialize(new StringReader((string)defaultValue)); StringCollection sc = new StringCollection(); sc.AddRange(values); defaultValue = sc; } else if (prop.PropertyType != typeof(string)) { defaultValue = TypeDescriptor.GetConverter(prop.PropertyType).ConvertFromString((string)defaultValue); } } else if (a is SettingsSerializeAsAttribute) { serializeAs = ((SettingsSerializeAsAttribute)a).SerializeAs; } else if (a is ApplicationScopedSettingAttribute || a is UserScopedSettingAttribute) { dict.Add(a.GetType(), a); } else { dict.Add(a.GetType(), a); } } SettingsProperty setting = new SettingsProperty(prop.Name, prop.PropertyType, provider, false /* XXX */, defaultValue /* XXX always a string? */, serializeAs, dict, false, false); if (providerService != null) { setting.Provider = providerService.GetSettingsProvider(setting); } if (provider == null) { if (local_provider == null) { local_provider = new LocalFileSettingsProvider(); local_provider.Initialize(null, null); } setting.Provider = local_provider; // .NET ends up to set this to providers. provider = local_provider; } if (provider != null) { /* make sure we're using the same instance of a * given provider across multiple properties */ SettingsProvider p = Providers[provider.Name]; if (p != null) { setting.Provider = p; } } properties.Add(setting); if (setting.Provider != null && Providers [setting.Provider.Name] == null) { Providers.Add(setting.Provider); } }
/// <devdoc> /// Creates a SettingsProperty object using the metadata on the given property /// and returns it. /// /// Implementation note: Initialization method - be careful not to access properties here /// to prevent stack overflow. /// </devdoc> private SettingsProperty CreateSetting(PropertyInfo propInfo) { object[] attributes = propInfo.GetCustomAttributes(false); SettingsProperty sp = new SettingsProperty(Initializer); bool explicitSerialize = _explicitSerializeOnClass; sp.Name = propInfo.Name; sp.PropertyType = propInfo.PropertyType; for (int i = 0; i < attributes.Length; i++) { Attribute attr = attributes[i] as Attribute; if (attr != null) { if (attr is DefaultSettingValueAttribute) { sp.DefaultValue = ((DefaultSettingValueAttribute)attr).Value; } else if (attr is ReadOnlyAttribute) { sp.IsReadOnly = true; } else if (attr is SettingsProviderAttribute) { string providerTypeName = ((SettingsProviderAttribute)attr).ProviderTypeName; Type providerType = Type.GetType(providerTypeName); if (providerType != null) { SettingsProvider spdr = SecurityUtils.SecureCreateInstance(providerType) as SettingsProvider; if (spdr != null) { spdr.Initialize(null, null); spdr.ApplicationName = ConfigurationManagerInternalFactory.Instance.ExeProductName; // See if we already have a provider of the same name in our collection. If so, // re-use the existing instance, since we cannot have multiple providers of the same name. SettingsProvider existing = _providers[spdr.Name]; if (existing != null) { spdr = existing; } sp.Provider = spdr; } else { throw new ConfigurationErrorsException(SR.GetString(SR.ProviderInstantiationFailed, providerTypeName)); } } else { throw new ConfigurationErrorsException(SR.GetString(SR.ProviderTypeLoadFailed, providerTypeName)); } } else if (attr is SettingsSerializeAsAttribute) { sp.SerializeAs = ((SettingsSerializeAsAttribute)attr).SerializeAs; explicitSerialize = true; } else { // This isn't an attribute we care about, so simply pass it on // to the SettingsProvider. // NOTE: The key is the type. So if an attribute was found at class // level and also property level, the latter overrides the former // for a given setting. This is exactly the behavior we want. sp.Attributes.Add(attr.GetType(), attr); } } } if (!explicitSerialize) { sp.SerializeAs = GetSerializeAs(propInfo.PropertyType); } return(sp); }
// 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; // Search for the specific settings node we are looking for in the configuration file. XmlNode SettingNode = XMLConfig.SelectSingleNode("//setting[@name='" + setProp.Name + "']"); SettingNode = SettingNode == null ? null : SettingNode.FirstChild; // If it exists, return the InnerText or InnerXML of its first child node, depending on the setting type. if (SettingNode != null) { switch (setProp.SerializeAs) { case SettingsSerializeAs.String: return(SettingNode.InnerText); case SettingsSerializeAs.Xml: string xmlData = SettingNode.InnerXml; return(@"" + xmlData); case SettingsSerializeAs.Binary: default: throw new NotSupportedException(); //break; } } else { // Check to see if a default value is defined by the application. if ((setProp.DefaultValue != null)) { // If so, return that value, using the same rules for settings stored as Strings and XML as above switch (setProp.SerializeAs) { case SettingsSerializeAs.String: retVal = setProp.DefaultValue.ToString(); break; case SettingsSerializeAs.Xml: retVal = setProp.DefaultValue.ToString().Replace(@"<?xml version=""1.0"" encoding=""utf-16""?>", ""); break; /*string xmlData = setProp.DefaultValue.ToString(); * XmlSerializer xs = new XmlSerializer(typeof(string[])); * StringCollection sc = new StringCollection(); * object property = xs.Deserialize(new XmlTextReader(xmlData, XmlNodeType.Element, null)); * if (setProp.PropertyType == typeof(System.Collections.Specialized.StringCollection)) * { * string[] data = (string[])property; * sc.AddRange(data); * return sc; * } * throw new NotSupportedException();**/ //retVal = ""; //break; case SettingsSerializeAs.Binary: default: throw new NotSupportedException(); //retVal = ""; //break; } } else { retVal = ""; } } return(retVal); }
private XmlNode SerializeToXmlElement(SettingsProperty setting, SettingsPropertyValue value) { XmlElement element = new XmlDocument().CreateElement("value"); string serializedValue = value.SerializedValue as string; if ((serializedValue == null) && (setting.SerializeAs == SettingsSerializeAs.Binary)) { byte[] inArray = value.SerializedValue as byte[]; if (inArray != null) { serializedValue = Convert.ToBase64String(inArray); } } if (serializedValue == null) { serializedValue = string.Empty; } if (setting.SerializeAs == SettingsSerializeAs.String) { serializedValue = this.Escaper.Escape(serializedValue); } element.InnerXml = serializedValue; XmlNode oldChild = null; foreach (XmlNode node2 in element.ChildNodes) { if (node2.NodeType == XmlNodeType.XmlDeclaration) { oldChild = node2; break; } } if (oldChild != null) { element.RemoveChild(oldChild); } return element; }
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) { if (_Properties == null) _Properties = new SettingsPropertyCollection(); if (_Properties[property.Name] == null) _Properties.Add(property); GetPropertyValuesCore(); return _PropertyValues[property.Name]; }
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) { return(impl.GetPreviousVersion(context, property)); }
public SettingsPropertyValue(SettingsProperty property) { this._Property = property; }
/// <devdoc> /// Indicates whether a setting is roaming or not. /// </devdoc> private static bool IsRoamingSetting(SettingsProperty setting) { return(false); }
//////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// // On* Methods for deriving classes to override. These have // been modeled after the CollectionBase class but have // been stripped of their "index" parameters as there is no // visible index to this collection. protected virtual void OnAdd(SettingsProperty property) { }
/// <summary> /// Creates a SettingsProperty object using the metadata on the given property /// and returns it. /// </summary> private SettingsProperty CreateSetting(PropertyInfo propertyInfo) { // Initialization method - // be careful not to access properties here to prevent stack overflow. object[] attributes = propertyInfo.GetCustomAttributes(false); SettingsProperty settingsProperty = new SettingsProperty(Initializer); bool explicitSerialize = _explicitSerializeOnClass; settingsProperty.Name = propertyInfo.Name; settingsProperty.PropertyType = propertyInfo.PropertyType; for (int i = 0; i < attributes.Length; i++) { Attribute attribute = attributes[i] as Attribute; if (attribute == null) { continue; } if (attribute is DefaultSettingValueAttribute) { settingsProperty.DefaultValue = ((DefaultSettingValueAttribute)attribute).Value; } else if (attribute is ReadOnlyAttribute) { settingsProperty.IsReadOnly = true; } else if (attribute is SettingsProviderAttribute) { string providerTypeName = ((SettingsProviderAttribute)attribute).ProviderTypeName; Type providerType = Type.GetType(providerTypeName); if (providerType == null) { throw new ConfigurationErrorsException(SR.Format(SR.ProviderTypeLoadFailed, providerTypeName)); } SettingsProvider settingsProvider = TypeUtil.CreateInstance(providerType) as SettingsProvider; if (settingsProvider == null) { throw new ConfigurationErrorsException(SR.Format(SR.ProviderInstantiationFailed, providerTypeName)); } settingsProvider.Initialize(null, null); settingsProvider.ApplicationName = ConfigurationManagerInternalFactory.Instance.ExeProductName; // See if we already have a provider of the same name in our collection. If so, // re-use the existing instance, since we cannot have multiple providers of the same name. SettingsProvider existing = _providers[settingsProvider.Name]; if (existing != null) { settingsProvider = existing; } settingsProperty.Provider = settingsProvider; } else if (attribute is SettingsSerializeAsAttribute) { settingsProperty.SerializeAs = ((SettingsSerializeAsAttribute)attribute).SerializeAs; explicitSerialize = true; } else { // This isn't an attribute we care about, so simply pass it on // to the SettingsProvider. // // NOTE: The key is the type. So if an attribute was found at class // level and also property level, the latter overrides the former // for a given setting. This is exactly the behavior we want. settingsProperty.Attributes.Add(attribute.GetType(), attribute); } } if (!explicitSerialize) { // Serialization method was not explicitly attributed. TypeConverter tc = TypeDescriptor.GetConverter(propertyInfo.PropertyType); if (tc.CanConvertTo(typeof(string)) && tc.CanConvertFrom(typeof(string))) { // We can use string settingsProperty.SerializeAs = SettingsSerializeAs.String; } else { // Fallback is Xml settingsProperty.SerializeAs = SettingsSerializeAs.Xml; } } return(settingsProperty); }
public void Remove_NonExistant () { SettingsPropertyCollection col = new SettingsPropertyCollection (); SettingsProperty test_prop = new SettingsProperty ("test_prop"); col.Add (test_prop); Assert.AreEqual (1, col.Count, "A1"); col.Remove ("test_prop2"); Assert.AreEqual (1, col.Count, "A2"); }
protected virtual void OnAddComplete(SettingsProperty property) { }
private bool IsUserSetting(SettingsProperty setting) { bool flag = setting.Attributes[typeof(UserScopedSettingAttribute)] is UserScopedSettingAttribute; bool flag2 = setting.Attributes[typeof(ApplicationScopedSettingAttribute)] is ApplicationScopedSettingAttribute; if (flag && flag2) { throw new ConfigurationErrorsException(System.SR.GetString("BothScopeAttributes")); } if (!flag && !flag2) { throw new ConfigurationErrorsException(System.SR.GetString("NoScopeAttributes")); } return flag; }
protected virtual void OnRemoveComplete(SettingsProperty property) { }
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) { bool isRoaming = IsRoamingSetting(property); string previousConfigFileName = this.GetPreviousConfigFileName(isRoaming); if (!string.IsNullOrEmpty(previousConfigFileName)) { SettingsPropertyCollection properties = new SettingsPropertyCollection(); properties.Add(property); return this.GetSettingValuesFromFile(previousConfigFileName, this.GetSectionName(context), 1, properties)[property.Name]; } return new SettingsPropertyValue(property) { PropertyValue = null }; }
/// <summary> /// Indicates whether a setting is roaming or not. /// </summary> private static bool IsRoamingSetting(SettingsProperty setting) { SettingsManageabilityAttribute manageAttr = setting.Attributes[typeof(SettingsManageabilityAttribute)] as SettingsManageabilityAttribute; return(manageAttr != null && ((manageAttr.Manageability & SettingsManageability.Roaming) == SettingsManageability.Roaming)); }
public virtual SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) { return SimpleSettingsStore.Instance.PreviousUserValues[property.Name]; }
public static void save_Setting(string setting_Name, string setting_Value) { //----------< save_Settings() >---------- string property_name = setting_Name; //< Setting erstellen > SettingsProperty prop = null; if (Properties.Settings.Default.Properties[property_name] != null) { //< existing Setting > prop = Properties.Settings.Default.Properties[property_name]; //</ existing Setting > } else { //< new Setting > prop = new System.Configuration.SettingsProperty(property_name); prop.PropertyType = typeof(string); Properties.Settings.Default.Properties.Add(prop); Properties.Settings.Default.Save(); Properties.Settings.Default.Upgrade(); //</ new Setting > } //</ Setting erstellen > //< set value > Properties.Settings.Default.Properties[property_name].DefaultValue = setting_Value; //</ set value > //< Save Settings File > Properties.Settings.Default.Save(); //</ Save Settings File > //----------</ save_Settings() >---------- }