/// <devdoc> /// We delegate this to the ClientConfigurationHost. The only thing we need to do here is to /// build a configPath from the ConfigurationUserLevel we get passed in. /// </devdoc> public override void InitForConfiguration(ref string locationSubPath, out string configPath, out string locationConfigPath, IInternalConfigRoot configRoot, params object[] hostInitConfigurationParams) { ConfigurationUserLevel userLevel = (ConfigurationUserLevel)hostInitConfigurationParams[0]; string desiredConfigPath = null; Host = (IInternalConfigHost)TypeUtil.CreateInstanceWithReflectionPermission(ClientConfigurationHostTypeName); switch (userLevel) { case ConfigurationUserLevel.None: desiredConfigPath = ClientHost.GetExeConfigPath(); break; case ConfigurationUserLevel.PerUserRoaming: desiredConfigPath = ClientHost.GetRoamingUserConfigPath(); break; case ConfigurationUserLevel.PerUserRoamingAndLocal: desiredConfigPath = ClientHost.GetLocalUserConfigPath(); break; default: throw new ArgumentException(SR.GetString(SR.UnknownUserLevel)); } Host.InitForConfiguration(ref locationSubPath, out configPath, out locationConfigPath, configRoot, null, null, desiredConfigPath); }
internal Configuration(string locationSubPath, Type typeConfigHost, params object[] hostInitConfigurationParams) { _typeConfigHost = typeConfigHost; _hostInitConfigurationParams = hostInitConfigurationParams; _configRoot = new InternalConfigRoot(this); IInternalConfigHost configHost = (IInternalConfigHost)TypeUtil.CreateInstanceWithReflectionPermission(typeConfigHost); // Wrap the host with the UpdateConfigHost to support SaveAs. IInternalConfigHost updateConfigHost = new UpdateConfigHost(configHost); ((IInternalConfigRoot)_configRoot).Init(updateConfigHost, true); // // Set the configuration paths for this Configuration. // We do this in a separate step so that the WebConfigurationHost // can use this object's _configRoot to get the <sites> section, // which is used in it's MapPath implementation. // string configPath, locationConfigPath; configHost.InitForConfiguration(ref locationSubPath, out configPath, out locationConfigPath, _configRoot, hostInitConfigurationParams); if (!String.IsNullOrEmpty(locationSubPath) && !updateConfigHost.SupportsLocation) { throw ExceptionUtil.UnexpectedError("Configuration::ctor"); } if (String.IsNullOrEmpty(locationSubPath) != String.IsNullOrEmpty(locationConfigPath)) { throw ExceptionUtil.UnexpectedError("Configuration::ctor"); } // Get the configuration record for this config file. _configRecord = (MgmtConfigurationRecord)_configRoot.GetConfigRecord(configPath); // // Create another MgmtConfigurationRecord for the location that is a child of the above record. // Note that this does not match the resolution hiearchy that is used at runtime. // if (!String.IsNullOrEmpty(locationSubPath)) { _configRecord = MgmtConfigurationRecord.Create( _configRoot, _configRecord, locationConfigPath, locationSubPath); } // // Throw if the config record we created contains global errors. // _configRecord.ThrowIfInitErrors(); }
private ConfigurationBuilder CreateAndInitializeBuilderWithAssert(Type t, ProviderSettings ps) { ConfigurationBuilder builder = (ConfigurationBuilder)TypeUtil.CreateInstanceWithReflectionPermission(t); NameValueCollection pars = ps.Parameters; NameValueCollection cloneParams = new NameValueCollection(pars.Count); foreach (string key in pars) { cloneParams[key] = pars[key]; } builder.Initialize(ps.Name, cloneParams); return(builder); }
public ConfigurationProperty(String name, Type type) { object defaultValue = null; ConstructorInit(name, type, ConfigurationPropertyOptions.None, null, null); if (type == typeof(string)) { defaultValue = String.Empty; } else if (type.IsValueType) { defaultValue = TypeUtil.CreateInstanceWithReflectionPermission(type); } SetDefaultValue(defaultValue); }
private ConfigurationBuilder CreateAndInitializeBuilderWithAssert(Type t, ProviderSettings ps) { ConfigurationBuilder builder = (ConfigurationBuilder)TypeUtil.CreateInstanceWithReflectionPermission(t); NameValueCollection pars = ps.Parameters; NameValueCollection cloneParams = new NameValueCollection(pars.Count); foreach (string key in pars) { cloneParams[key] = pars[key]; } try { builder.Initialize(ps.Name, cloneParams); } catch (Exception e) { throw ExceptionUtil.WrapAsConfigException(SR.GetString(SR.ConfigBuilder_init_error, ps.Name), e, null); } return(builder); }
private void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) { // Get the type of the factory Type type = TypeUtil.GetTypeWithReflectionPermission(configRecord.Host, factoryRecord.FactoryTypeName, true); // If the type is a ConfigurationSection, that's the type. if (typeof(ConfigurationSection).IsAssignableFrom(type)) { _sectionCtor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSection), true); } else { // Note: in v1, IConfigurationSectionHandler is in effect a factory that has a Create method // that creates the real section object. // throws if type does not implement IConfigurationSectionHandler TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true); // Create an instance of the handler _sectionHandler = (IConfigurationSectionHandler)TypeUtil.CreateInstanceWithReflectionPermission(type); } }
private void InitDefaultValueFromTypeInfo(ConfigurationPropertyAttribute attribProperty, DefaultValueAttribute attribStdDefault) { object defaultValue = attribProperty.DefaultValue; // If there is no default value there - try the other attribute ( the clr standard one ) if ((defaultValue == null || defaultValue == ConfigurationElement.s_nullPropertyValue) && (attribStdDefault != null)) { defaultValue = attribStdDefault.Value; } // If there was a default value in the prop attribute - check if we need to convert it from string if ((defaultValue != null) && (defaultValue is string) && (_type != typeof(string))) { // Use the converter to parse this property default value try { defaultValue = Converter.ConvertFromInvariantString((string)defaultValue); } catch (Exception ex) { throw new ConfigurationErrorsException(SR.GetString(SR.Default_value_conversion_error_from_string, _name, ex.Message)); } catch { throw new ConfigurationErrorsException(SR.GetString(SR.Default_value_conversion_error_from_string, _name, ExceptionUtil.NoExceptionInformation)); } } if (defaultValue == null || defaultValue == ConfigurationElement.s_nullPropertyValue) { if (_type == typeof(string)) { defaultValue = String.Empty; } else if (_type.IsValueType) { defaultValue = TypeUtil.CreateInstanceWithReflectionPermission(_type); } } SetDefaultValue(defaultValue); }
private ProtectedConfigurationProvider CreateAndInitializeProviderWithAssert(Type t, ProviderSettings pn) { ProtectedConfigurationProvider provider = (ProtectedConfigurationProvider)TypeUtil.CreateInstanceWithReflectionPermission(t); NameValueCollection pars = pn.Parameters; NameValueCollection cloneParams = new NameValueCollection(pars.Count); foreach (string key in pars) { cloneParams[key] = pars[key]; } provider.Initialize(pn.Name, cloneParams); return(provider); }
internal ConfigurationProperty(PropertyInfo info) { Debug.Assert(info != null, "info != null"); // Bellow are the attributes we handle TypeConverterAttribute attribConverter = null; ConfigurationPropertyAttribute attribProperty = null; ConfigurationValidatorAttribute attribValidator = null; // Compatability attributes // If the approprite data is provided in the ConfigPropAttribute then the one bellow will be ignored DescriptionAttribute attribStdDescription = null; DefaultValueAttribute attribStdDefault = null; TypeConverter typeConverter = null; ConfigurationValidatorBase validator = null; // Find the interesting attributes in the collection foreach (Attribute attribute in Attribute.GetCustomAttributes(info)) { if (attribute is TypeConverterAttribute) { attribConverter = (TypeConverterAttribute)attribute; typeConverter = (TypeConverter)TypeUtil.CreateInstanceWithReflectionPermission(attribConverter.ConverterTypeName); } else if (attribute is ConfigurationPropertyAttribute) { attribProperty = (ConfigurationPropertyAttribute)attribute; } else if (attribute is ConfigurationValidatorAttribute) { if (validator != null) { throw new ConfigurationErrorsException(SR.GetString(SR.Validator_multiple_validator_attributes, info.Name)); } attribValidator = (ConfigurationValidatorAttribute)attribute; validator = attribValidator.ValidatorInstance; } else if (attribute is DescriptionAttribute) { attribStdDescription = (DescriptionAttribute)attribute; } else if (attribute is DefaultValueAttribute) { attribStdDefault = (DefaultValueAttribute)attribute; } } Type propertyType = info.PropertyType; // Collections need some customization when the collection attribute is present if (typeof(ConfigurationElementCollection).IsAssignableFrom(propertyType)) { ConfigurationCollectionAttribute attribCollection = Attribute.GetCustomAttribute(info, typeof(ConfigurationCollectionAttribute)) as ConfigurationCollectionAttribute; // If none on the property - see if there is an attribute on the collection type itself if (attribCollection == null) { attribCollection = Attribute.GetCustomAttribute(propertyType, typeof(ConfigurationCollectionAttribute)) as ConfigurationCollectionAttribute; } if (attribCollection != null) { if (attribCollection.AddItemName.IndexOf(',') == -1) { _addElementName = attribCollection.AddItemName; } _removeElementName = attribCollection.RemoveItemName; _clearElementName = attribCollection.ClearItemsName; } } // This constructor shouldnt be invoked if the reflection info is not for an actual config property Debug.Assert(attribProperty != null, "attribProperty != null"); ConstructorInit(attribProperty.Name, info.PropertyType, attribProperty.Options, validator, typeConverter); // Figure out the default value InitDefaultValueFromTypeInfo(attribProperty, attribStdDefault); // Get the description if ((attribStdDescription != null) && !string.IsNullOrEmpty(attribStdDescription.Description)) { _description = attribStdDescription.Description; } }