internal static void CheckBaseType(Type expectedBaseType, Type userBaseType, string propertyName, ConfigurationElement configElement)
 {
     if (!expectedBaseType.IsAssignableFrom(userBaseType))
     {
         throw new ConfigurationErrorsException(System.Web.SR.GetString("Invalid_type_to_inherit_from", new object[] { userBaseType.FullName, expectedBaseType.FullName }), configElement.ElementInformation.Properties[propertyName].Source, configElement.ElementInformation.Properties[propertyName].LineNumber);
     }
 }

 protected override void Reset(ConfigurationElement parentElement)
 {
     WsdlHelpGeneratorElement element = (WsdlHelpGeneratorElement) parentElement;
     WebContext hostingContext = base.EvaluationContext.HostingContext as WebContext;
     if (hostingContext != null)
     {
         string path = hostingContext.Path;
         bool flag = path == null;
         this.actualPath = element.actualPath;
         if (flag)
         {
             path = HostingEnvironment.ApplicationVirtualPath;
         }
         if ((path != null) && !path.EndsWith("/", StringComparison.Ordinal))
         {
             path = path + "/";
         }
         if ((path == null) && (parentElement != null))
         {
             this.virtualPath = element.virtualPath;
         }
         else if (path != null)
         {
             this.virtualPath = path;
         }
     }
     base.Reset(parentElement);
 }

 public new void Configure(ConfigurationElement configuration)
 {
     //Store the .config configuration section for us to maybe created modified version later (if requested on the model).
     //Note, we had to implement IConfigurable as well (despite it being implemented on our base class) or this would not be called.
     _realConfiguration  = configuration as OrderPipelinesProcessorConfiguration;
     base.Configure(configuration);
 }

    protected int BaseIndexOf (ConfigurationElement element)
    {
      Contract.Requires(element != null);
      Contract.Ensures(Contract.Result<int>() >= -1);

      return default(int);
    }

 protected override object GetElementKey(ConfigurationElement element)
 {
     var ele = element as IgnorePostfixConfigurationElement;
     if (ele == null)
         throw new ArgumentNullException("element", "element不能转换成 IgnoreConfigurationElement");
     return ele.Postfix;
 }

        protected override object GetElementKey(ConfigurationElement element)
        {
            if (element == null)
                throw new ArgumentNullException("element");

            return ((RepositoryElement)element).Name;
        }

 protected override object GetElementKey(ConfigurationElement element)
 {
     var ele = element as ServiceConfigurationElement;
     if (ele == null)
         throw new ArgumentNullException("element", "element不能转换成 ServiceConfigurationElement");
     return ele.Key;
 }

        internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType,
            string ignoreName, ConfigurationLockCollection parentCollection)
        {
            _thisElement = thisElement;
            LockType = lockType;
            _internalDictionary = new HybridDictionary();
            _internalArraylist = new ArrayList();
            IsModified = false;

            ExceptionList = (LockType == ConfigurationLockCollectionType.LockedExceptionList) ||
                (LockType == ConfigurationLockCollectionType.LockedElementsExceptionList);
            _ignoreName = ignoreName;

            if (parentCollection == null) return;

            foreach (string key in parentCollection) // seed the new collection
            {
                Add(key, ConfigurationValueFlags.Inherited); // add the local copy
                if (!ExceptionList) continue;

                if (_seedList.Length != 0)
                    _seedList += ",";
                _seedList += key;
            }
        }

        protected internal virtual string SerializeSection(ConfigurationElement parentElement, string name,
            ConfigurationSaveMode saveMode)
        {
            if ((CurrentConfiguration != null) &&
                (CurrentConfiguration.TargetFramework != null) &&
                !ShouldSerializeSectionInTargetVersion(CurrentConfiguration.TargetFramework))
                return string.Empty;

            ValidateElement(this, null, true);

            ConfigurationElement tempElement = CreateElement(GetType());
            tempElement.Unmerge(this, parentElement, saveMode);

            StringWriter strWriter = new StringWriter(CultureInfo.InvariantCulture);
            XmlTextWriter writer = new XmlTextWriter(strWriter)
            {
                Formatting = Formatting.Indented,
                Indentation = 4,
                IndentChar = ' '
            };

            tempElement.DataToWriteInternal = saveMode != ConfigurationSaveMode.Minimal;

            if ((CurrentConfiguration != null) && (CurrentConfiguration.TargetFramework != null))
                _configRecord.SectionsStack.Push(this);

            tempElement.SerializeToXmlElement(writer, name);

            if ((CurrentConfiguration != null) && (CurrentConfiguration.TargetFramework != null))
                _configRecord.SectionsStack.Pop();

            writer.Flush();
            return strWriter.ToString();
        }

        internal AutoConfigurationHelper(ConfigurationElement element, Action<ConfigurationProperty, object> valueSetter, Func<ConfigurationProperty, object> valueGetter)
        {
            _ConfigElement = element;
            _ValueSetter = valueSetter;
            _ValueGetter = valueGetter;

            var type = element.GetType();
            Dictionary<ConfigurationProperty, PropertyInfo> properties;
            if (!_TypeProperties.TryGetValue(type, out properties))
            {
                properties = new Dictionary<ConfigurationProperty, PropertyInfo>();
                foreach (var member in type.GetProperties())
                {
                    var configField = member.GetCustomAttributes(typeof(ConfigurationPropertyAttribute), true).Cast<ConfigurationPropertyAttribute>().FirstOrDefault();
                    if (configField != null)
                    {
                        var property = new ConfigurationProperty(configField.Name, member.PropertyType, configField.DefaultValue, ConfigurationPropertyOptions.None);
                        properties[property] = member;
                    }
                }
                _TypeProperties.TryAdd(type, properties);
            }
            _Properties = properties;

            // Pre-initialize properties of type ConfigurationElement, or things go boom
            foreach (var property in _Properties)
            {
                if (typeof(ConfigurationElement).IsAssignableFrom(property.Value.PropertyType))
                    property.Value.SetValue(_ConfigElement, _ValueGetter(property.Key), null);
            }
        }

 protected internal override void Reset(ConfigurationElement parentSection) {
     _KeyValueCollection = null;
     base.Reset(parentSection);
     if (!String.IsNullOrEmpty((string)base[s_propFile])) { // don't inherit from the parent
         SetPropertyValue(s_propFile,null,true); // ignore the lock to prevent inheritence
     }
 }

 protected override object GetElementKey(ConfigurationElement element)
 {
     if (element == null) throw new ArgumentNullException("element");
     var le = element as LocaleElement;
     if (le == null) throw new ArgumentException("Value must be LocaleElement.", "element");
     return le.Prefix;
 }

        /// <summary>
        /// Gets the element key for autofac component configuration element composed from component name and type.
        /// </summary>
        /// <param name="element">Autofac component configuration element</param>
        /// <returns>An <see cref="System.Object" /> that acts as the key for the specified <see cref="ConfigurationElement" />.</returns>
        protected override object GetElementKey(ConfigurationElement element)
        {
            Guard.NotNull("element", element);

            var component = (ComponentConfigurationElement)element;
            return component.Name + component.TypeString;
        }

 internal static Type GetType(string typeName, string propertyName, ConfigurationElement configElement, XmlNode node, bool checkAptcaBit, bool ignoreCase)
 {
     Type type;
     try
     {
         type = BuildManager.GetType(typeName, true, ignoreCase);
     }
     catch (Exception exception)
     {
         if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
         {
             throw;
         }
         if (node != null)
         {
             throw new ConfigurationErrorsException(exception.Message, exception, node);
         }
         if (configElement != null)
         {
             throw new ConfigurationErrorsException(exception.Message, exception, configElement.ElementInformation.Properties[propertyName].Source, configElement.ElementInformation.Properties[propertyName].LineNumber);
         }
         throw new ConfigurationErrorsException(exception.Message, exception);
     }
     if (checkAptcaBit)
     {
         if (node != null)
         {
             HttpRuntime.FailIfNoAPTCABit(type, node);
             return type;
         }
         HttpRuntime.FailIfNoAPTCABit(type, (configElement != null) ? configElement.ElementInformation : null, propertyName);
     }
     return type;
 }

            protected override object GetElementKey(ConfigurationElement element)
            {
                if (element == null)
                    throw new ArgumentNullException("element");

                return ((EtcdClient)element).Uri;
            }

 protected override object GetElementKey(ConfigurationElement element)
 {
     var server = element as DbConnect;
     if (server == null)
         return string.Empty;
     return server.Name;
 }

        protected override object GetElementKey(ConfigurationElement element)
        {
            if (element == null)
                throw new ArgumentNullException("element");

            return ((DependenceConf)element).Assembly;
        }

        private static IEnumerable<Argument> ReadConfigurationElement(ConfigurationElement element)
        {
            var arguments = new List<Argument>();

            var collection = element as ConfigurationElementCollection;

            if (collection != null)
            {
                foreach (ConfigurationElement child in collection)
                {
                    arguments.AddRange(ReadConfigurationElement(child));
                }
            }
            else
            {
                foreach (PropertyInfo property in element.GetType().GetProperties())
                {
                    object propertyValue = property.GetValue(element, null);

                    if (typeof (ConfigurationElement).IsAssignableFrom(property.PropertyType))
                    {
                        arguments.AddRange(ReadConfigurationElement((ConfigurationElement) propertyValue));
                    }

                    var argument = new Argument(property, propertyValue);
                    if (argument.Include())
                    {
                        arguments.Add(argument);
                    }
                }
            }
            return arguments;
        }

 protected override object GetElementKey(ConfigurationElement element)
 {
     var elem = element as AppConfigElement;
     if (elem == null)
         throw new ConfigurationErrorsException ("Child of applications element is not AppConfigElement");
     return elem.Name;
 }

		protected override object GetElementKey (ConfigurationElement element)
		{
			//			if (BaseIndexOf (element) == -1)
			//				return "";

			return ((KeyValueConfigurationElement)element).Key;
		}