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) {
}
}
/// <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 void ValidateSchema(string xml)
{
var schemaStream = typeof(HoptoadValidator).Assembly.GetManifestResourceStream("Tests.hoptoad_2_0.xsd");
var schema = XmlSchema.Read(schemaStream, (sender, args) => { });
var reader = new StringReader(xml);
var xmlReader = new XmlTextReader(reader);
#pragma warning disable 0618
var validator = new XmlValidatingReader(xmlReader);
#pragma warning restore 0618
var errorBuffer = new StringBuilder();
validator.ValidationEventHandler += (sender, args) => {
errorBuffer.AppendLine(args.Message);
};
validator.Schemas.Add(schema);
while (validator.Read())
{
}
if (errorBuffer.ToString().Length > 0)
Assert.Fail(errorBuffer.ToString());
}
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();
}
static void Main (string [] args)
{
string schemaFile = "bug.xsd";
XmlTextReader treader = new XmlTextReader (schemaFile);
XmlSchema sc = XmlSchema.Read (treader, null);
sc.Compile (null);
string page =
"<body xmlns=\"" + sc.TargetNamespace + "\">"
+ "<div>"
+ "</div>"
+ "</body>";
System.Xml.XmlTextReader reader = new XmlTextReader (new StringReader (page));
try {
XmlValidatingReader validator = new System.Xml.XmlValidatingReader (reader);
validator.Schemas.Add (sc);
validator.ValidationType = ValidationType.Schema;
validator.EntityHandling = EntityHandling.ExpandCharEntities;
while (validator.Read ()) {
}
} finally {
reader.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";
}
}
public void TestEmptySchema ()
{
string xml = "<root/>";
xvr = PrepareXmlReader (xml);
xvr.ValidationType = ValidationType.Schema;
xvr.Read (); // Is is missing schema component.
}
public void ShouldGenerateASchemaToValidateTestSubClassXml()
{
NetReflectorTypeTable table = new NetReflectorTypeTable
{
typeof (TestClass),
typeof (TestInnerClass),
typeof (TestSubClass)
};
XsdGenerator generator = new XsdGenerator(table);
XmlSchema schema = generator.Generate(true);
#if DEBUG
schema.Write(Console.Out);
#endif
string xmlToValidate = TestClass.GetXmlWithSubClass(DateTime.Today);
#if DEBUG
Console.Out.WriteLine("xmlToValidate = {0}", xmlToValidate);
#endif
XmlValidatingReader reader = new XmlValidatingReader(new XmlTextReader(new StringReader(xmlToValidate)));
reader.Schemas.Add(schema);
reader.ValidationType = ValidationType.Schema;
while (reader.Read()) {}
}
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;
}
public static void Validate(XmlReader reader)
{
XmlValidatingReader vr = new XmlValidatingReader(reader);
vr.ValidationType = ValidationType.Auto;
vr.ValidationEventHandler += new ValidationEventHandler(ValidationHandler);
while (vr.Read()){};
}
public string FilterFragment(string origHtmlFragment)
{
origHtmlFragment = CleanupHtml(origHtmlFragment);
// Remove duplicate ids because they are invalid but not an attack vector.
string htmlFragment = RemoveIds(origHtmlFragment);
// Resolve general entities to character entities so we don't have to use
// 2 XmlValidatingReaders - one with a DTD to resolve the general entities
// and one with the schema to validate the document.
htmlFragment = ResolveGeneralEntities(htmlFragment);
string page = @"<html xmlns=""" + FilterInfo.Schema.TargetNamespace + @"""><head><title>title</title></head>"
+ "<body>"
+ "<div>\n" + htmlFragment + "\n</div>"
+ "</body>"
+ "</html>";
XmlTextReader reader = new XmlTextReader(new StringReader(page));
try
{
XmlValidatingReader validator = new System.Xml.XmlValidatingReader(reader);
validator.ValidationEventHandler += new ValidationEventHandler(OnValidationError);
validator.Schemas.Add(FilterInfo.Schema);
validator.ValidationType = ValidationType.Schema;
validator.EntityHandling = EntityHandling.ExpandCharEntities;
while (validator.Read())
{
}
}
finally
{
reader.Close();
}
if (FilterInfo.UriAndStyleValidator != null)
{
reader = new XmlTextReader(new StringReader(page));
try
{
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.Load(reader);
FilterInfo.UriAndStyleValidator.Validate(doc);
}
finally
{
reader.Close();
}
}
return(origHtmlFragment);
}
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();
*/
}
private void Page_Load(object sender, System.EventArgs e)
{
XmlValidatingReader reader = null;
XmlSchemaCollection myschema = new XmlSchemaCollection();
ValidationEventHandler eventHandler = new ValidationEventHandler(ShowCompileErrors );
try
{
String xmlFrag = @"<?xml version='1.0' ?>
<item>
<xxx:price xmlns:xxx='xxx' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
xsi:schemaLocation='test.xsd'></xxx:price>
</item>";
/*"<author xmlns='urn:bookstore-schema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>" +
"<first-name>Herman</first-name>" +
"<last-name>Melville</last-name>" +
"</author>";*/
string xsd = @"<?xml version='1.0' encoding='UTF-8'?>
<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema' targetNamespace='xxx'>
<xsd:element name='price' type='xsd:integer' xsd:default='12'/>
</xsd:schema>";
//Create the XmlParserContext.
XmlParserContext context = new XmlParserContext(null, null, "", XmlSpace.None);
//Implement the reader.
reader = new XmlValidatingReader(xmlFrag, XmlNodeType.Element, context);
//Add the schema.
myschema.Add("xxx", new XmlTextReader(new StringReader(xsd)));
//Set the schema type and add the schema to the reader.
reader.ValidationType = ValidationType.Schema;
reader.Schemas.Add(myschema);
while (reader.Read()){Response.Write(reader.Value);}
Response.Write("<br>Completed validating xmlfragment<br>");
}
catch (XmlException XmlExp)
{
Response.Write(XmlExp.Message + "<br>");
}
catch(XmlSchemaException XmlSchExp)
{
Response.Write(XmlSchExp.Message + "<br>");
}
catch(Exception GenExp)
{
Response.Write(GenExp.Message + "<br>");
}
finally
{}
XmlDocument doc;
}
public void TestElementContent ()
{
string intSubset = "<!ELEMENT root (foo)><!ELEMENT foo EMPTY>";
string dtd = "<!DOCTYPE root [" + intSubset + "]>";
string xml = dtd + "<root />";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
try {
dvr.Read (); // root: invalid end
Assert.Fail ("should be failed.");
} catch (XmlSchemaException) {
}
xml = dtd + "<root>Test.</root>";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
dvr.Read (); // root
try {
dvr.Read (); // invalid end
Assert.Fail ("should be failed.");
} catch (XmlSchemaException) {
}
xml = dtd + "<root><foo /></root>";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
dvr.Read (); // root
dvr.Read (); // foo
xml = dtd + "<root><bar /></root>";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
dvr.Read (); // root
try {
dvr.Read (); // invalid element
Assert.Fail ("should be failed.");
} catch (XmlSchemaException) {
}
}
public void LoadAndValidate()
{
string path = this.GetType().Namespace + ".";
Stream stm = this.GetType().Assembly.GetManifestResourceStream(
path + "mixedNs.xml");
string xml = new StreamReader(stm).ReadToEnd();
XPathDocument doc = new XPathDocument(new StringReader(xml));
XPathNavigatorReader nr = new XPathNavigatorReader(doc.CreateNavigator());
XmlTextReader tr = new XmlTextReader(new StringReader(xml));
XmlValidatingReader vr = new XmlValidatingReader(tr);
using (StreamReader sr = new StreamReader(this.GetType().Assembly.GetManifestResourceStream
(path + "ImportedSchema1.xsd")))
{
vr.Schemas.Add(XmlSchema.Read(sr, null));
}
using (StreamReader sr = new StreamReader(this.GetType().Assembly.GetManifestResourceStream
(path + "ImportedSchema2.xsd")))
{
vr.Schemas.Add(XmlSchema.Read(sr, null));
}
using (StreamReader sr = new StreamReader(this.GetType().Assembly.GetManifestResourceStream
(path + "RootSchema.xsd")))
{
vr.Schemas.Add(XmlSchema.Read(sr, null));
}
while (vr.Read()) {}
vr = new XmlValidatingReader(nr);
using (StreamReader sr = new StreamReader(this.GetType().Assembly.GetManifestResourceStream
(path + "ImportedSchema1.xsd")))
{
vr.Schemas.Add(XmlSchema.Read(sr, null));
}
using (StreamReader sr = new StreamReader(this.GetType().Assembly.GetManifestResourceStream
(path + "ImportedSchema2.xsd")))
{
vr.Schemas.Add(XmlSchema.Read(sr, null));
}
using (StreamReader sr = new StreamReader(this.GetType().Assembly.GetManifestResourceStream
(path + "RootSchema.xsd")))
{
vr.Schemas.Add(XmlSchema.Read(sr, null));
}
while (vr.Read()) {}
Console.ReadLine();
}
public void TestSingleElement ()
{
string intSubset = "<!ELEMENT root EMPTY>";
string dtd = "<!DOCTYPE root [" + intSubset + "]>";
string xml = dtd + "<root />";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
dvr.Read ();
xml = dtd + "<invalid />";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
try {
dvr.Read (); // invalid element.
Assert.Fail ("should be failed.");
} catch (XmlSchemaException) {
}
xml = dtd + "<root>invalid PCDATA.</root>";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
dvr.Read (); // root
try {
dvr.Read (); // invalid text
Assert.Fail ("should be failed.");
} catch (XmlSchemaException) {
}
xml = dtd + "<root><invalid_child /></root>";
dvr = PrepareXmlReader (xml);
dvr.Read (); // DTD
dvr.Read (); // root
try {
dvr.Read (); // invalid child
Assert.Fail ("should be failed.");
} catch (XmlSchemaException) {
}
}
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);
}
}
/// <summary>
/// Validates the specified xml content
/// </summary>
/// <param name="sImportDocument">Xml content to validate</param>
/// <returns>Error messages if any, else "true"</returns>
public List<string> ValidateCrmImportDocument(string sImportDocument)
{
ValidationEventHandler eventHandler = ShowCompileErrors;
XmlSchemaCollection myschemacoll = new XmlSchemaCollection();
XmlValidatingReader vr;
try
{
using (StreamReader schemaReader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("MsCrmTools.SiteMapEditor.Resources.sitemap.xsd")))
{
//Load the XmlValidatingReader.
vr = new XmlValidatingReader(schemaReader.BaseStream, XmlNodeType.Element, null);
vr.Schemas.Add(myschemacoll);
vr.ValidationType = ValidationType.Schema;
while (vr.Read())
{
}
}
return messages;
}
//This code catches any XML exceptions.
catch (XmlException XmlExp)
{
messages.Add(XmlExp.Message);
return messages;
}
//This code catches any XML schema exceptions.
catch (XmlSchemaException XmlSchemaExp)
{
messages.Add(XmlSchemaExp.Message);
return messages;
}
//This code catches any standard exceptions.
catch (Exception GeneralExp)
{
messages.Add(GeneralExp.Message);
return messages;
}
finally
{
vr = null;
myschemacoll = null;
}
}
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 static void ValidateXml(Stream xmlStream, XmlSchema xsdSchema)
{
XmlTextReader reader1 = null;
try
{
reader1 = new XmlTextReader(xmlStream);
XmlSchemaCollection collection1 = new XmlSchemaCollection();
collection1.Add(xsdSchema);
XmlValidatingReader reader2 = new XmlValidatingReader(reader1);
reader2.ValidationType = ValidationType.Schema;
reader2.Schemas.Add(collection1);
ArrayList list1 = new ArrayList();
while (reader2.ReadState != ReadState.EndOfFile)
{
try
{
reader2.Read();
continue;
}
catch (XmlSchemaException exception1)
{
list1.Add(exception1);
continue;
}
}
if (list1.Count != 0)
{
throw new XmlValidationException(list1);
}
}
catch (XmlValidationException exception2)
{
throw exception2;
}
catch (Exception exception3)
{
throw new XmlValidationException(exception3.Message, exception3);
}
finally
{
if (reader1 != null)
{
reader1.Close();
}
}
}
private void ValidXml()
{
XmlTextReader tr = new XmlTextReader("HeadCount.xml");
XmlValidatingReader vr = new XmlValidatingReader(tr);
// XmlReader xr =
vr.ValidationType = ValidationType.Schema;
vr.ValidationEventHandler += new ValidationEventHandler(ValidationHandler);
while (vr.Read())
{
// PrintTypeInfo(vr);
if (vr.NodeType == XmlNodeType.Element)
{
// while (vr.MoveToNextAttribute())
// PrintTypeInfo(vr);
}
}
// Console.WriteLine("Validation finished");
}
// XmlReaderSample5/form.cs
protected void button1_Click(object sender, System.EventArgs e)
{
//change this to match your path structure.
string fileName = "..\\booksVal.xml";
XmlTextReader tr=new XmlTextReader(fileName);
XmlValidatingReader trv=new XmlValidatingReader(tr);
//Set validation type
trv.ValidationType=ValidationType.XDR;
//Add in the Validation eventhandler
trv.ValidationEventHandler +=
new ValidationEventHandler(this.ValidationEvent);
//Read in node at a time
while(trv.Read())
{
if(trv.NodeType == XmlNodeType.Text)
listBox1.Items.Add(trv.Value);
}
}
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 bool validateCommon()
{
bool success=true;
//d_nrMessages=0;
try {
XmlValidatingReader vr = new XmlValidatingReader(d_xtr);
vr.ValidationType = ValidationType.Schema;
vr.ValidationEventHandler += new ValidationEventHandler (validationHandler);
// consume
while(vr.Read())
;
} catch(Exception e) {
success=false;
if (d_throwErrors)
throw e;
} finally {
d_xtr.Close();
}
return success;
}
static void Main(string[] args)
{
//
// TODO: Add code to start application here
//
try
{
if(args.Length!=1)
{
System.Console.WriteLine("Usage: xsd.exe source-uri");
return;
}
SX.XmlTextReader reader = new SX.XmlTextReader(args[0]);
SX.XmlValidatingReader validatingReader =
new SX.XmlValidatingReader(reader);
while(validatingReader.Read());
}
catch(System.Exception e)
{
System.Console.WriteLine(e.ToString());
}
}
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");
}
}