public BaseCodeGenerator(Stream sourceXML) { XmlDocument doc = new XmlDocument(); using (sourceXML) { doc.Load(sourceXML); } MemoryStream ms = new MemoryStream(); doc.Save(ms); ms.Position = 0; using (XmlTextReader r = new XmlTextReader(ms)) { XmlValidatingReader v = new XmlValidatingReader(r); v.ValidationType = ValidationType.Schema; v.ValidationEventHandler += new ValidationEventHandler(v_ValidationEventHandler); while (v.Read()) { } v.Close(); } if (m_errors) throw new InvalidDataException("The Xml input did not match the schema"); Parse(doc); }
protected void Page_Load(object sender, EventArgs e) { string xmlFile = Server.MapPath("~/Customers1.xml"); string xsdFile = Server.MapPath("~/Customers.xsd"); XmlTextReader textReader = new XmlTextReader(xmlFile); XmlValidatingReader validatingReader = new XmlValidatingReader(textReader); validatingReader.Schemas.Add(null, xsdFile); validatingReader.ValidationType = ValidationType.Schema; validatingReader.ValidationEventHandler += new ValidationEventHandler(validatingReader_ValidationEventHandler); while (validatingReader.Read()) { if (validatingReader.NodeType == XmlNodeType.Element) { if (validatingReader.SchemaType is XmlSchemaComplexType) { XmlSchemaComplexType complexType = (XmlSchemaComplexType)validatingReader.SchemaType; Response.Write(validatingReader.Name + " " + complexType.Name); } else { object innerText = validatingReader.ReadTypedValue(); Response.Write(validatingReader.Name + " : " + innerText.ToString() + " <br />"); } } } validatingReader.Close(); }
/*Validar archivo XML Contra Esquema XSD*/ public void Validar(string rutaFicheroXml) { var r = new XmlTextReader(rutaFicheroXml); var v = new XmlValidatingReader(r) {ValidationType = ValidationType.Schema}; v.ValidationEventHandler += ValidarControlEventos; var procesarXml = new ConvertirXmlEnTexo(); procesarXml.ProcesarArchivo(rutaFicheroXml/*,@"D:\pruebas.txt"*/); try { while (v.Read()) { } // Comprobar si el documento es válido o no. //return _isValid ? "true" : "false"; // var procesarXml = new ConvertirXmlEnTexo(); // procesarXml.ProcesarArchivo(rutaFicheroXml/*,@"D:\pruebas.txt"*/); v.Close(); } catch (Exception e) { //ValidarControlEventos(null, null); // _isValid = false; // MessageBox.Show("Evento de validación\r\n" + e.Message, @"Validacion de XML", // MessageBoxButtons.OK, MessageBoxIcon.Asterisk); ////v.ValidationEventHandler += new ValidationEventHandler(ValidarControlEventos); //return "true"; } }
/// <summary> /// Valida se um Xml está seguindo de acordo um Schema /// </summary> /// <param name="arquivoXml">Arquivo Xml</param> /// <param name="arquivoSchema">Arquivo de Schema</param> /// <returns>True se estiver certo, Erro se estiver errado</returns> public void ValidaSchema(String arquivoXml, String arquivoSchema) { //Seleciona o arquivo de schema de acordo com o schema informado //arquivoSchema = Bll.Util.ContentFolderSchemaValidacao + "\\" + arquivoSchema; //Verifica se o arquivo de XML foi encontrado. if (!File.Exists(arquivoXml)) throw new Exception("Arquivo de XML informado: \"" + arquivoXml + "\" não encontrado."); //Verifica se o arquivo de schema foi encontrado. if (!File.Exists(arquivoSchema)) throw new Exception("Arquivo de schema: \"" + arquivoSchema + "\" não encontrado."); // Cria um novo XMLValidatingReader var reader = new XmlValidatingReader(new XmlTextReader(new StreamReader(arquivoXml))); // Cria um schemacollection var schemaCollection = new XmlSchemaCollection(); //Adiciona o XSD e o namespace schemaCollection.Add("http://www.portalfiscal.inf.br/nfe", arquivoSchema); // Adiciona o schema ao ValidatingReader reader.Schemas.Add(schemaCollection); //Evento que retorna a mensagem de validacao reader.ValidationEventHandler += Reader_ValidationEventHandler; //Percorre o XML while (reader.Read()) { } reader.Close(); //Fecha o arquivo. //O Resultado é preenchido no reader_ValidationEventHandler if (validarResultado != "") { throw new Exception(validarResultado); } }
/// <summary> /// Validate XML Format /// </summary> /// <param name="text">XML string</param> public static bool IsValidXML(string text) { bool errored; byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(text); MemoryStream stream = new MemoryStream(byteArray); XmlTextReader xmlr = new XmlTextReader(stream); XmlValidatingReader reader = new XmlValidatingReader(xmlr); try { while (reader.Read()) { ; } errored = false; } catch { errored = true; } finally { reader.Close(); } return !errored; }
public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler) { WebReferenceOptions options; XmlValidatingReader reader = new XmlValidatingReader(xmlReader) { ValidationType = ValidationType.Schema }; if (validationEventHandler != null) { reader.ValidationEventHandler += validationEventHandler; } else { reader.ValidationEventHandler += new ValidationEventHandler(WebReferenceOptions.SchemaValidationHandler); } reader.Schemas.Add(Schema); webReferenceOptionsSerializer serializer = new webReferenceOptionsSerializer(); try { options = (WebReferenceOptions) serializer.Deserialize(reader); } catch (Exception exception) { throw exception; } finally { reader.Close(); } return options; }
public GReader(string path) { document = new XmlDocument (); try { XmlTextReader textreader = new XmlTextReader (path); XmlValidatingReader vreader = new XmlValidatingReader (textreader); // Set the validation event handler vreader.ValidationEventHandler += new ValidationEventHandler (ValidationCallBack); // Load the XML to Document node. document.Load (textreader); Console.WriteLine ("Validation finished. Validation {0}", (m_success==true ? "successful!" : "failed.")); //Close the reader. vreader.Close(); } catch (FileNotFoundException e) { Console.WriteLine ("Error: {0} not found.", e.FileName); Environment.Exit (1); } catch (DirectoryNotFoundException) { Console.WriteLine ("Error: {0} not found.", path); Environment.Exit (1); } catch (XmlException) { Console.WriteLine ("Error: {0} is not well-formed xml.", path); Environment.Exit (1); } }
public static T_SeamateItems ParseItemsConfiguration(String configPath) { TextReader tr = null; XmlTextReader xml = null; XmlValidatingReader validate = null; xml = new XmlTextReader(configPath); validate = new XmlValidatingReader(xml); validate.ValidationEventHandler += new ValidationEventHandler(xsdValidationHandler); while (validate.Read()) { } validate.Close(); try { tr = new StreamReader(configPath); XmlSerializer serializer = new XmlSerializer(typeof(T_SeamateItems)); T_SeamateItems config = (T_SeamateItems)serializer.Deserialize(tr); tr.Close(); return config; } catch (Exception ex) { if (tr != null) { tr.Close(); } throw new Exception("Unable to read configuration file: " + configPath, ex); } return null; }
private void ParseDocumentType(XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver) { this.doc = dtNode.OwnerDocument; XmlNameTable nt = this.doc.NameTable; XmlNamespaceManager mgr = new XmlNamespaceManager(nt); XmlParserContext pc = new XmlParserContext(nt, mgr, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, this.doc.BaseURI, String.Empty, XmlSpace.None ); XmlValidatingReader vr = new XmlValidatingReader("", XmlNodeType.Element, pc); vr.Namespaces = dtNode.ParseWithNamespaces; if (bUseResolver) { vr.XmlResolver = resolver; } vr.ValidationType = ValidationType.None; vr.Read(); LoadDocumentType(vr, dtNode); vr.Close(); }
static void Main(string[] args) { if (args.Length != 4) { Console.WriteLine("Invalid parameter count. Exiting..."); return; } string xmlFile = args[0]; string xdsFile = args[1]; string xdsNamespace = args[2]; string outputFile = args[3]; try { XmlSchemaCollection cache = new XmlSchemaCollection(); cache.Add(xdsNamespace, xdsFile); XmlTextReader r = new XmlTextReader(xmlFile); XmlValidatingReader v = new XmlValidatingReader(r); v.Schemas.Add(cache); v.ValidationType = ValidationType.Schema; v.ValidationEventHandler += new ValidationEventHandler(MyValidationEventHandler); while (v.Read()) { } // look for validation errors v.Close(); } catch (Exception e) { encounteredFatalError = true; fatalError = e; } StreamWriter file = new StreamWriter(outputFile); if (isValid && !encounteredFatalError) file.WriteLine("PASSED: Document is valid"); else file.WriteLine("FAILED: Document is invalid"); // Printing foreach (string entry in list) { file.WriteLine(entry); } if (encounteredFatalError) { file.WriteLine("Error: a FATAL error has occured " + "while reading the file.\r\n" + fatalError.ToString()); } file.Close(); }
static void Main(string[] args) { XmlTextReader r = new XmlTextReader(@"..\..\XMLFile1.xml"); XmlValidatingReader v = new XmlValidatingReader(r); v.ValidationType = ValidationType.Schema; v.ValidationEventHandler += new ValidationEventHandler(MyValidationEventHandler); while(v.Read()) { // Can add code here to process the content. } v.Close(); // Check whether the document is valid or invalid. if(m_isValid) { Console.WriteLine("Document is valid"); } else { Console.WriteLine("Document is invalid"); } /* XmlTextWriter xtw = new XmlTextWriter(new StreamWriter("test1.xml")); xtw.WriteStartDocument(true); xtw.WriteStartElement("MapVals"); xtw.WriteStartElement("MapValKey1"); xtw.WriteAttributeString("val1","a"); xtw.WriteAttributeString("val2","b"); xtw.WriteEndElement(); xtw.WriteStartElement("MapValKey2"); xtw.WriteAttributeString("val1","qf"); xtw.WriteAttributeString("val2","xt"); xtw.WriteEndElement(); xtw.WriteStartElement("MapValKey3"); xtw.WriteAttributeString("val1","wwu"); xtw.WriteAttributeString("val2","verble"); xtw.WriteEndElement(); xtw.WriteEndElement(); xtw.WriteEndDocument(); xtw.Close(); */ }
/// <summary> /// /// </summary> /// /// <param name="directory"></param> /// <param name="ruleName"></param> /// /// <returns></returns> /// public static List<RuleItem> Read(string directory, string ruleName) { List<RuleItem> result = new List<RuleItem>(); foreach (string file in Directory.GetFiles(directory, "*.xml")) { XmlValidatingReader reader = null; try { XmlDocument xml = new XmlDocument(); reader = new XmlValidatingReader(new XmlTextReader(file)); reader.ValidationType = ValidationType.None; xml.Load(reader); reader.Close(); XmlElement rootNode = (XmlElement) xml.SelectSingleNode("/applicationlogic"); XmlNodeList ruleNodes = rootNode.SelectNodes(ruleName); // extract each rule. foreach (XmlElement ruleSource in ruleNodes) { RuleItem rule = new RuleItem(ruleName, xml, ruleSource, directory, file); result.Add(rule); } } catch (Exception exception) { log.Warn(string.Format("Failed to read rules file: {0}.", file), exception); } finally { if (reader != null && reader.ReadState != ReadState.Closed) { reader.Close(); } } } return result; }
public XPathDocument (string uri, XmlSpace space) { XmlValidatingReader vr = null; try { vr = new XmlValidatingReader (new XmlTextReader (uri)); vr.ValidationType = ValidationType.None; Initialize (vr, space); } finally { if (vr != null) vr.Close (); } }
public void Validate(string strXMLDoc) { try { // Declare local objects XmlTextReader tr = null; XmlSchemaCollection xsc = null; XmlValidatingReader vr = null; // Text reader object tr = new XmlTextReader(Application.StartupPath + @"\BDOCImportSchema.xsd"); xsc = new XmlSchemaCollection(); xsc.Add(null, tr); // XML validator object vr = new XmlValidatingReader(strXMLDoc, XmlNodeType.Document, null); vr.Schemas.Add(xsc); // Add validation event handler vr.ValidationType = ValidationType.Schema; vr.ValidationEventHandler += new ValidationEventHandler(ValidationHandler); // Validate XML data while (vr.Read()) ; vr.Close(); // Raise exception, if XML validation fails if (ErrorsCount > 0) { throw new Exception(ErrorMessage); } // XML Validation succeeded Console.WriteLine("XML validation succeeded.\r\n"); } catch (Exception error) { // XML Validation failed Console.WriteLine("XML validation failed." + "\r\n" + "Error Message: " + error.Message); throw new Exception("Error in XSD verification:\r\n" + error.Message); } }
private void Render(Stream stream, string xslResourceId, string xslResourceDefault, XsltArgumentList args) { XslTransform xslt = new XslTransform(); xslt.Load(new XmlTextReader(Assembly .GetExecutingAssembly() .GetManifestResourceStream(Parameter.GetString(xslResourceId, xslResourceDefault))), null, null); XmlValidatingReader reader = new XmlValidatingReader(new XmlTextReader(ruleFileURI)); reader.ValidationType = ValidationType.Schema; reader.Schemas.Add(XmlSchema.Read(Assembly .GetExecutingAssembly() .GetManifestResourceStream(Parameter.GetString("xbusinessrules.xsd", "resource.xBusinessRules.xsd")), null)); xslt.Transform(new XPathDocument(reader), args, stream, null); reader.Close(); }
static void ValidateFile (string file) { IsValid = true; try { reader = new XmlValidatingReader (new XmlTextReader (file)); reader.ValidationType = ValidationType.Schema; reader.Schemas.Add (schema); reader.ValidationEventHandler += new ValidationEventHandler (OnValidationEvent); while (reader.Read ()) { // do nothing } reader.Close (); } catch (Exception e) { Console.WriteLine ("mdvalidator: error: " + e.ToString ()); } }
public bool ValidateXMLFile() { XmlTextReader objXmlTextReader =null; XmlValidatingReader objXmlValidatingReader=null ; try { //creating a text reader for the XML file already picked by the //overloaded constructor above viz..clsSchemaValidator objXmlTextReader = new XmlTextReader(m_sXMLFileName); //creating a validating reader for that objXmlTextReader just created objXmlValidatingReader = new XmlValidatingReader (objXmlTextReader); //For validation we are adding the schema collection in //ValidatingReaders Schema collection. objXmlValidatingReader.Schemas.Add (m_objXmlSchemaCollection); //Attaching the event handler now in case of failures objXmlValidatingReader.ValidationEventHandler += new ValidationEventHandler (ValidationFailed); //Actually validating the data in the XML file with a empty while. //which would fire the event ValidationEventHandler and invoke //our ValidationFailed function while (objXmlValidatingReader.Read()) { } //Note:- If any issue is faced in the above while it will invoke ValidationFailed //which will in turn set the module level m_bIsFailure boolean variable to false //thus returning true as a signal to the calling function that the ValidateXMLFile //function(this function) has encountered failure return m_bIsFailure; } catch (Exception ex) { MessageBox.Show ("Exception : " + ex.Message); return true; } finally { // close the readers, no matter what. objXmlValidatingReader.Close (); objXmlTextReader.Close (); } }
/* Takes a type name, and a valid example of that type, Creates a schema consisting of a single element of that type, and validates a bit of xml containing the valid value, with whitespace against that schema. FIXME: Really we want to test the value of whitespace more directly that by creating a schema then parsing a string. */ public void WhiteSpaceTest(string type, string valid) { passed = true; XmlSchema schema = new XmlSchema(); schema.TargetNamespace= "http://example.com/testCase"; XmlSchemaElement element = new XmlSchemaElement(); element.Name = "a"; element.SchemaTypeName = new XmlQualifiedName(type, "http://www.w3.org/2001/XMLSchema"); schema.Items.Add(element); schema.Compile(new ValidationEventHandler(ValidationCallbackOne)); XmlValidatingReader vr = new XmlValidatingReader(new XmlTextReader(new StringReader("<a xmlns='http://example.com/testCase'>\n\n"+valid+"\n\n</a>" ))); vr.Schemas.Add(schema); vr.ValidationType = ValidationType.Schema; // vr.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne); while(vr.Read()) { }; vr.Close(); Assert(type + " doesn't collapse whitespace: " + (errorInfo != null ? errorInfo.Message : null), passed); }
public bool validateXml(String infile) { //First we create the xmltextreader XmlTextReader xmlr = new XmlTextReader(infile); //We pass the xmltextreader into the xmlvalidatingreader //'This will validate the xml doc with the schema file //'NOTE the xml file it self points to the schema file XmlValidatingReader xmlvread = new XmlValidatingReader(xmlr); // // // ' Set the validation event handler xmlvread.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack); m_Success = true; //'make sure to reset the success var // // //' Read XML data while (xmlvread.Read()) { } //'Close the reader. xmlvread.Close(); //'The validationeventhandler is the only thing that would set m_Success to false return m_Success; }
private static bool isValid = true; // If a validation error occurs, // set this flag to false in the // validation event handler. static void Main(string[] args) { XmlTextReader r = new XmlTextReader(@"..\..\GenKeyIDList.xml"); XmlValidatingReader v = new XmlValidatingReader(r); v.ValidationType = ValidationType.Schema; v.ValidationEventHandler += new ValidationEventHandler(MyValidationEventHandler); while (v.Read()) { // Can add code here to process the content. Console.WriteLine(v.LocalName); if (v.LocalName == "GenericKeyIDList") { if(v.IsStartElement()) { v.MoveToFirstAttribute(); v.ReadAttributeValue(); Console.WriteLine(" " + v.ReadContentAsString()); } } } v.Close(); // Check whether the document is valid or invalid. if (isValid) { Console.WriteLine("Document is valid"); } else { Console.WriteLine("Document is invalid"); } }
SchemeNode CreateSchemeNode(XmlTextReader reader, bool userList) { try { XmlValidatingReader validatingReader = new XmlValidatingReader(reader); Stream schemaStream = typeof(SyntaxMode).Assembly.GetManifestResourceStream("Mode.xsd"); validatingReader.Schemas.Add("", new XmlTextReader(schemaStream)); validatingReader.ValidationType = ValidationType.Schema; validatingReader.ValidationEventHandler += new ValidationEventHandler(ValidationHandler); XmlDocument doc = new XmlDocument(); doc.Load(validatingReader); if (errors.Count != 0) { ReportErrors(); validatingReader.Close(); return null; } else { validatingReader.Close(); return new SchemeNode(doc.DocumentElement, userList); } } catch (Exception e) { MessageService.ShowError(e, "${res:Dialog.Options.TextEditorOptions.EditHighlighting.LoadError}"); return null; } finally { reader.Close(); } }
/// <summary> /// Load and validate the mappings in the <see cref="XmlTextReader" /> against /// the nhibernate-mapping-2.0 schema, without adding them to the configuration. /// </summary> /// <remarks> /// This method is made public to be usable from the unit tests. It is not intended /// to be called by end users. /// </remarks> /// <param name="hbmReader">The XmlReader that contains the mapping.</param> /// <returns>Validated XmlDocument built from the XmlReader.</returns> public XmlDocument LoadMappingDocument( XmlTextReader hbmReader ) { XmlValidatingReader validatingReader = new XmlValidatingReader( hbmReader ); try { XmlDocument hbmDocument = new XmlDocument(); validatingReader.ValidationEventHandler += new ValidationEventHandler( ValidationHandler ); validatingReader.ValidationType = ValidationType.Schema; validatingReader.Schemas.Add( MappingSchemaCollection ); hbmDocument.Load( validatingReader ); return hbmDocument; } finally { validatingReader.Close(); } }
/// <summary> /// Configure NHibernate using the specified XmlTextReader. /// </summary> /// <param name="reader">The <see cref="XmlTextReader"/> that contains the Xml to configure NHibernate.</param> /// <returns>A Configuration object initialized with the file.</returns> /// <remarks> /// Calling Configure(XmlTextReader) will overwrite the values set in app.config or web.config /// </remarks> public Configuration Configure( XmlTextReader reader ) { if( reader == null ) { throw new HibernateException( "Could not configure NHibernate.", new ArgumentException( "A null value was passed in.", "reader" ) ); } XmlDocument doc = new XmlDocument(); XmlValidatingReader validatingReader = null; try { validatingReader = new XmlValidatingReader( reader ); validatingReader.ValidationType = ValidationType.Schema; validatingReader.Schemas.Add( CfgSchemaCollection ); doc.Load( validatingReader ); } catch( Exception e ) { log.Error( "Problem parsing configuration", e ); throw new HibernateException( "problem parsing configuration : " + e ); } finally { if( validatingReader != null ) { validatingReader.Close(); } } return DoConfigure( doc ); }
/// <summary> /// Initializes the task and verifies parameters. /// </summary> /// <param name="TaskNode">Node that contains the XML fragment used to define this task instance.</param> protected override void InitializeTask(XmlNode TaskNode) { XmlElement taskXml = (XmlElement) TaskNode.Clone(); // Expand all properties in the task and its child elements if (taskXml.ChildNodes != null) { ExpandPropertiesInNodes(taskXml.ChildNodes); if (taskXml.Attributes != null) { foreach (XmlAttribute attr in taskXml.Attributes) { attr.Value = Properties.ExpandProperties(attr.Value, Location); } } } // Get the [SchemaValidator(type)] attribute SchemaValidatorAttribute[] taskValidators = (SchemaValidatorAttribute[])GetType().GetCustomAttributes( typeof(SchemaValidatorAttribute), true); if (taskValidators.Length > 0) { SchemaValidatorAttribute taskValidator = taskValidators[0]; XmlSerializer taskSerializer = new XmlSerializer(taskValidator.ValidatorType); // get embedded schema resource stream Stream schemaStream = Assembly.GetExecutingAssembly().GetManifestResourceStream( taskValidator.ValidatorType.Namespace); // ensure schema resource was embedded if (schemaStream == null) { throw new BuildException(string.Format(CultureInfo.InvariantCulture, "Schema resource '{0}' could not be found.", taskValidator.ValidatorType.Namespace), Location); } // load schema resource XmlTextReader tr = new XmlTextReader( schemaStream, XmlNodeType.Element, null); // Add the schema to a schema collection XmlSchema schema = XmlSchema.Read(tr, null); XmlSchemaCollection schemas = new XmlSchemaCollection(); schemas.Add(schema); string xmlNamespace = (taskValidator.XmlNamespace != null ? taskValidator.XmlNamespace : GetType().FullName); // Create a namespace manager with the schema's namespace NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); nsmgr.AddNamespace(string.Empty, xmlNamespace); // Create a textreader containing just the Task's Node XmlParserContext ctx = new XmlParserContext( null, nsmgr, null, XmlSpace.None); taskXml.SetAttribute("xmlns", xmlNamespace); XmlTextReader textReader = new XmlTextReader(taskXml.OuterXml, XmlNodeType.Element, ctx); // Copy the node from the TextReader and indent it (for error // reporting, since NAnt does not retain formatting during a load) StringWriter stringWriter = new StringWriter(); XmlTextWriter textWriter = new XmlTextWriter(stringWriter); textWriter.Formatting = Formatting.Indented; textWriter.WriteNode(textReader, true); //textWriter.Close(); XmlTextReader formattedTextReader = new XmlTextReader( stringWriter.ToString(), XmlNodeType.Document, ctx); // Validate the Task's XML against its schema XmlValidatingReader validatingReader = new XmlValidatingReader( formattedTextReader); validatingReader.ValidationType = ValidationType.Schema; validatingReader.Schemas.Add(schemas); validatingReader.ValidationEventHandler += new ValidationEventHandler(Task_OnSchemaValidate); while (validatingReader.Read()) { // Read strictly for validation purposes } validatingReader.Close(); if (!_validated) { // Log any validation errors that have ocurred for (int i = 0; i < _validationExceptions.Count; i++) { BuildException ve = (BuildException) _validationExceptions[i]; if (i == _validationExceptions.Count - 1) { // If this is the last validation error, throw it throw ve; } Log(Level.Info, ve.Message); } } NameTable taskNameTable = new NameTable(); XmlNamespaceManager taskNSMgr = new XmlNamespaceManager(taskNameTable); taskNSMgr.AddNamespace(string.Empty, xmlNamespace); XmlParserContext context = new XmlParserContext( null, taskNSMgr, null, XmlSpace.None); XmlTextReader taskSchemaReader = new XmlTextReader( taskXml.OuterXml, XmlNodeType.Element, context); // Deserialize from the Task's XML to the schema wrapper object _schemaObject = taskSerializer.Deserialize(taskSchemaReader); } }
/// <summary> /// Validate the document against the standard WiX schema and any extensions. /// </summary> /// <param name="document">The xml document to validate.</param> private void ValidateDocument(XmlDocument document) { // if we haven't loaded the schemas yet, do that now if (null == this.schemas) { this.schemas = new XmlSchemaCollection(); // always add the WiX schema first this.schemas.Add(this.schema); // add all the extension schemas foreach (CompilerExtension compilerExtension in this.extensions.Values) { this.schemas.Add(compilerExtension.Schema); } } // write the document to a string for validation StringWriter xml = new StringWriter(CultureInfo.InvariantCulture); XmlTextWriter writer = null; try { writer = new XmlTextWriter(xml); document.WriteTo(writer); } finally { if (null != writer) { writer.Close(); } } // validate the xml string (and thus the document) SourceLineNumberCollection sourceLineNumbers = null; XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.None); XmlValidatingReader validatingReader = null; try { validatingReader = new XmlValidatingReader(xml.ToString(), XmlNodeType.Document, context); validatingReader.Schemas.Add(this.schemas); while (validatingReader.Read()) { if (XmlNodeType.ProcessingInstruction == validatingReader.NodeType && Preprocessor.LineNumberElementName == validatingReader.Name) { sourceLineNumbers = new SourceLineNumberCollection(validatingReader.Value); } } } catch (XmlSchemaException e) { string message = e.Message.Replace(String.Concat(this.schema.TargetNamespace, ":"), String.Empty); this.core.OnMessage(WixErrors.SchemaValidationFailed(sourceLineNumbers, message, e.LineNumber, e.LinePosition)); } finally { if (null != validatingReader) { validatingReader.Close(); } } }
private bool IsValidXml(string message) { if (Regex.Match(message, @"^<.*>").Success) { XmlValidatingReader reader = null; try { // validate xml reader = new XmlValidatingReader(message, XmlNodeType.Document, null); while (reader.Read()) { } // the xml is valid return true; } catch { return false; } finally { if (reader != null) { reader.Close(); } } } return false; }
static private XmlDocument OpenDocument( string IncludeFilePath ) { XmlValidatingReader reader = new XmlValidatingReader( new XmlTextReader( IncludeFilePath ) ); reader.ValidationType = ValidationType.None; reader.XmlResolver = null; XmlDocument doc = new XmlDocument(); doc.Load( reader ); reader.Close(); //make sure we close the reader before saving return doc; }
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="XmlSchema.Read2"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler) { XmlValidatingReader validatingReader = new XmlValidatingReader(xmlReader); validatingReader.ValidationType = ValidationType.Schema; if (validationEventHandler != null) { validatingReader.ValidationEventHandler += validationEventHandler; } else { validatingReader.ValidationEventHandler += new ValidationEventHandler(SchemaValidationHandler); } validatingReader.Schemas.Add(Schema); webReferenceOptionsSerializer ser = new webReferenceOptionsSerializer(); try { return (WebReferenceOptions)ser.Deserialize(validatingReader); } catch (Exception e) { throw e; } finally { validatingReader.Close(); } }
private void ValidateXmlIfNeeded(string xml) { if (validateXml) { // stream to validate using (StringReader stringReader = new StringReader(xml)) { XmlTextReader xmlr = new XmlTextReader(stringReader); XmlValidatingReader xmlvread = new XmlValidatingReader(xmlr); // Set the validation event handler xmlvread.ValidationEventHandler += new ValidationEventHandler(XmlValidationCallBack); // Read XML data while (xmlvread.Read()) { } //Close the reader. xmlvread.Close(); } } }
private void ParseDocumentType ( XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver ) { this.doc = dtNode.OwnerDocument; XmlNameTable nt = this.doc.NameTable; XmlNamespaceManager mgr = new XmlNamespaceManager( nt ); XmlParserContext pc = new XmlParserContext( nt, mgr, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, this.doc.BaseURI, String.Empty, XmlSpace.None ); XmlValidatingReader vr = new XmlValidatingReader( "", XmlNodeType.Element, pc ); vr.Namespaces = dtNode.ParseWithNamespaces; if ( bUseResolver ) vr.XmlResolver = resolver; vr.ValidationType = ValidationType.None; vr.Read(); LoadDocumentType( vr, dtNode ); vr.Close(); }
/// <SUMMARY> /// This method validates an xml string against an xml schema. /// </SUMMARY> /// <PARAM name="xml">StringReader containing xml</PARAM> /// <PARAM name="schemaNamespace">XML Schema Namespace</PARAM> /// <PARAM name="schemaUri">XML Schema Uri</PARAM> /// <RETURNS>bool</RETURNS> public bool ValidXmlDoc(StringReader xml, string schemaNamespace, string schemaUri) { // Continue? if (xml == null || schemaNamespace == null || schemaUri == null) { return false; } isValidXml = true; XmlValidatingReader vr; XmlTextReader tr; var schemaCol = new XmlSchemaCollection(); schemaCol.Add(schemaNamespace, schemaUri); try { // Read the xml. tr = new XmlTextReader(xml); // Create the validator. vr = new XmlValidatingReader(tr); // Set the validation tyep. vr.ValidationType = ValidationType.Auto; // Add the schema. if (schemaCol != null) { vr.Schemas.Add(schemaCol); } // Set the validation event handler. vr.ValidationEventHandler += ValidationCallBack; // Read the xml schema. while (vr.Read()) { } vr.Close(); return isValidXml; } catch (Exception ex) { ValidationError = ex.Message; return false; } finally { // Clean up... vr = null; tr = null; } }