C# XDocument.Validate方法代码示例

        public string GetXml(bool validate)
        {
            XNamespace ns = "http://sd.ic.gc.ca/SLDR_Schema_Definition_en";

            var spectrum_licences = getLicences();

            XDocument doc = new XDocument(new XElement("spectrum_licence_data_registry", spectrum_licences));

            foreach (XElement e in doc.Root.DescendantsAndSelf())
            {
                if (e.Name.Namespace == "")
                    e.Name = ns + e.Name.LocalName;
            }

            var errors = new StringBuilder();

            if (validate)
            {
                XmlSchemaSet set = new XmlSchemaSet();
                var schema = getMainSchema();
                set.Add(null, schema);

                doc.Validate(set, (sender, args) => { errors.AppendLine(args.Message); });
            }

            //return errors.Length > 0 ? errors.ToString() : doc.ToString();
            var  result = errors.Length > 0 ? "Validation Errors: " + errors.ToString() : getDocumentAsString(doc);
            return result;
        }

        public List<EndpointInstance> Parse(XDocument document)
        {
            document.Validate(schema, null, true);

            var root = document.Root;
            var endpointElements = root.Descendants("endpoint");

            var instances = new List<EndpointInstance>();

            foreach (var e in endpointElements)
            {
                var endpointName = e.Attribute("name").Value;

                foreach (var i in e.Descendants("instance"))
                {
                    var discriminatorAttribute = i.Attribute("discriminator");
                    var discriminator = discriminatorAttribute?.Value;

                    var properties = i.Attributes().Where(a => a.Name != "discriminator");
                    var propertyDictionary = properties.ToDictionary(a => a.Name.LocalName, a => a.Value);

                    instances.Add(new EndpointInstance(endpointName, discriminator, propertyDictionary));
                }
            }

            return instances;
        }

        public DDEX(XDocument doc, bool verifySchema = false)
        {
            if (verifySchema)
                doc.Validate(DDEXSchema.GetDdexSchema(), null);

            Root = new NewReleaseMessage(doc.Root);
        }

    private static void Validate(XDocument doc, XmlSchemaSet xmlScheme)
    {
        bool notValidated = false;
        doc.Validate(xmlScheme, (eventObject, eventHandler) => { notValidated = true; }, false);

        Console.WriteLine(notValidated ? "Not Validated" : "Validated");
    }

        internal static bool IsValidMessage(XDocument doc, XDocument schema)
        {
            var schemas = new XmlSchemaSet();

            schemas.Add("http://www.SDMX.org/resources/SDMXML/schemas/v2_0/message",
                GetPath("lib\\SDMXMessage.xsd"));


            if (schema != null)
            {
                using (var reader = schema.CreateReader())
                {
                    schemas.Add(null, reader);
                }
            }

            bool isValid = true;

            doc.Validate(schemas, (s, args) =>
            {
                isValid = false;
                if (args.Severity == XmlSeverityType.Warning)

                    Console.WriteLine("\tWarning: " + args.Message);
                else
                    Console.WriteLine("\tError: " + args.Message);
            });

            return isValid;
        }

 private static void ValidateSchema(XDocument doc, XmlSchemaSet schema, string file)
 {
     doc.Validate(schema, (obj, ev) =>
     {
         Console.WriteLine("{0} --> {1}", file, ev.Message);
     });
 }

 private static void ValidateSchema(XDocument doc, XmlSchemaSet schema, string file)
 {
     doc.Validate(schema, (o, e) =>
     {
         Console.WriteLine("Not valid schema in file \"{0}\"\nException: {1}", file, e.Message);
     });
 }

 public static XDocument Normalize(XDocument source, XmlSchemaSet schema)
 {
     bool havePSVI = false;
     // validate, throw errors, add PSVI information
     if (schema != null)
     {
         source.Validate(schema, null, true);
         havePSVI = true;
     }
     return new XDocument(
         source.Declaration,
         source.Nodes().Select(n =>
         {
             // Remove comments, processing instructions, and text nodes that are
             // children of XDocument.  Only white space text nodes are allowed as
             // children of a document, so we can remove all text nodes.
             if (n is XComment || n is XProcessingInstruction || n is XText)
                 return null;
             XElement e = n as XElement;
             if (e != null)
                 return NormalizeElement(e, havePSVI);
             return n;
         }
         )
     );
 }

        /// <summary>
        /// Validates Xml against the configured schema and outs validation erros if any
        /// </summary>
        /// <param name="xmlDoc"></param>
        /// <param name="validationErrors"></param>
        /// <returns></returns>
        public bool Validate(XDocument xmlDoc, out string validationErrors)
        {

            validationErrors = null;

            //This will contain the xml schema
            var schemas = new XmlSchemaSet();

            //Add the schema, targetNamespace not specified
            schemas.Add(_xmlNamespace, XmlReader.Create(new StringReader(_xsdDoc)));

            //Variable to check if there are errors
            var hasValidationErrors = false;
            string xmlValidationErrorMessage = null;
            //Validate the xml against the schema
            xmlDoc.Validate(schemas, (sender, eventArgs) =>
                                         {
                                             hasValidationErrors = true;
                                             xmlValidationErrorMessage = eventArgs.Message;
                                         });

            validationErrors = xmlValidationErrorMessage;

            // validation fails if validation errors
            return !hasValidationErrors;

        }

 private static void PrintValidationResult(XDocument doc, XmlSchemaSet schema, string file)
 {
     doc.Validate(schema, (obj, ev) =>
     {
         Console.WriteLine("* {0} * {1}",file, ev.Message);
     });
 }

 private static void PrintValidationResult(XDocument doc, XmlSchemaSet schema, string file)
 {
     doc.Validate(schema, (obj, ev) =>
     {
         Console.WriteLine("!!! SCHEME VALIDATION ERROR IN FILE ---> {0} !!! {1}", file, ev.Message);
     });
 }

        public void ValidateSave()
        {
            WorldEntity world = createTestWorld();

            XElement xElement = WorldTransformer.Instance.ToXElement(world, TransformerSettings.WorldNamespace + "World");

            xElement.Save("unittestsave.xml", SaveOptions.OmitDuplicateNamespaces);

            XmlSchemaSet schemaSet = new XmlSchemaSet();

            schemaSet.Add(null, "WorldSchema1.xsd");

            XDocument xDocument = new XDocument(xElement);
            xDocument.AddAnnotation(SaveOptions.OmitDuplicateNamespaces);
            xDocument.Save("unittest2.xml", SaveOptions.OmitDuplicateNamespaces);

            XElement x1 = new XElement(TransformerSettings.WorldNamespace + "Outer");
            x1.Add(new XElement(TransformerSettings.WorldNamespace + "Inner"));
            x1.Save("unittest3.xml", SaveOptions.OmitDuplicateNamespaces);
            string val = "";
            xDocument.Validate(schemaSet, (o, vea) => {
                val += o.GetType().Name + "\n";
                val += vea.Message + "\n";
            }, true);

            Assert.AreEqual("", val);
        }

 private static void ValidateXml(XDocument document, XmlSchemaSet schema)
 {
     document.Validate(schema, (obj, ev) =>
         {
             Console.WriteLine("{0}", ev.Message);
         });
 }

        public bool IsValid(XDocument doc, XDocument schema, string xmlns = "")
        {
            var isValid = true;

            if (string.IsNullOrEmpty(xmlns))
            {
                xmlns = GetXmlnsFromSchema(schema);
            }

            // 1. Verify that the document has a namespace
            if (!string.IsNullOrEmpty(xmlns) && string.IsNullOrEmpty(GetXmlnsFromDocument(doc)))
            {
                return false;
            }

            // 2. Validate against schema
            var schemas = new XmlSchemaSet();
            schemas.Add(xmlns, XmlReader.Create(new StringReader(schema.ToString())));
            doc.Validate(schemas, (sender, args) =>
                                      {
                                          isValid = false;
                                      }, true);

            return isValid;
        }

		public bool IsValidTwiML(XDocument doc)
		{
			Console.Write(doc.ToString());

			var valid = true;
			doc.Validate(Schemas, (o, e) => { valid = false; });
			return valid;
		}