|
static private UnexpectedError ( string methodName ) : |
||
| methodName | string | |
| Результат | ||
public override bool IsDefinitionAllowed(string configPath, ConfigurationAllowDefinition allowDefinition,
ConfigurationAllowExeDefinition allowExeDefinition)
{
string allowedConfigPath;
switch (allowExeDefinition)
{
case ConfigurationAllowExeDefinition.MachineOnly:
allowedConfigPath = MachineConfigPath;
break;
case ConfigurationAllowExeDefinition.MachineToApplication:
allowedConfigPath = ExeConfigPath;
break;
case ConfigurationAllowExeDefinition.MachineToRoamingUser:
allowedConfigPath = RoamingUserConfigPath;
break;
// MachineToLocalUser does not current have any definition restrictions
case ConfigurationAllowExeDefinition.MachineToLocalUser:
return(true);
default:
// If we have extended ConfigurationAllowExeDefinition
// make sure to update this switch accordingly
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::IsDefinitionAllowed");
}
return(configPath.Length <= allowedConfigPath.Length);
}
public override bool IsDefinitionAllowed(string configPath, ConfigurationAllowDefinition allowDefinition, ConfigurationAllowExeDefinition allowExeDefinition)
{
string str;
switch (allowExeDefinition)
{
case ConfigurationAllowExeDefinition.MachineToRoamingUser:
str = "MACHINE/EXE/ROAMING_USER";
break;
case ConfigurationAllowExeDefinition.MachineToLocalUser:
return(true);
case ConfigurationAllowExeDefinition.MachineOnly:
str = "MACHINE";
break;
case ConfigurationAllowExeDefinition.MachineToApplication:
str = "MACHINE/EXE";
break;
default:
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::IsDefinitionAllowed");
}
return(configPath.Length <= str.Length);
}
public override void VerifyDefinitionAllowed(string configPath, ConfigurationAllowDefinition allowDefinition,
ConfigurationAllowExeDefinition allowExeDefinition, IConfigErrorInfo errorInfo)
{
if (!IsDefinitionAllowed(configPath, allowDefinition, allowExeDefinition))
{
switch (allowExeDefinition)
{
case ConfigurationAllowExeDefinition.MachineOnly:
throw new ConfigurationErrorsException(
SR.Config_allow_exedefinition_error_machine, errorInfo);
case ConfigurationAllowExeDefinition.MachineToApplication:
throw new ConfigurationErrorsException(
SR.Config_allow_exedefinition_error_application, errorInfo);
case ConfigurationAllowExeDefinition.MachineToRoamingUser:
throw new ConfigurationErrorsException(
SR.Config_allow_exedefinition_error_roaminguser, errorInfo);
default:
// If we have extended ConfigurationAllowExeDefinition
// make sure to update this switch accordingly
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::VerifyDefinitionAllowed");
}
}
}
internal Configuration(string locationSubPath, Type typeConfigHost, params object[] hostInitConfigurationParams)
{
string str;
string str2;
this._typeConfigHost = typeConfigHost;
this._hostInitConfigurationParams = hostInitConfigurationParams;
this._configRoot = new InternalConfigRoot(this);
IInternalConfigHost host = (IInternalConfigHost)System.Configuration.TypeUtil.CreateInstanceWithReflectionPermission(typeConfigHost);
IInternalConfigHost host2 = new UpdateConfigHost(host);
((IInternalConfigRoot)this._configRoot).Init(host2, true);
host.InitForConfiguration(ref locationSubPath, out str, out str2, this._configRoot, hostInitConfigurationParams);
if (!string.IsNullOrEmpty(locationSubPath) && !host2.SupportsLocation)
{
throw ExceptionUtil.UnexpectedError("Configuration::ctor");
}
if (string.IsNullOrEmpty(locationSubPath) != string.IsNullOrEmpty(str2))
{
throw ExceptionUtil.UnexpectedError("Configuration::ctor");
}
this._configRecord = (MgmtConfigurationRecord)this._configRoot.GetConfigRecord(str);
if (!string.IsNullOrEmpty(locationSubPath))
{
this._configRecord = MgmtConfigurationRecord.Create(this._configRoot, this._configRecord, str2, locationSubPath);
}
this._configRecord.ThrowIfInitErrors();
}
public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext)
{
if (!this.IsFile(streamName))
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::OpenStreamForWrite");
}
return(base.Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext));
}
public override void DeleteStream(string streamName)
{
if (!this.IsFile(streamName))
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Delete");
}
base.Host.DeleteStream(streamName);
}
public override void Init(IInternalConfigRoot configRoot, params object[] hostInitParams)
{
try
{
ConfigurationFileMap fileMap = (ConfigurationFileMap)hostInitParams[0];
_exePath = (string)hostInitParams[1];
Host.Init(configRoot, hostInitParams);
// Do not complete initialization in runtime config, to avoid expense of
// loading user.config files that may not be required.
_initComplete = configRoot.IsDesignTime;
if ((fileMap != null) && !string.IsNullOrEmpty(_exePath))
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Init");
}
if (string.IsNullOrEmpty(_exePath))
{
_exePath = null;
}
// Initialize the fileMap, if provided.
if (fileMap != null)
{
_fileMap = new ExeConfigurationFileMap();
if (!string.IsNullOrEmpty(fileMap.MachineConfigFilename))
{
_fileMap.MachineConfigFilename = Path.GetFullPath(fileMap.MachineConfigFilename);
}
ExeConfigurationFileMap exeFileMap = fileMap as ExeConfigurationFileMap;
if (exeFileMap != null)
{
if (!string.IsNullOrEmpty(exeFileMap.ExeConfigFilename))
{
_fileMap.ExeConfigFilename = Path.GetFullPath(exeFileMap.ExeConfigFilename);
}
if (!string.IsNullOrEmpty(exeFileMap.RoamingUserConfigFilename))
{
_fileMap.RoamingUserConfigFilename = Path.GetFullPath(exeFileMap.RoamingUserConfigFilename);
}
if (!string.IsNullOrEmpty(exeFileMap.LocalUserConfigFilename))
{
_fileMap.LocalUserConfigFilename = Path.GetFullPath(exeFileMap.LocalUserConfigFilename);
}
}
}
}
catch
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Init");
}
}
public override void DeleteStream(string streamName)
{
// only support files, not URIs
if (!IsFile(streamName))
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Delete");
}
Host.DeleteStream(streamName);
}
public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext)
{
// only support files, not URIs
if (!IsFile(streamName))
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::OpenStreamForWrite");
}
return(Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext));
}
internal Configuration(string locationSubPath, Type typeConfigHost, params object[] hostInitConfigurationParams)
{
_typeConfigHost = typeConfigHost;
_hostInitConfigurationParams = hostInitConfigurationParams;
IInternalConfigHost configHost = (IInternalConfigHost)TypeUtil.CreateInstance(typeConfigHost);
// Wrap the host with the UpdateConfigHost to support SaveAs.
UpdateConfigHost updateConfigHost = new UpdateConfigHost(configHost);
// Now wrap in ImplicitMachineConfigHost so we can stub in a simple machine.config if needed.
IInternalConfigHost implicitMachineConfigHost = new ImplicitMachineConfigHost(updateConfigHost);
InternalConfigRoot configRoot = new InternalConfigRoot(this, updateConfigHost);
((IInternalConfigRoot)configRoot).Init(implicitMachineConfigHost, isDesignTime: 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;
implicitMachineConfigHost.InitForConfiguration(
ref locationSubPath,
out configPath,
out locationConfigPath,
configRoot,
hostInitConfigurationParams);
if (!string.IsNullOrEmpty(locationSubPath) && !implicitMachineConfigHost.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 ContextInformation _evalContext; // evaluation context
internal Configuration(string locationSubPath, Type typeConfigHost, params object[] hostInitConfigurationParams)
{
_typeConfigHost = typeConfigHost;
_hostInitConfigurationParams = hostInitConfigurationParams;
_configRoot = new InternalConfigRoot();
IInternalConfigHost configHost = (IInternalConfigHost)TypeUtil.CreateInstanceWithReflectionPermission(typeConfigHost);
// Wrap the host with the UpdateConfigHost to support SaveAs.
IInternalConfigHost updateConfigHost = new UpdateConfigHost(configHost);
_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();
}
public override void Init(IInternalConfigRoot configRoot, params object[] hostInitParams)
{
try
{
ConfigurationFileMap map = (ConfigurationFileMap)hostInitParams[0];
this._exePath = (string)hostInitParams[1];
base.Host.Init(configRoot, hostInitParams);
this._initComplete = configRoot.IsDesignTime;
if ((map != null) && !string.IsNullOrEmpty(this._exePath))
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Init");
}
if (string.IsNullOrEmpty(this._exePath))
{
this._exePath = null;
}
if (map != null)
{
this._fileMap = new ExeConfigurationFileMap();
if (!string.IsNullOrEmpty(map.MachineConfigFilename))
{
this._fileMap.MachineConfigFilename = Path.GetFullPath(map.MachineConfigFilename);
}
ExeConfigurationFileMap map2 = map as ExeConfigurationFileMap;
if (map2 != null)
{
if (!string.IsNullOrEmpty(map2.ExeConfigFilename))
{
this._fileMap.ExeConfigFilename = Path.GetFullPath(map2.ExeConfigFilename);
}
if (!string.IsNullOrEmpty(map2.RoamingUserConfigFilename))
{
this._fileMap.RoamingUserConfigFilename = Path.GetFullPath(map2.RoamingUserConfigFilename);
}
if (!string.IsNullOrEmpty(map2.LocalUserConfigFilename))
{
this._fileMap.LocalUserConfigFilename = Path.GetFullPath(map2.LocalUserConfigFilename);
}
}
}
}
catch (SecurityException)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_security"));
}
catch
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Init");
}
}
// Serialization methods
protected ConfigurationErrorsException(SerializationInfo info, StreamingContext context) :
base(info, context)
{
string firstFilename;
int firstLine;
int count;
string numPrefix;
string currentType;
Type currentExceptionType;
// Retrieve out members
firstFilename = info.GetString(SERIALIZATION_PARAM_FILENAME);
firstLine = info.GetInt32(SERIALIZATION_PARAM_LINE);
Init(firstFilename, firstLine);
// Retrieve errors for _errors object
count = info.GetInt32(SERIALIZATION_PARAM_ERROR_COUNT);
if (count != 0)
{
_errors = new ConfigurationException[count];
for (int i = 0; i < count; i++)
{
numPrefix = i.ToString(CultureInfo.InvariantCulture);
currentType = info.GetString(numPrefix + SERIALIZATION_PARAM_ERROR_TYPE);
currentExceptionType = Type.GetType(currentType, true);
// Only allow our exception types
if ((currentExceptionType != typeof(ConfigurationException)) &&
(currentExceptionType != typeof(ConfigurationErrorsException)))
{
throw ExceptionUtil.UnexpectedError("ConfigurationErrorsException");
}
_errors[i] = (ConfigurationException)
info.GetValue(numPrefix + SERIALIZATION_PARAM_ERROR_DATA,
currentExceptionType);
}
}
}
public override void VerifyDefinitionAllowed(string configPath, ConfigurationAllowDefinition allowDefinition, ConfigurationAllowExeDefinition allowExeDefinition, IConfigErrorInfo errorInfo)
{
if (!this.IsDefinitionAllowed(configPath, allowDefinition, allowExeDefinition))
{
ConfigurationAllowExeDefinition definition = allowExeDefinition;
if (definition != ConfigurationAllowExeDefinition.MachineOnly)
{
if (definition == ConfigurationAllowExeDefinition.MachineToApplication)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_allow_exedefinition_error_application"), errorInfo);
}
if (definition == ConfigurationAllowExeDefinition.MachineToRoamingUser)
{
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_allow_exedefinition_error_roaminguser"), errorInfo);
}
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::VerifyDefinitionAllowed");
}
throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_allow_exedefinition_error_machine"), errorInfo);
}
}
protected ConfigurationErrorsException(SerializationInfo info, StreamingContext context) :
base(info, context)
{
int firstLine;
int count;
// Retrieve out members
string firstFilename = info.GetString(SerializationParamFilename);
firstLine = info.GetInt32(SerializationParamLine);
Init(firstFilename, firstLine);
// Retrieve errors for _errors object
count = info.GetInt32(SerializationParamErrorCount);
if (count == 0)
{
return;
}
_errors = new ConfigurationException[count];
for (int i = 0; i < count; i++)
{
string numPrefix = i.ToString(CultureInfo.InvariantCulture);
string currentType = info.GetString(numPrefix + SerializationParamErrorType);
Type currentExceptionType = Type.GetType(currentType, true);
// Only allow our exception types
if ((currentExceptionType != typeof(ConfigurationException)) &&
(currentExceptionType != typeof(ConfigurationErrorsException)))
{
throw ExceptionUtil.UnexpectedError("ConfigurationErrorsException");
}
_errors[i] = (ConfigurationException)
info.GetValue(numPrefix + SerializationParamErrorData,
currentExceptionType);
}
}
protected ConfigurationErrorsException(SerializationInfo info, StreamingContext context) : base(info, context)
{
string filename = info.GetString("firstFilename");
int line = info.GetInt32("firstLine");
this.Init(filename, line);
int num2 = info.GetInt32("count");
if (num2 != 0)
{
this._errors = new ConfigurationException[num2];
for (int i = 0; i < num2; i++)
{
string str2 = i.ToString(CultureInfo.InvariantCulture);
Type type = Type.GetType(info.GetString(str2 + "_errors_type"), true);
if ((type != typeof(ConfigurationException)) && (type != typeof(ConfigurationErrorsException)))
{
throw ExceptionUtil.UnexpectedError("ConfigurationErrorsException");
}
this._errors[i] = (ConfigurationException)info.GetValue(str2 + "_errors", type);
}
}
}
public override void Init(IInternalConfigRoot configRoot, params object[] hostInitParams)
{
try {
ConfigurationFileMap fileMap = (ConfigurationFileMap)hostInitParams[0];
_exePath = (string)hostInitParams[1];
Host.Init(configRoot, hostInitParams);
// Do not complete initialization in runtime config, to avoid expense of
// loading user.config files that may not be required.
_initComplete = configRoot.IsDesignTime;
if (fileMap != null && !String.IsNullOrEmpty(_exePath))
{
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Init");
}
if (String.IsNullOrEmpty(_exePath))
{
_exePath = null;
}
// Initialize the fileMap, if provided.
if (fileMap != null)
{
_fileMap = new ExeConfigurationFileMap();
if (!String.IsNullOrEmpty(fileMap.MachineConfigFilename))
{
_fileMap.MachineConfigFilename = Path.GetFullPath(fileMap.MachineConfigFilename);
}
ExeConfigurationFileMap exeFileMap = fileMap as ExeConfigurationFileMap;
if (exeFileMap != null)
{
if (!String.IsNullOrEmpty(exeFileMap.ExeConfigFilename))
{
_fileMap.ExeConfigFilename = Path.GetFullPath(exeFileMap.ExeConfigFilename);
}
if (!String.IsNullOrEmpty(exeFileMap.RoamingUserConfigFilename))
{
_fileMap.RoamingUserConfigFilename = Path.GetFullPath(exeFileMap.RoamingUserConfigFilename);
}
if (!String.IsNullOrEmpty(exeFileMap.LocalUserConfigFilename))
{
_fileMap.LocalUserConfigFilename = Path.GetFullPath(exeFileMap.LocalUserConfigFilename);
}
}
}
}
catch (SecurityException) {
// Lets try to give them some information telling them
// they don't have enough security privileges
throw new ConfigurationErrorsException(
SR.GetString(SR.Config_client_config_init_security));
}
catch {
throw ExceptionUtil.UnexpectedError("ClientConfigurationHost::Init");
}
}