static internal IInternalConfigRecord Create(
                InternalConfigRoot          configRoot,
                IInternalConfigRecord       parent,
                string                      configPath) {

            RuntimeConfigurationRecord configRecord = new RuntimeConfigurationRecord();
            configRecord.Init(configRoot, (BaseConfigurationRecord) parent, configPath, null);
            return configRecord;
        }

        private HybridDictionary _streamInfoUpdates; // List of StreamInfo, including the main config file, the configSource this record uses, and
                                                    // new configSource stream added thru API


        static internal MgmtConfigurationRecord Create(
                IInternalConfigRoot         configRoot,
                IInternalConfigRecord       parent,
                string                      configPath,
                string                      locationSubPath) {

            MgmtConfigurationRecord configRecord = new MgmtConfigurationRecord();
            configRecord.Init(configRoot, parent, configPath, locationSubPath);
            return configRecord;
        }

 protected RuntimeConfig(IInternalConfigRecord configRecord, bool permitNull)
 {
     this._configRecord = configRecord;
     this._permitNull = permitNull;
     this._results = new object[0x18];
     for (int i = 0; i < this._results.Length; i++)
     {
         this._results[i] = s_unevaluatedResult;
     }
 }

        private void Init(
                IInternalConfigRoot         configRoot,
                IInternalConfigRecord       parent,
                string                      configPath,
                string                      locationSubPath) {

            base.Init(configRoot, (BaseConfigurationRecord) parent, configPath, locationSubPath);

            if (    IsLocationConfig &&
                    (MgmtParent._locationTags == null || !MgmtParent._locationTags.Contains(_locationSubPath))) {

                // By instantiating a "new" LocationSubPath class, we have implicitly
                // asked for one to be created
                _flags[ForceLocationWritten] = true;
            }

            // Copy all stream information so that we can model changes to ConfigSource
            InitStreamInfoUpdates();
        }

 public override void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
 {
     string streamName;
     bool flag = this.IsFile(configRecord.StreamName);
     if (flag)
     {
         streamName = UrlPath.ConvertFileNameToUrl(configRecord.StreamName);
     }
     else
     {
         streamName = configRecord.StreamName;
     }
     Evidence evidence = new Evidence();
     evidence.AddHostEvidence<Url>(new Url(streamName));
     evidence.AddHostEvidence<Zone>(Zone.CreateFromUrl(streamName));
     if (!flag)
     {
         evidence.AddHostEvidence<Site>(Site.CreateFromUrl(streamName));
     }
     permissionSet = SecurityManager.GetStandardSandbox(evidence);
     isHostReady = true;
 }

		public virtual void GetRestrictedPermissions (IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady)
		{
			throw new NotImplementedException ();
		}

		public virtual bool IsInitDelayed (IInternalConfigRecord configRecord)
		{
			throw new NotImplementedException ();
		}

        public override void RequireCompleteInit(IInternalConfigRecord record)
        {
            // Loading information about user.config files is expensive,
            // so do it just once by locking.
            lock (this)
            {
                if (!_initComplete)
                {
                    // Note that all future requests for config must be complete.
                    _initComplete = true;

                    // Throw out the ConfigPath for this exe.
                    ClientConfigPaths.RefreshCurrent();

                    // Throw out our cached copy.
                    _configPaths = null;

                    // Force loading of user.config file information under lock.
                    ClientConfigPaths configPaths = ConfigPaths;
                }
            }
        }

 internal static void StaticGetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
     isHostReady = HttpRuntime.IsTrustLevelInitialized;
     permissionSet = null;
     if (isHostReady && IsVirtualPathConfigPath(configRecord.ConfigPath)) {
         permissionSet = HttpRuntime.NamedPermissionSet;
     }
 }

 void IInternalConfigHost.RequireCompleteInit(IInternalConfigRecord configRecord) {
 }

	// Methods
	public virtual bool IsInitDelayed(IInternalConfigRecord configRecord) {}

	public virtual void RequireCompleteInit(IInternalConfigRecord configRecord) {}

 public override bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord) {
     if (HostingEnvironment.IsHosted) {
         return HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted);
     }
     else {
         return Host.IsFullTrustSectionWithoutAptcaAllowed(configRecord);
     }
 }

 private void OnConfigRemoved(object sender, InternalConfigEventArgs e)
 {
     try
     {
         IInternalConfigRecord configRecord = this._configRoot.GetConfigRecord(this._completeConfigRecord.ConfigPath);
         this._completeConfigRecord = configRecord;
         this._completeConfigRecord.ThrowIfInitErrors();
     }
     catch (Exception exception)
     {
         this._initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception);
         ConfigurationManager.SetInitError(this._initError);
         throw this._initError;
     }
 }

 public override void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
     StaticGetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
 }

 // Delay init if we have not been asked to complete init, and it is a user.config file.
 public override bool IsInitDelayed(IInternalConfigRecord configRecord)
 {
     return !_initComplete && IsUserConfig(configRecord.ConfigPath);
 }

 public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
     Host.GetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
 }

 //
 // If config has been removed because initialization was not complete,
 // fetch a new configuration record. The record will be created and
 // completely initialized as RequireCompleteInit() will have been called
 // on the ClientConfigurationHost before we receive this event.
 //
 private void OnConfigRemoved(object sender, InternalConfigEventArgs e) {
     try {
         IInternalConfigRecord newConfigRecord = _configRoot.GetConfigRecord(_completeConfigRecord.ConfigPath);
         _completeConfigRecord = newConfigRecord;
         _completeConfigRecord.ThrowIfInitErrors();
     }
     catch (Exception ex) {
         _initError = new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_init_error), ex);
         ConfigurationManager.SetInitError(_initError);
         throw _initError;
     }
 }

 public virtual bool IsInitDelayed(IInternalConfigRecord configRecord) {
     return Host.IsInitDelayed(configRecord);
 }

		public virtual bool IsFullTrustSectionWithoutAptcaAllowed (IInternalConfigRecord configRecord)
		{
			throw new NotImplementedException ();
		}