[Test] // ctor (String)
public void Constructor2 ()
{
string msg;
ConfigurationErrorsException cee;
msg = "MSG";
cee = new ConfigurationErrorsException (msg);
Assert.AreSame (msg, cee.BareMessage, "#A1");
Assert.IsNotNull (cee.Data, "#A2");
Assert.AreEqual (0, cee.Data.Count, "#A3");
Assert.IsNull (cee.Filename, "#A4");
Assert.IsNull (cee.InnerException, "#A5");
Assert.AreEqual (0, cee.Line, "#A6");
Assert.AreSame (msg, cee.Message, "#A7");
msg = null;
cee = new ConfigurationErrorsException (msg);
Assert.AreEqual (new ConfigurationErrorsException ().Message, cee.BareMessage, "#B1");
Assert.IsNotNull (cee.Data, "#B2");
Assert.AreEqual (0, cee.Data.Count, "#B3");
Assert.IsNull (cee.Filename, "#B4");
Assert.IsNull (cee.InnerException, "#B5");
Assert.AreEqual (0, cee.Line, "#B6");
Assert.AreEqual (cee.BareMessage, cee.Message, "#B7");
}
internal static ConfigurationErrorsException WrapAsConfigException(string outerMessage, Exception e, string filename, int line)
{
ConfigurationErrorsException exception = e as ConfigurationErrorsException;
if (exception != null)
{
return(exception);
}
ConfigurationException exception2 = e as ConfigurationException;
if (exception2 != null)
{
return(new ConfigurationErrorsException(exception2));
}
XmlException inner = e as XmlException;
if (inner != null)
{
if (inner.LineNumber != 0)
{
line = inner.LineNumber;
}
return(new ConfigurationErrorsException(inner.Message, inner, filename, line));
}
if (e != null)
{
return(new ConfigurationErrorsException(System.Configuration.SR.GetString("Wrapped_exception_message", new object[] { outerMessage, e.Message }), e, filename, line));
}
return(new ConfigurationErrorsException(System.Configuration.SR.GetString("Wrapped_exception_message", new object[] { outerMessage, NoExceptionInformation }), filename, line));
}
static internal void AddError(ref List <ConfigurationException> errors, ConfigurationException e)
{
Debug.Assert(e != null, "e != null");
// Create on demand
if (errors == null)
{
errors = new List <ConfigurationException>();
}
ConfigurationErrorsException ce = e as ConfigurationErrorsException;
if (ce == null)
{
errors.Add(e);
}
else
{
ICollection <ConfigurationException> col = ce.ErrorsGeneric;
if (col.Count == 1)
{
errors.Add(e);
}
else
{
errors.AddRange(col);
}
}
}
// Verify and Retrieve the Boolean Attribute. If it is not
// a valid value then log an error and set the value to a given default.
internal void VerifyAndGetBooleanAttribute(
ExceptionAction action, bool defaultValue, out bool newValue)
{
if (Reader.Value == "true")
{
newValue = true;
}
else
{
if (Reader.Value == "false")
{
newValue = false;
}
else
{
// Unrecognized value
newValue = defaultValue;
ConfigurationErrorsException ex = new ConfigurationErrorsException(
string.Format(SR.Config_invalid_boolean_attribute, Reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
}
}
internal static void AddError(ref List <ConfigurationException> errors, ConfigurationException e)
{
if (errors == null)
{
errors = new List <ConfigurationException>();
}
ConfigurationErrorsException exception = e as ConfigurationErrorsException;
if (exception == null)
{
errors.Add(e);
}
else
{
ICollection <ConfigurationException> errorsGeneric = exception.ErrorsGeneric;
if (errorsGeneric.Count == 1)
{
errors.Add(e);
}
else
{
errors.AddRange(errorsGeneric);
}
}
}
private object CreateSectionImpl(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader)
{
if (this._sectionCtor != null)
{
ConfigurationSection section = (ConfigurationSection)System.Configuration.TypeUtil.InvokeCtorWithReflectionPermission(this._sectionCtor);
section.SectionInformation.SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord);
section.CallInit();
ConfigurationSection parentElement = (ConfigurationSection)parentConfig;
section.Reset(parentElement);
if (reader != null)
{
section.DeserializeSection(reader);
}
ConfigurationErrorsException errors = section.GetErrors();
if (errors != null)
{
throw errors;
}
section.SetReadOnly();
section.ResetModified();
return(section);
}
if (reader != null)
{
XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader);
CheckForLockAttributes(factoryRecord.ConfigKey, xmlNode);
object configContext = configRecord.Host.CreateDeprecatedConfigContext(configRecord.ConfigPath);
return(this._sectionHandler.Create(parentConfig, configContext, xmlNode));
}
return(null);
}
internal object CreateSection(bool inputIsTrusted, RuntimeConfigurationRecord configRecord,
FactoryRecord factoryRecord, SectionRecord sectionRecord, object parentConfig, ConfigXmlReader reader)
{
object config;
if (_sectionCtor != null)
{
ConfigurationSection configSection =
(ConfigurationSection)_sectionCtor.Invoke(null);
configSection.SectionInformation.SetRuntimeConfigurationInformation(configRecord, factoryRecord,
sectionRecord);
configSection.CallInit();
ConfigurationSection parentSection = (ConfigurationSection)parentConfig;
configSection.Reset(parentSection);
if (reader != null)
{
configSection.DeserializeSection(reader);
}
// throw if there are any cached errors
ConfigurationErrorsException errors = configSection.GetErrors();
if (errors != null)
{
throw errors;
}
// don't allow changes to sections at runtime
configSection.SetReadOnly();
// reset the modified bit
configSection.ResetModified();
config = configSection;
}
else
{
if (reader != null)
{
XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader);
CheckForLockAttributes(factoryRecord.ConfigKey, xmlNode);
// In v1, our old section handler expects a context that contains the virtualPath from the configPath
object configContext = configRecord.Host.CreateDeprecatedConfigContext(configRecord.ConfigPath);
config = _sectionHandler.Create(parentConfig, configContext, xmlNode);
}
else
{
config = null;
}
}
return(config);
}
internal void AddErrorRequiredAttribute(string attrib, ExceptionAction action)
{
ConfigurationErrorsException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_missing_required_attribute, attrib, _reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
/// <summary>
/// 使用缓冲池的键、缓冲对象的类型和已发生的
/// <see cref="System.Configuration.ConfigurationErrorsException"/> 初始化
/// <see cref="CacheResolveEventArgs"/> 类的新实例。
/// </summary>
/// <param name="key">缓冲池的键。</param>
/// <param name="keyType">缓冲对象的键的类型。</param>
/// <param name="valueType">缓冲对象的类型。</param>
/// <param name="exception">已发生的 <see cref="System.Exception"/>。</param>
public CacheResolveEventArgs(string key, Type keyType, Type valueType,
ConfigurationErrorsException exception)
{
this.Key = key;
this.CacheKeyType = keyType;
this.CacheValueType = valueType;
this.Exception = exception;
}
internal void AddErrorReservedAttribute(ExceptionAction action)
{
ConfigurationErrorsException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_reserved_attribute, _reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
internal void AddErrorUnrecognizedAttribute(ExceptionAction action)
{
ConfigurationErrorsException ex = new ConfigurationErrorsException(
string.Format(SR.Config_base_unrecognized_attribute, Reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
/// <summary>
/// 使用缓冲池的键、缓冲对象的类型和发生的内部异常初始化 <see cref="CacheResolveEventArgs"/> 类的新实例。
/// </summary>
/// <param name="key">缓冲池的键。</param>
/// <param name="keyType">缓冲对象的键的类型。</param>
/// <param name="valueType">缓冲对象的类型。</param>
/// <param name="innerException">发生的内部异常。</param>
public CacheResolveEventArgs(string key, Type keyType, Type valueType, ConfigurationErrorsException innerException)
{
Contract.Requires(key != null && keyType != null && valueType != null);
this.key = key;
this.keyType = keyType;
this.valueType = valueType;
this.innerException = innerException;
}
internal void AddErrorUnrecognizedElement(ExceptionAction action)
{
ConfigurationErrorsException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_base_unrecognized_element),
this);
SchemaErrors.AddError(ex, action);
}
internal static void ThrowOnErrors(List <ConfigurationException> errors)
{
ConfigurationErrorsException errorsException = GetErrorsException(errors);
if (errorsException != null)
{
throw errorsException;
}
}
static internal void ThrowOnErrors(List <ConfigurationException> errors)
{
ConfigurationErrorsException e = GetErrorsException(errors);
if (e != null)
{
throw e;
}
}
static internal ConfigurationErrorsException WrapAsConfigException(string outerMessage, Exception e, string filename, int line)
{
//
// Preserve ConfigurationErrorsException
//
ConfigurationErrorsException ce = e as ConfigurationErrorsException;
if (ce != null)
{
return(ce);
}
//
// Promote deprecated ConfigurationException to ConfigurationErrorsException
//
ConfigurationException deprecatedException = e as ConfigurationException;
if (deprecatedException != null)
{
return(new ConfigurationErrorsException(deprecatedException));
}
//
// For XML exceptions, preserve the text of the exception in the outer message.
//
XmlException xe = e as XmlException;
if (xe != null)
{
if (xe.LineNumber != 0)
{
line = xe.LineNumber;
}
return(new ConfigurationErrorsException(xe.Message, xe, filename, line));
}
//
// Wrap other exceptions in an inner exception, and give as much info as possible
//
if (e != null)
{
return(new ConfigurationErrorsException(
SR.GetString(SR.Wrapped_exception_message, outerMessage, e.Message),
e,
filename,
line));
}
//
// If there is no exception, create a new exception with no further information.
//
return(new ConfigurationErrorsException(
SR.GetString(SR.Wrapped_exception_message, outerMessage, ExceptionUtil.NoExceptionInformation),
filename,
line));
}
internal void VerifyIgnorableNodeType(ExceptionAction action)
{
XmlNodeType nodeType = this._reader.NodeType;
if ((nodeType != XmlNodeType.Comment) && (nodeType != XmlNodeType.EndElement))
{
ConfigurationException ce = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_base_unrecognized_element"), this);
this.SchemaErrors.AddError(ce, action);
}
}
internal static bool TryGetHttpHandlerType(string virtualPath, Type hostedXamlType, out Type httpHandlerType)
{
XamlHostingSection section = LoadXamlHostingSection(virtualPath);
if (null == section)
{
ConfigurationErrorsException configException = new ConfigurationErrorsException(SR.ConfigSectionNotFound);
throw FxTrace.Exception.AsError(configException);
}
return section.Handlers.TryGetHttpHandlerType(hostedXamlType, out httpHandlerType);
}
[Test] // ctor ()
public void Constructor1 ()
{
ConfigurationErrorsException cee = new ConfigurationErrorsException ();
Assert.IsNotNull (cee.BareMessage, "#1");
Assert.IsTrue (cee.BareMessage.IndexOf ("'" + typeof (ConfigurationErrorsException).FullName + "'") != -1, "#2:" + cee.BareMessage);
Assert.IsNotNull (cee.Data, "#3");
Assert.AreEqual (0, cee.Data.Count, "#4");
Assert.IsNull (cee.Filename, "#5");
Assert.IsNull (cee.InnerException, "#6");
Assert.AreEqual (0, cee.Line, "#7");
Assert.AreEqual (cee.BareMessage, cee.Message, "#8");
}
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string instanceName)
{
try
{
DefaultCachingEventLogger eventLogger = EnterpriseLibraryFactory.BuildUp<DefaultCachingEventLogger>();
if (eventLogger != null)
{
eventLogger.LogConfigurationError(instanceName, configurationException);
}
}
catch { }
}
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string instanceName)
{
try
{
DefaultSecurityEventLogger eventLogger = EnterpriseLibraryFactory.BuildUp<DefaultSecurityEventLogger>();
if (eventLogger != null)
{
eventLogger.LogConfigurationError(instanceName, Resources.ErrorAuthorizationConfigurationFailedMessage, configurationException);
}
}
catch { }
}
//
// Add an error if the node type is not permitted by the configuration schema.
//
internal void VerifyIgnorableNodeType(ExceptionAction action)
{
XmlNodeType nodeType = _reader.NodeType;
if (nodeType != XmlNodeType.Comment && nodeType != XmlNodeType.EndElement)
{
ConfigurationException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_base_unrecognized_element),
this);
SchemaErrors.AddError(ex, action);
}
}
internal void VerifyAndGetNonEmptyStringAttribute(ExceptionAction action, out string newValue)
{
if (!string.IsNullOrEmpty(this._reader.Value))
{
newValue = this._reader.Value;
}
else
{
newValue = null;
ConfigurationException ce = new ConfigurationErrorsException(System.Configuration.SR.GetString("Empty_attribute", new object[] { this._reader.Name }), this);
this.SchemaErrors.AddError(ce, action);
}
}
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string instanceName)
{
try
{
DefaultDataEventLogger logger = EnterpriseLibraryFactory.BuildUp<DefaultDataEventLogger>();
if (logger != null)
{
logger.LogConfigurationError(configurationException, instanceName);
}
}
catch
{
}
}
public void DefaultLoggerFiresWmiEvent()
{
DefaultCachingEventLogger logger
= new DefaultCachingEventLogger(false, true);
ConfigurationErrorsException exception = new ConfigurationErrorsException(exceptionMessage);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
logger.LogConfigurationError(instanceName, exception);
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("CacheConfigurationFailureEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual(instanceName, eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
}
}
public void DefaultLoggerWritesToEventLog()
{
DefaultCachingEventLogger logger
= new DefaultCachingEventLogger(true, false);
ConfigurationErrorsException exception = new ConfigurationErrorsException(exceptionMessage);
using (EventLog eventLog = GetEventLog())
{
int eventCount = eventLog.Entries.Count;
logger.LogConfigurationError(instanceName, exception);
Assert.AreEqual(eventCount + 1, eventLog.Entries.Count);
Assert.IsTrue(eventLog.Entries[eventCount].Message.IndexOf(exceptionMessage) > -1);
}
}
internal void VerifyAndGetBooleanAttribute(ExceptionAction action, bool defaultValue, out bool newValue)
{
if (this._reader.Value == "true")
{
newValue = true;
}
else if (this._reader.Value == "false")
{
newValue = false;
}
else
{
newValue = defaultValue;
ConfigurationErrorsException ce = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_invalid_boolean_attribute", new object[] { this._reader.Name }), this);
this.SchemaErrors.AddError(ce, action);
}
}
public void DefaultLoggerWritesToEventLog()
{
DefaultCachingEventLogger logger
= new DefaultCachingEventLogger(true);
ConfigurationErrorsException exception = new ConfigurationErrorsException(exceptionMessage);
using (var eventLog = new EventLogTracker(GetEventLog()))
{
logger.LogConfigurationError(instanceName, exception);
var newEntries = from entry in eventLog.NewEntries()
where entry.Message.IndexOf(exceptionMessage) > -1
select entry;
Assert.AreEqual(1, newEntries.ToList().Count);
}
}
internal void VerifyAndGetNonEmptyStringAttribute(ExceptionAction action, out string newValue)
{
if (!String.IsNullOrEmpty(_reader.Value))
{
newValue = _reader.Value;
}
else
{
newValue = null;
ConfigurationException ex = new ConfigurationErrorsException(
SR.GetString(SR.Empty_attribute, _reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
}
public WebConfigSettingService(string configLocation = null, bool isVirtualPath = false)
: base(configLocation)
{
//http://stackoverflow.com/questions/4738/using-configurationmanager-to-load-config-from-an-arbitrary-location/4746#4746
try
{
if (configLocation != null)
{
if (isVirtualPath)
{
_configuration = WebConfigurationManager.OpenWebConfiguration(configLocation);
_settings = _configuration.AppSettings;
}
else
{
//ConfigurationFileMap fileMap = new ConfigurationFileMap(configLocation); //Path to your config file
//_configuration = ConfigurationManager.OpenMappedMachineConfiguration(fileMap);
ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
fileMap.ExeConfigFilename = configLocation;
_configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
//_settings = (AppSettingsSection)_configuration.GetSection("AppSettings");
_settings = _configuration.AppSettings;
}
}
else
{
//No config file was sent in so we use default one
_configuration = WebConfigurationManager.OpenWebConfiguration(HttpContext.Current != null ? HttpContext.Current.Request.ApplicationPath : null);
_settings = _configuration.AppSettings;
}
}
catch (ConfigurationErrorsException e)
{
var eNew = new ConfigurationErrorsException("Could not load configuration. Either incorrect path was sent in or if no path was sent in web.config could not be found where expected",e);
throw eNew;
}
}
internal void AddErrorRequiredAttribute(string attrib, ExceptionAction action)
{
ConfigurationErrorsException ce = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_missing_required_attribute", new object[] { attrib, this._reader.Name }), this);
this.SchemaErrors.AddError(ce, action);
}
Exception BuildParseError(Exception e, string capsKey) {
string message = SR.GetString(SR.Invalid_string_from_browser_caps, e.Message, capsKey, this[capsKey]);
// to show ConfigurationException in stack trace
ConfigurationErrorsException configEx = new ConfigurationErrorsException(message, e);
// I want it to look like an unhandled exception
HttpUnhandledException httpUnhandledEx = new HttpUnhandledException(null, null);
// but show message from outer exception (it normally shows the inner-most)
httpUnhandledEx.SetFormatter(new UseLastUnhandledErrorFormatter(configEx));
return httpUnhandledEx;
}
// GetErrors
//
// Get a ConfigurationErrorsException that contains the errors
// for this ConfigurationElement and its children
//
internal ConfigurationErrorsException GetErrors() {
ArrayList errorsList;
errorsList = GetErrorsList();
if (errorsList.Count == 0) {
return null;
}
ConfigurationErrorsException e = new ConfigurationErrorsException(errorsList);
return e;
}
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string hashInstance, string template)
{
try
{
DefaultCryptographyEventLogger eventLogger = EnterpriseLibraryFactory.BuildUp<DefaultCryptographyEventLogger>();
if (eventLogger != null)
{
eventLogger.LogConfigurationError(hashInstance, template, configurationException);
}
}
catch { }
}
private static void TryLogHashConfigurationError(ConfigurationErrorsException configurationException, string hashInstance)
{
TryLogConfigurationError(configurationException, Resources.ErrorHashProviderConfigurationFailedMessage, hashInstance);
}
internal void AddErrorUnrecognizedElement(ExceptionAction action)
{
ConfigurationErrorsException ce = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_base_unrecognized_element"), this);
this.SchemaErrors.AddError(ce, action);
}
internal void AddErrorUnrecognizedAttribute(ExceptionAction action)
{
ConfigurationErrorsException ce = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_base_unrecognized_attribute", new object[] { this._reader.Name }), this);
this.SchemaErrors.AddError(ce, action);
}
private IHttpHandler GetHandlerFirstTime(HttpContext context, string requestType, string url, string pathTranslated)
{
Type type;
ConfigurationErrorsException exception;
if (this.hostedXamlType == null)
{
this.hostedXamlType = this.GetCompiledCustomString(context.Request.AppRelativeCurrentExecutionFilePath);
}
if (XamlHostingConfiguration.TryGetHttpHandlerType(url, this.hostedXamlType, out type))
{
if (TD.HttpHandlerPickedForUrlIsEnabled())
{
TD.HttpHandlerPickedForUrl(url, this.hostedXamlType.FullName, type.FullName);
}
if (typeof(IHttpHandler).IsAssignableFrom(type))
{
IHttpHandler handler = (IHttpHandler) XamlHttpHandlerFactory.CreateInstance(type);
if (handler.IsReusable)
{
this.cachedResult = handler;
return handler;
}
this.cachedResult = type;
return handler;
}
if (typeof(IHttpHandlerFactory).IsAssignableFrom(type))
{
IHttpHandlerFactory factory = (IHttpHandlerFactory) XamlHttpHandlerFactory.CreateInstance(type);
this.cachedResult = factory;
return XamlHttpHandlerFactory.HandlerWrapper.Create(factory.GetHandler(context, requestType, url, pathTranslated), factory);
}
exception = new ConfigurationErrorsException(System.Xaml.Hosting.SR.NotHttpHandlerType(url, this.hostedXamlType, type.FullName));
this.cachedResult = exception;
throw FxTrace.Exception.AsError(exception);
}
exception = new ConfigurationErrorsException(System.Xaml.Hosting.SR.HttpHandlerForXamlTypeNotFound(url, this.hostedXamlType, "system.xaml.hosting/httpHandlers"));
this.cachedResult = exception;
throw FxTrace.Exception.AsError(exception);
}
//This function is invoked the first time a request is made to XAMLx file
//It caches url as key and one of the
//following 4 as value -> "Handler/Factory/HandlerCLRType/Exception"
IHttpHandler GetHandlerFirstTime(HttpContext context, string requestType,
string url, string pathTranslated)
{
Type httpHandlerType;
ConfigurationErrorsException configException;
//GetCompiledType is costly - invoke it just once.
//This null check is required for "error after GetCompiledType on first attempt" cases only
if (this.hostedXamlType == null)
{
this.hostedXamlType = GetCompiledCustomString(context.Request.AppRelativeCurrentExecutionFilePath);
}
if (XamlHostingConfiguration.TryGetHttpHandlerType(url, this.hostedXamlType, out httpHandlerType))
{
if (TD.HttpHandlerPickedForUrlIsEnabled())
{
TD.HttpHandlerPickedForUrl(url, hostedXamlType.FullName, httpHandlerType.FullName);
}
if (typeof(IHttpHandler).IsAssignableFrom(httpHandlerType))
{
IHttpHandler handler = (IHttpHandler)CreateInstance(httpHandlerType);
if (handler.IsReusable)
{
this.cachedResult = handler;
}
else
{
this.cachedResult = httpHandlerType;
}
return handler;
}
else if (typeof(IHttpHandlerFactory).IsAssignableFrom(httpHandlerType))
{
IHttpHandlerFactory factory = (IHttpHandlerFactory)CreateInstance(httpHandlerType);
this.cachedResult = factory;
IHttpHandler handler = factory.GetHandler(context, requestType, url, pathTranslated);
return HandlerWrapper.Create(handler, factory);
}
else
{
configException =
new ConfigurationErrorsException(SR.NotHttpHandlerType(url, this.hostedXamlType, httpHandlerType.FullName));
this.cachedResult = configException;
throw FxTrace.Exception.AsError(configException);
}
}
configException =
new ConfigurationErrorsException(SR.HttpHandlerForXamlTypeNotFound(url, this.hostedXamlType, XamlHostingConfiguration.XamlHostingSection));
this.cachedResult = configException;
throw FxTrace.Exception.AsError(configException);
}
//
// Add an error if the node type is not permitted by the configuration schema.
//
internal void VerifyIgnorableNodeType(ExceptionAction action) {
XmlNodeType nodeType = _reader.NodeType;
if (nodeType != XmlNodeType.Comment && nodeType != XmlNodeType.EndElement) {
ConfigurationException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_base_unrecognized_element),
this);
SchemaErrors.AddError(ex, action);
}
}
private static void InitializeDefaultProvider(RoleManagerSection settings) {
bool canInitializeDefaultProvider = (!HostingEnvironment.IsHosted || BuildManager.PreStartInitStage == PreStartInitStage.AfterPreStartInit);
if (!s_InitializedDefaultProvider && canInitializeDefaultProvider) {
Debug.Assert(s_Providers != null);
s_Providers.SetReadOnly();
if (settings.DefaultProvider == null) {
s_InitializeException = new ProviderException(SR.GetString(SR.Def_role_provider_not_specified));
}
else {
try {
s_Provider = s_Providers[settings.DefaultProvider];
}
catch { }
}
if (s_Provider == null) {
s_InitializeException = new ConfigurationErrorsException(SR.GetString(SR.Def_role_provider_not_found), settings.ElementInformation.Properties["defaultProvider"].Source, settings.ElementInformation.Properties["defaultProvider"].LineNumber);
}
s_InitializedDefaultProvider = true;
}
}
internal void AddErrorRequiredAttribute(string attrib, ExceptionAction action) {
ConfigurationErrorsException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_missing_required_attribute, attrib, _reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
private static void TryLogSymmetricConfigurationError(ConfigurationErrorsException configurationException, string symmetricInstance)
{
TryLogConfigurationError(configurationException, Resources.ErrorSymmetricEncryptionConfigurationFailedMessage, symmetricInstance);
}
internal void AddErrorReservedAttribute(ExceptionAction action) {
ConfigurationErrorsException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_reserved_attribute, _reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
private object DeserializePropertyValue(ConfigurationProperty prop, XmlReader reader) {
Debug.Assert(prop != null, "prop != null");
Debug.Assert(reader != null, "reader != null");
// By default we try to load (i.e. parse/validate ) all properties
// If a property value is invalid ( cannot be parsed or is not valid ) we will keep the value
// as string ( from the xml ) and will write it out unchanged if needed
// If the property value is needed by users the actuall exception will be thrown
string xmlValue = reader.Value;
object propertyValue = null;
try {
propertyValue = prop.ConvertFromString(xmlValue);
// Validate the loaded and converted value
prop.Validate(propertyValue);
}
catch (ConfigurationException ce) {
// If the error is incomplete - complete it :)
if (string.IsNullOrEmpty(ce.Filename)) {
ce = new ConfigurationErrorsException(ce.Message, reader);
}
// Cannot parse/validate the value. Keep it as string
propertyValue = new InvalidPropValue(xmlValue, ce);
}
catch {
// If this is an exception related to the parsing/validating the
// value ConfigurationErrorsException should be thrown instead.
// If not - the exception is ok to surface out of here
Debug.Fail("Unknown exception type thrown");
}
return propertyValue;
}
internal void AddErrorUnrecognizedElement(ExceptionAction action) {
ConfigurationErrorsException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_base_unrecognized_element),
this);
SchemaErrors.AddError(ex, action);
}
internal void FireConfigurationFailureEvent(ConfigurationErrorsException configurationException)
{
if (configurationFailure != null) configurationFailure(this, new ValidationConfigurationFailureEventArgs(configurationException));
}
internal void VerifyAndGetNonEmptyStringAttribute(ExceptionAction action, out string newValue) {
if (!String.IsNullOrEmpty(_reader.Value)) {
newValue = _reader.Value;
}
else {
newValue = null;
ConfigurationException ex = new ConfigurationErrorsException(
SR.GetString(SR.Empty_attribute, _reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
}
private object DeserializePropertyValue(ConfigurationProperty prop, XmlReader reader)
{
string str = reader.Value;
object obj2 = null;
try
{
obj2 = prop.ConvertFromString(str);
prop.Validate(obj2);
}
catch (ConfigurationException exception)
{
if (string.IsNullOrEmpty(exception.Filename))
{
exception = new ConfigurationErrorsException(exception.Message, reader);
}
obj2 = new InvalidPropValue(str, exception);
}
catch
{
}
return obj2;
}
// VerifyAndGetBooleanAttribute
//
// Verify and Retrieve the Boolean Attribute. If it is not
// a valid value then log an error and set the value to a given default.
//
internal void VerifyAndGetBooleanAttribute(
ExceptionAction action, bool defaultValue, out bool newValue) {
if (_reader.Value == "true") {
newValue = true;
}
else if (_reader.Value == "false") {
newValue = false;
}
else {
// Unrecognized value
newValue = defaultValue;
ConfigurationErrorsException ex = new ConfigurationErrorsException(
SR.GetString(SR.Config_invalid_boolean_attribute, _reader.Name),
this);
SchemaErrors.AddError(ex, action);
}
}
public void NotifyConfigurationFailure(ConfigurationErrorsException configurationException)
{
// Intentional no-op
}
/// <summary>
/// Transfers settings from/to the stick according to the direction.
/// </summary>
/// <param name="direction">The direction.</param>
/// <remarks>Documented by Dev02, 2007-12-06</remarks>
static void SettingsOnStick(SettingsOnStickDirection direction)
{
if (!RunningFromStick())
{
return;
}
if (direction == SettingsOnStickDirection.Save)
{
//replace settings with placeholders
Properties.Settings.Default.DicDir = ReplacePath(Properties.Settings.Default.DicDir, SettingsOnStickReplaceDirection.PathToPlaceholder);
Properties.Settings.Default.RecentFiles = ReplacePath(Properties.Settings.Default.RecentFiles, SettingsOnStickReplaceDirection.PathToPlaceholder);
//save current properties before copying to stick
Properties.Settings.Default.Save();
}
System.Configuration.Configuration localconfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal);
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
FileInfo sourcefile, destfile;
string userconfigfileformat = Properties.Resources.SETUP_STICKMODE_CONFIGFILE;
switch (direction)
{
case SettingsOnStickDirection.Load:
sourcefile = new FileInfo(string.Format(userconfigfileformat, config.FilePath));
destfile = new FileInfo(localconfig.FilePath);
break;
case SettingsOnStickDirection.Save:
sourcefile = new FileInfo(localconfig.FilePath);
destfile = new FileInfo(string.Format(userconfigfileformat, config.FilePath));
break;
default:
return;
}
try
{
sourcefile.Directory.Create();
destfile.Directory.Create();
File.Copy(sourcefile.FullName, destfile.FullName, true);
}
catch
{
return;
}
//load current properties after loading from stick
try
{
Properties.Settings.Default.Reload();
Properties.Settings.Default.DicDir = ReplacePath(Properties.Settings.Default.DicDir, SettingsOnStickReplaceDirection.PlaceholderToPath);
Properties.Settings.Default.RecentFiles = ReplacePath(Properties.Settings.Default.RecentFiles, SettingsOnStickReplaceDirection.PlaceholderToPath);
Properties.Settings.Default.Save();
}
catch (System.Configuration.ConfigurationErrorsException exp)
{
bool errorfixed = false;
if (exp.InnerException != null && exp.InnerException is System.Configuration.ConfigurationErrorsException)
{
System.Configuration.ConfigurationErrorsException innerexception = exp.InnerException as System.Configuration.ConfigurationErrorsException;
if (System.IO.File.Exists(innerexception.Filename))
{
try
{
System.IO.File.Delete(innerexception.Filename);
errorfixed = true;
}
catch { }
}
}
if (System.IO.File.Exists(exp.Filename))
{
try
{
System.IO.File.Delete(exp.Filename);
}
catch { }
}
if (System.IO.File.Exists(sourcefile.FullName))
{
try
{
System.IO.File.Delete(sourcefile.FullName);
errorfixed = true;
}
catch { }
}
if (errorfixed)
{
Program.MainForm.BringToFront();
Program.MainForm.TopMost = true;
Application.DoEvents();
MessageBox.Show(Properties.Resources.INITIALIZE_SETTINGS_ERROR, Properties.Resources.INITIALIZE_SETTINGS_CAPTION);
Environment.Exit(-1);
}
else
{
throw exp;
}
}
catch (Exception exp)
{
throw exp;
}
}