C# Schema.XmlSchema类代码示例

		public void Bug360541 ()
		{
			XmlSchemaComplexType stype = GetStype ();
			
			XmlSchemaElement selem1 = new XmlSchemaElement ();
			selem1.Name = "schema";
			selem1.SchemaType = stype;

			XmlSchema schema = new XmlSchema ();
			schema.Items.Add (selem1);

			XmlSchemas xs = new XmlSchemas ();
			xs.Add (schema);

			xs.Find (XmlQualifiedName.Empty, typeof (XmlSchemaElement));

			selem1 = new XmlSchemaElement ();
			selem1.Name = "schema1";
			selem1.SchemaType = stype;

			schema = new XmlSchema ();
			schema.Items.Add (selem1);

			xs = new XmlSchemas ();
			xs.Add (schema);
			xs.Find (XmlQualifiedName.Empty, typeof (XmlSchemaElement));
		}

        private void LoadSchema(string schemaUri)
        {
            //string fullSchemaURI = @"http://local.bbc.co.uk:8081/schemas/" + schemaUri;
            //string fullSchemaURI = @"http://dnadev.national.core.bbc.co.uk/bbc.dna/schemas/" + schemaUri;


            if (_cachedSchemas.ContainsKey(schemaUri))
            {
                //Retrieve shema from cache.
                _xmlSchema = _cachedSchemas[schemaUri];
            }
            else
            {
                //Get Local Path of schema file.
                // Make sure that you specify the Schema directory name is Case correct.

                using (var iis = IIsInitialise.GetIIsInitialise())
                {
                    String path = iis.GetVDirPath("h2g2UnitTesting", "Schemas");
                    path = Path.Combine(path, schemaUri);

                    _xmlSchema = new XmlSchema();
                    //Uri ourUri = new Uri(fullSchemaURI);
                    //WebRequest request = WebRequest.Create(ourUri);
                    //request.Proxy = null;
                    //WebResponse response = request.GetResponse();

                    //Read Schema from local path. This allows relative includes within the schema files to be resolved correctly.
                    _xmlSchema = XmlSchema.Read(new XmlTextReader(path), new ValidationEventHandler(xmlReaderSettingsValidationEventHandler));
                }

                //Cache it.
                _cachedSchemas[schemaUri] = _xmlSchema;
            }
        }

 private static XmlReaderSettings CreateXmlReaderSettings(XmlSchema xmlSchema)
 {
     XmlReaderSettings settings = new XmlReaderSettings();
     settings.ValidationType = ValidationType.Schema;
     settings.Schemas.Add(xmlSchema);
     return settings;
 }

		///<remarks>
		/// 1. Content must be present and one of restriction or extention
		///</remarks>
		internal override int Compile(ValidationEventHandler h, XmlSchema schema)
		{
			// If this is already compiled this time, simply skip.
			if (CompilationId == schema.CompilationId)
				return 0;

			if(Content == null)
			{
				error(h, "Content must be present in a simpleContent");
			}
			else
			{
				if(Content is XmlSchemaSimpleContentRestriction)
				{
					XmlSchemaSimpleContentRestriction xscr = (XmlSchemaSimpleContentRestriction) Content;
					errorCount += xscr.Compile(h, schema);
				}
				else if(Content is XmlSchemaSimpleContentExtension)
				{
					XmlSchemaSimpleContentExtension xsce = (XmlSchemaSimpleContentExtension) Content;
					errorCount += xsce.Compile(h, schema);
				}
				else
					error(h,"simpleContent can't have any value other than restriction or extention");
			}
			
			XmlSchemaUtil.CompileID(Id,this, schema.IDCollection,h);
			this.CompilationId = schema.CompilationId;
			return errorCount;
		}

		/// <summary>
		/// Customizes the generated code to better conform to the NHibernate's coding conventions.
		/// </summary>
		/// <param name="code">The customizable code DOM.</param>
		/// <param name="sourceSchema">The source XML Schema.</param>
		protected override void CustomizeGeneratedCode(CodeNamespace code, XmlSchema sourceSchema)
		{
			new ImproveHbmTypeNamesCommand(code).Execute();
			new ImproveEnumFieldsCommand(code).Execute();

			// TODO: Rename class fields?
		}

        public void v2()
        {
            XmlSchemaSet sc = new XmlSchemaSet();
            sc.XmlResolver = new XmlUrlResolver();
            XmlSchema schema = new XmlSchema();
            sc.Add(null, TestData._XsdNoNs);
            CError.Compare(sc.Count, 1, "AddCount");
            CError.Compare(sc.IsCompiled, false, "AddIsCompiled");

            sc.Compile();
            CError.Compare(sc.IsCompiled, true, "IsCompiled");
            CError.Compare(sc.Count, 1, "Count");

            try
            {
                schema = sc.Add(null, Path.Combine(TestData._Root, "include_v2.xsd"));
            }
            catch (XmlSchemaException)
            {
                // no schema should be addded to the set.
                CError.Compare(sc.Count, 1, "Count");
                CError.Compare(sc.IsCompiled, true, "IsCompiled");
                return;
            }
            Assert.True(false);
        }

		public void TestSimpleValidation ()
		{
			string xml = "<root/>";
			xvr = PrepareXmlReader (xml);
			Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);
			XmlSchema schema = new XmlSchema ();
			XmlSchemaElement elem = new XmlSchemaElement ();
			elem.Name = "root";
			schema.Items.Add (elem);
			xvr.Schemas.Add (schema);
			xvr.Read ();	// root
			Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);
			xvr.Read ();	// EOF

			xml = "<hoge/>";
			xvr = PrepareXmlReader (xml);
			xvr.Schemas.Add (schema);
			try {
				xvr.Read ();
				Assert.Fail ("element mismatch is incorrectly allowed");
			} catch (XmlSchemaException) {
			}

			xml = "<hoge xmlns='urn:foo' />";
			xvr = PrepareXmlReader (xml);
			xvr.Schemas.Add (schema);
			try {
				xvr.Read ();
				Assert.Fail ("Element in different namespace is incorrectly allowed.");
			} catch (XmlSchemaException) {
			}
		}

        internal void Add(XmlDocument schemaDoc, XmlSchema schema, string typeName, string namespaceUri)
        {
            XmlSchemaSimpleType simpleType = schema.SchemaTypes[new XmlQualifiedName(typeName, namespaceUri)] as XmlSchemaSimpleType;
            XmlSchemaSimpleTypeRestriction typeRestriction = simpleType.Content as XmlSchemaSimpleTypeRestriction;
            XmlSchemaPatternFacet pattern = typeRestriction.Facets[0] as XmlSchemaPatternFacet;
            Regex re = new Regex(pattern.Value);

            XmlNodeList attributeNameNodes = schemaDoc.SelectNodes("//*[@type='" + typeName + "']/@name");
            for (int i = 0; i < attributeNameNodes.Count; i++)
            {
                string attrName = attributeNameNodes.Item(i).Value;
                if (RegexForAttrName[attrName] != null)
                {
                    continue;
                }
                else
                {
                    RegexForAttrName[attrName] = re;
                    if (XPathPredicateOfAttributes == null)
                    {
                        XPathPredicateOfAttributes = "";
                    }
                    else
                    {
                        XPathPredicateOfAttributes += " or ";
                    }
                    XPathPredicateOfAttributes += "local-name() = '" + attrName + "'";
                }
            }
        }

		public static void ValidateSpecification(XmlElement containingNode, XmlSchema schema)
		{
			// We must parse the XML to get the schema validation to work.  So, we write
			// the xml out to a string, and read it back in with Schema Validation enabled
			var sw = new StringWriter();

			var xmlWriterSettings = new XmlWriterSettings
			{
				Encoding = Encoding.UTF8,
				ConformanceLevel = ConformanceLevel.Fragment,
				Indent = false,
				NewLineOnAttributes = false,
				IndentChars = ""
			};

			var xmlWriter = XmlWriter.Create(sw, xmlWriterSettings);
			foreach (XmlNode node in containingNode.ChildNodes)
				node.WriteTo(xmlWriter);
			xmlWriter.Close();

			var xmlReaderSettings = new XmlReaderSettings
			{
				ValidationType = ValidationType.Schema,
				ConformanceLevel = ConformanceLevel.Fragment,
				Schemas = new XmlSchemaSet()
			};
			xmlReaderSettings.Schemas.Add(schema);

			var xmlReader = XmlTextReader.Create(new StringReader(sw.ToString()), xmlReaderSettings);
			while (xmlReader.Read()) ;
			xmlReader.Close();
		}

        /// <summary>Called when extension shall processs generated CodeDOM</summary>
        /// <param name="code">Object tree representing generated CodeDOM</param>
        /// <param name="schema">Input XML schema</param>
        /// <param name="provider">CodeDOM provider (the language)</param>
        /// <version version="1.5.3">Added documentation</version>
        /// <version version="1.5.3">Parameter <c>Provider</c> renamed to <c>provider</c></version>
        public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider provider)
        {
            // Copy as we will be adding types.
            CodeTypeDeclaration[] types =
                new CodeTypeDeclaration[code.Types.Count];
            code.Types.CopyTo(types, 0);

            foreach (CodeTypeDeclaration type in types) {
                if (type.IsClass || type.IsStruct) {
                    foreach (CodeTypeMember member in type.Members) {
                        if (member is CodeMemberField && ((CodeMemberField)member).Type.ArrayElementType != null) {
                            CodeMemberField field = (CodeMemberField)member;
                            // Change field type to collection.
                            field.Type = GetCollection(field.Type.ArrayElementType);
                            field.InitExpression = new CodeObjectCreateExpression(field.Type);
                            if (field.Name.EndsWith("Field"))
                                field.Comments.Add(new CodeCommentStatement(string.Format("<summary>Contains value of the <see cref='{0}'/> property</summary>", field.Name.Substring(0, field.Name.Length - "field".Length)), true));
                        } else if (member is CodeMemberProperty && ((CodeMemberProperty)member).Type.ArrayElementType != null) {
                            CodeMemberProperty Property = (CodeMemberProperty)member;
                            Property.Type = GetCollection(Property.Type.ArrayElementType);
                            Property.HasSet = false;
                        }
                    }
                }
            }
        }

        private void addElements(XmlSchema schema, string targetNamespaceUri)
        {
            debug("adding elements: " + schema.Elements.Count);
            debug("adding elements items: " + schema.Items.Count);

            foreach (XmlSchemaObject item in schema.Items)
            {
                var element = item as XmlSchemaElement;
                if (element != null && element.SchemaType is XmlSchemaComplexType)
                {
                    processComplexType(targetNamespaceUri, element.SchemaType as XmlSchemaComplexType, element.Name, Elements);
                }

            }
            foreach (XmlSchemaElement element in schema.Elements.Values)
            {
                if (element.SchemaType is XmlSchemaComplexType)
                {
                    processComplexType(targetNamespaceUri, element.SchemaType as XmlSchemaComplexType, element.Name, Elements);
                }
            }

            debug("Elements Found: " + Elements.Count);
            foreach (var elems in Elements)
            {
                debug("Elem: " + elems.Key + ":" + elems.Value.Name);
                debug(string.Join(", ", elems.Value.Properties.Select(_ => _.Name + ":" + _.Type).ToArray()));
            }
        }

 private string GetXml(XmlSchema schema)
 {
     XmlDocument xmlDoc = new XmlDocument();
     xmlDoc.LoadXml(SerializeObjectToXml(schema));
     return @"<?xml version=""1.0"" encoding=""utf-8""?>"
         + xmlDoc.DocumentElement.OuterXml;
 }

 internal SchemaObjectInfo(XmlSchemaType type, XmlSchemaElement element, XmlSchema schema, List<XmlSchemaType> knownTypes)
 {
     this.type = type;
     this.element = element;
     this.schema = schema;
     this.knownTypes = knownTypes;
 }

 internal static void AddElementForm(XmlSchemaElement element, XmlSchema schema)
 {
     if (schema.ElementFormDefault != XmlSchemaForm.Qualified)
     {
         element.Form = XmlSchemaForm.Qualified;
     }
 }

        /// <summary>
        ///  TODO: Create new XmlSchema instead of DeepCopy
        /// </summary>
        /// <param name="templateSchema">Arbitrary maindoc schema used as a template for our new base class schema</param>
        /// <param name="sharedElementCount">Number of elements that shoud be copied over to the new base class schema complex type</param>
        /// <returns></returns>
        private static XmlSchema CreateAbstractBaseSchemaFromMaindocSchema(XmlSchema templateSchema, int sharedElementCount)
        {
            XmlSchema abstractBaseSchema = DeepCopy(templateSchema);
            var abstractBaseElement = abstractBaseSchema.Items.OfType<XmlSchemaElement>().Single();          // Single. There can only be one
            var abstractBaseComplexType = abstractBaseSchema.Items.OfType<XmlSchemaComplexType>().Single();  // Christopher Lambert again

            // overwrite template props
            abstractBaseSchema.TargetNamespace = abstractBaseSchema.TargetNamespace.Replace(abstractBaseElement.Name, Constants.abstractBaseSchemaName);
            abstractBaseSchema.Namespaces.Add("", abstractBaseSchema.TargetNamespace);
            abstractBaseSchema.SourceUri = templateSchema.SourceUri.Replace(abstractBaseElement.Name, Constants.abstractBaseSchemaName);

            abstractBaseComplexType.IsAbstract = true;
            abstractBaseComplexType.Annotation.Items.Clear();
            XmlSchemaDocumentation doc = new XmlSchemaDocumentation();
            var nodeCreaterDoc = new XmlDocument();
            doc.Markup = new XmlNode[] { nodeCreaterDoc.CreateTextNode("This is a custom generated class that holds all the props/fields common to all UBL maindocs."),
                                         nodeCreaterDoc.CreateTextNode("You won't find a matching xsd file where it originates from.") };
            abstractBaseComplexType.Annotation.Items.Add(doc);
            abstractBaseComplexType.Name = Constants.abstractBaseSchemaComplexTypeName;

            // remove non-shared tailing elements.
            XmlSchemaObjectCollection elementCollection = (abstractBaseComplexType.Particle as XmlSchemaSequence).Items;
            while (sharedElementCount < elementCollection.Count) elementCollection.RemoveAt(sharedElementCount);

            abstractBaseElement.Name = Constants.abstarctBaseSchemaElementName;
            abstractBaseElement.SchemaTypeName = new XmlQualifiedName(Constants.abstractBaseSchemaComplexTypeName, abstractBaseSchema.TargetNamespace);

            // Don't need schemaLocation for loaded schemas. Will generate schemasetcompile warnings if not removed
            foreach (var baseSchemaImports in abstractBaseSchema.Includes.OfType<XmlSchemaImport>()) baseSchemaImports.SchemaLocation = null;

            return abstractBaseSchema;
        }