configurationrecord.cs

蓝牙通讯

							// Wrap all others as ConfigurationExceptions
							throw new ConfigurationException("Exception in ConfigSectionHandler", ex, filename, line);
						}
					}
					continue;
				}
				StrictSkipToNextElement(reader);
			}
			return config;
		}

		private void ScanFactoriesRecursive(XmlTextReader reader)
		{
			// Skip processor instructions and comments
			reader.MoveToContent();

			if (reader.NodeType != XmlNodeType.Element || reader.Name != "configuration")
			{
				throw BuildConfigError(filename + " doesn't have root configuration", reader);
			}

			CheckForUnrecognizedAttributes(reader);
			
			// Move to first child of <configuration>
			StrictReadToNextElement(reader);
			if (reader.Depth == 1)
			{
				if(reader.Name == "configSections")
				{
					CheckForUnrecognizedAttributes(reader);
					ScanFactoriesRecursive(reader, null);
				}
			}
		}

        private void ScanFactoriesRecursive(XmlTextReader reader, string configKey) {
           
            int depth = reader.Depth;
            StrictReadToNextElement(reader);
            while (reader.Depth == depth + 1) {
                switch(reader.Name) {
                    case "sectionGroup": {
                        // Get the name of the current sectionGroup
                        string tagName = null;
                        if (reader.HasAttributes) {
                            while (reader.MoveToNextAttribute()) {
                                if (reader.Name != "name")
                                    ThrowUnrecognizedAttribute(reader);
                                tagName = reader.Value;
                            }
                            reader.MoveToElement();
                        }
                        // sectionGroup name attribute must have a value
                        CheckRequiredAttribute(tagName, "name", reader);
                        // Check the validity of the section name
                        VerifySectionName(tagName, reader);

                        // Add the current sectionGroup to the hashtable and process it
                        string tagKey = TagKey(configKey, tagName);
                        if (HaveFactoryEnum.Section == HaveFactory(tagName)) {
                            throw BuildConfigError("Tag name already defined", reader);
                        }
                        EnsureFactories[tagKey] = GroupSingleton;
                        ScanFactoriesRecursive(reader, tagKey);
                        continue; 
                    }
                    case "section": {
                        string tagName = null;
                        string typeName = null;

                        if (reader.HasAttributes) {
                            while (reader.MoveToNextAttribute()) {
                                switch(reader.Name) {
                                    case "name": 
                                        tagName = reader.Value;
                                        break;
                                    case "type":
                                        typeName = reader.Value;
                                        break;
                                    case "allowLocation":
                                    case "allowDefinition":
                                        break;
                                    default:
                                        ThrowUnrecognizedAttribute(reader);
                                        break;
                                }
                            }
                            reader.MoveToElement();
                        }
                        CheckRequiredAttribute(tagName, "name", reader);
                        CheckRequiredAttribute(typeName, "type", reader);
                        VerifySectionName(tagName, reader);
                        string tagKey = TagKey(configKey, tagName);
                        if (HaveFactory(tagKey) != HaveFactoryEnum.NotFound) {
                            throw BuildConfigError("Tag name already defined", reader);
                        }
                        EnsureFactories[tagKey] = typeName;
                        break;
                    }
                    case "remove": {
                        string tagName = null;
                        // Schema defines that <remove /> elements must have a name attribute
                        // so check to see if we have one and retrieve its value
                        if (reader.HasAttributes) {
                            while (reader.MoveToNextAttribute()) {
                                if (reader.Name != "name")
                                    ThrowUnrecognizedAttribute(reader);
                                tagName = reader.Value;
                            }
                            reader.MoveToElement();
                        }
                        // Enforce schema definition of remove element
                        if (tagName == null)
                            this.ThrowRequiredAttribute(reader, "name");
                        // Does the remove element have a valid name?
                        this.VerifySectionName(tagName, reader);

                        // If so, add it to the hashtable
                        string tagKey = ConfigurationRecord.TagKey(configKey, tagName);
                        if (HaveFactory(tagKey) != HaveFactoryEnum.Section) {
                            throw BuildConfigError("Could not remove section handler", reader);
                        }
                        EnsureFactories[tagName] = RemovedFactorySingleton;
                        break;
                    }
                    case "clear": {
                        // Config schema definition states that clear element has no attributes
                        CheckForUnrecognizedAttributes(reader);
                        // Reset factories hashtable
                        factories = null;
                        factoriesNoInherit = true;
                        break;
                    }
                    default:
                        ThrowUnrecognizedElement(reader);
                        break;
                }

                this.StrictReadToNextElement(reader);
                // Unrecognized children are not allowed
                if (reader.Depth > depth + 1) {
                    ThrowUnrecognizedElement(reader);
                }
            }
        }

		private static string TagKey(string configKey, string tagName)
		{
			return (configKey != null) ? String.Concat(configKey, "/", tagName) : tagName;
		}

		private void VerifySectionName(string tagName, XmlTextReader reader)
		{
			if (tagName.StartsWith("config"))
			{
				BuildConfigError("Tag name cannot begin with config", reader);
			}
			if (tagName == "location")
			{
				BuildConfigError("Tag name cannot be location", reader);
			}
		}

		private void ScanSectionsRecursive(XmlTextReader reader, string configKey)
		{
			int depth = reader.Depth;
			
			// only move to child nodes on first level (we've already passed the first <configSections>)
			if (configKey == null)
			{
				depth = 0;
			}
			else
			{
				StrictReadToNextElement(reader);
			}

			while (reader.Depth == depth + 1)
			{
				string tagName = reader.Name;
				string tagKey = TagKey(configKey, tagName);

				HaveFactoryEnum haveFactory = HaveFactory(tagKey);
				
				if (haveFactory == HaveFactoryEnum.Group)
				{
					ScanSectionsRecursive(reader, tagKey);
				}
				else if(haveFactory == HaveFactoryEnum.NotFound)
				{
					if (tagKey != "location")
					{
					}
					else if (tagKey == "configSections")
					{
						throw BuildConfigError("ClientConfig: too many ConfigSection elements", reader);
					}
					else
					{
						throw BuildConfigError("Unrecognized ConfigurationSection: " + tagName, reader);
					}
				}
				else
				{
					if(unevaluatedSections == null)
					{
						unevaluatedSections = new Hashtable();
					}
					unevaluatedSections[tagKey] = null;
				}
				StrictSkipToNextElement(reader);
			}
		}

		private static XmlTextReader OpenXmlTextReader(string configFileName)
		{
			string localFileName;
			Uri uri = new Uri(configFileName);

			bool isFile = uri.Scheme == "file";
			if(isFile)
			{
				localFileName = uri.LocalPath;
			}
			else
			{
				localFileName = uri.ToString();
			}
			XmlTextReader reader = null;
			try
			{
				if(isFile)
				{
					if (!File.Exists(uri.LocalPath))
					{
						return null;
					}
					reader = new XmlTextReader(localFileName);
				}
				else
				{
					try
					{
						Stream stream = File.OpenRead(configFileName);
						reader = new XmlTextReader(stream);
					}
					catch
					{
						return null;
					}
				}
				reader.MoveToContent();
				return reader;
			}
			catch (Exception)
			{
				throw new ConfigurationException("ErrorloadingXMLfile", localFileName, 0);
			}
		}

		private ConfigurationException BuildConfigError(string message, XmlTextReader reader)
		{
			return new ConfigurationException(message, filename, reader.LineNumber);
		}

		private ConfigurationException BuildConfigError(string message, Exception inner, XmlTextReader reader)
		{
			return new ConfigurationException(message, inner, filename, reader.LineNumber);
		}

		private void StrictReadToNextElement(XmlTextReader reader)
		{
			while (reader.Read())
			{
				if (reader.NodeType == XmlNodeType.Element)
				{
					return;
				}
				CheckIgnorableNodeType(reader);
			}
		}

		private void StrictSkipToNextElement(XmlTextReader reader)
		{
			reader.Skip();
			while (!reader.EOF && reader.NodeType != XmlNodeType.Element)
			{
				CheckIgnorableNodeType(reader);
				reader.Read();
			}
		}

		private void CheckIgnorableNodeType(XmlTextReader reader)
		{
			if (reader.NodeType != XmlNodeType.Comment && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Whitespace && reader.NodeType != XmlNodeType.SignificantWhitespace)
			{
				ThrowUnrecognizedElement(reader);
			}
		}

		private void ThrowUnrecognizedAttribute(XmlTextReader reader)
		{
			throw BuildConfigError("Configbaseunrecognizedattribute", reader);
		}

		private void CheckForUnrecognizedAttributes(XmlTextReader reader)
		{
			if (reader.HasAttributes)
			{
				reader.MoveToNextAttribute();
				ThrowUnrecognizedAttribute(reader);
			}
		}

		private void ThrowRequiredAttribute(XmlTextReader reader, string attrib)
		{
			throw BuildConfigError("Missing required attribute", reader);
		}

		private void ThrowUnrecognizedElement(XmlTextReader reader)
		{
			throw BuildConfigError("ConfigBase unrecognized element", reader);
		}

		private void CheckRequiredAttribute(object o, string attrName, XmlTextReader reader)
		{
			if (o == null)
			{
				ThrowRequiredAttribute(reader, "name");
			}
		}

		private ConfigurationException TranslateXmlParseOrEvaluateErrors(Exception e)
		{
			XmlException e2 = e as XmlException;
			if (e2 != null)
			{
				return new ConfigurationException(e2.Message, e, filename, e2.LineNumber);
			}
			else
			{
				return new ConfigurationException("Error loading XML file", e, filename, 0);
			}
		}
	}
}