How to get the XPath (or Node) for the location of an XML schema validation failure?

Question

I am using XDocument.Validate (it seems to function the same as XmlDocument.Validate) to validate an XML document against an XSD - this works well and I am informed of validation errors.

However, only some information seems to be exposed [reliably] in the ValidationEventHandler (and XmlSchemaException), e.g.:

• the error message (i.e. "The 'X' attribute is invalid - The value 'Y' is invalid according to its datatype 'Z' - The Pattern constraint failed"),
• the severity

What I would like is to get the "failing XPath" for the validation failure (where it makes sense): that is, I would like to get the failure in relation to the XML document (as opposed to the XML text).

Is there a way to obtain the "failing XPath" information from XDocument.Validate? If not, can the "failing XPath" be obtained through another XML validation method such as an XmlValidatingReader¹?

---

Background:

The XML will be sent as data to my Web Service with an automatic conversion (via JSON.NET) from JSON to XML. Because of this I begin processing the XDocument data¹ and not text, which has no guaranteed order due to the original JSON data. The REST client is, for reasons I care not to get into, basically a wrapper for HTML form fields over an XML document and validation on the server occurs in two parts - XML schema validation and Business Rule validation.

In the Business Rule validation it's easy to return the "XPath" for the fields which fail conformance that can be used to indicate the failing field(s) on the client. I would like to extend this to the XSD schema validation which takes care of the basic structure validation and, more importantly, the basic "data type" and "existence" of attributes. However, due to the desired automatic process (i.e. highlight the appropriate failing field) and source conversions, the raw text message and the source line/column numbers are not very useful by themselves.

---

Here is a snippet of the validation code:

// Start with an XDocument object - created from JSON.NET conversion
XDocument doc = GetDocumentFromWebServiceRequest();

// Load XSD    
var reader = new StringReader(EmbeddedResourceAccess.ReadResource(xsdName));
var xsd = XmlReader.Create(reader, new XmlReaderSettings());
var schemas = new XmlSchemaSet();
schemas.Add("", xsd);

// Validate
doc.Validate(schemas, (sender, args) => {
  // Process validation (not parsing!) error,
  // but how to get the "failing XPath"?
});

---

Update: I found Capture Schema Information when validating XDocument which links to "Accessing XML Schema Information During Document Validation" (cached) from which I determined two things:

1. XmlSchemaException can be specialized into XmlSchemaValidationException which has a SourceObject property - however, this always returns null during validation: "When an XmlSchemaValidationException is thrown during validation by a validating XmlReader object, the value of the SourceObject property is null".

2. I can read through the document (via XmlReader.Read) and "remember" the path prior to the validation callback. While this "seems like it works" in initial tests (without a ValidationCallback), it feels quite inelegant to me - but I've been able to find little else.

Answer 1

Sender of validation event is a source of event. So, you can search over the network for code which gets XPath for node (e.g. Generating an XPath expression) and generate XPath for source of event:

doc.Validate(schemas, (sender, args) => {
  if (sender is XObject)
  { 
     xpath = ((XObject)sender).GetXPath();
  }
});

Answer 2

Take it :-)

var xpath = new Stack<string>();

var settings = new XmlReaderSettings
               {
                   ValidationType = ValidationType.Schema,
                   ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings,
               };
MyXmlValidationError error = null;
settings.ValidationEventHandler += (sender, args) => error = ValidationCallback(sender, args);
foreach (var schema in schemas)
{
    settings.Schemas.Add(schema);
}

using (var reader = XmlReader.Create(xmlDocumentStream, settings))
{
    // validation
    while (reader.Read())
    {
        if (reader.NodeType == XmlNodeType.Element)
        {
            xpath.Push(reader.Name);
        }

        if (error != null)
        {
            // set "failing XPath"
            error.XPath = xpath.Reverse().Aggregate(string.Empty, (x, y) => x + "/" + y);

            // your error with XPath now

            error = null;
        }

        if (reader.NodeType == XmlNodeType.EndElement ||
            (reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement))
        {
            xpath.Pop();
        }
    }
}

Answer 3

I don't know the API but my guess is no, you can't get the xpath because validation may be implemented as a finite state machine. A state may not translate to an xpath or in the case when it is valid for more than one element to follow and the element found is not in the expected set, the xpath doesn't exist.

Answer 4

Finally successed in this way!

When I use XmlReader.Create(xmlStream, settings) and xmlRdr.Read() to Validate a XML, I captured the sender of the ValidationEventHandler and find it is an object of {System.Xml.XsdValidatingReader},so I transfer sender to a xmlreader object, there are some functions in XMLReader class to help you find the parent node of the error attributes.

There is one thing to watch out that when i use XMLReader.MoveToElement(), the Validation function will be stuck into a loop in the error attribute,so i used MoveToAtrribute(AttributeName) and then MoveToNextAttribute to avoid stuck into the loop, maybe there is more elegant way to handle this.

Without further ado，below is my code.

public string XMLValidation(string XMLString, string SchemaPath)
    {
        string error = string.Empty;
        MemoryStream xmlStream = new MemoryStream(Encoding.UTF8.GetBytes(XMLString));

        XmlSchemaSet schemas = new XmlSchemaSet();
        schemas.Add(null, SchemaPath);

        XmlReaderSettings settings = new XmlReaderSettings();
        settings.ValidationType = ValidationType.Schema;
        settings.Schemas.Add(schemas);

        settings.ValidationEventHandler += new ValidationEventHandler(delegate(object sender, ValidationEventArgs e)
        {
            switch (e.Severity)
            {
                case XmlSeverityType.Error:
                    XmlReader senRder = (XmlReader)sender;
                    if (senRder.NodeType == XmlNodeType.Attribute)
                    {//when error occurs in an attribute,get its parent element name
                        string attrName = senRder.Name;
                        senRder.MoveToElement();
                        error += string.Format("ERROR:ElementName'{0}':{1}{2}", senRder.Name, e.Message, Environment.NewLine);
                        senRder.MoveToAttribute(attrName);
                    }
                    else
                    {
                        error += string.Format("ERROR:ElementName'{0}':{1}{2}", senRder.Name, e.Message, Environment.NewLine);
                    }
                    break;
                case XmlSeverityType.Warning:
                    break;
            }
        });
        XmlReader xmlRdr = XmlReader.Create(xmlStream, settings);
        while (xmlRdr.Read()) ;
        return error;
    }

Answer 5

Alternatively you could use the code at How to find an XML node from a line and column number in C#? to get the failing node by using the args.Exception.LineNumber and args.Exception.LinePosition and then navigate the XML document as required to provide more information about what data caused the validation to fail.

Answer 6

If, like me, you are using the "XmlDocument.Validate(ValidationEventHandler validationEventHandler)" method to validate your XML:

// Errors and alerts collection
private ICollection<string> errors = new List<String>();

// Open xml and validate
...
{
    // Create XMLFile for validation
    XmlDocument XMLFile = new XmlDocument();

    // Validate the XML file
    XMLFile.Validate(ValidationCallBack);
}

// Manipulator of errors occurred during validation
private void ValidationCallBack(object sender, ValidationEventArgs args)
{
    if (args.Severity == XmlSeverityType.Warning)
    {
        errors.Add("Alert: " + args.Message + " (Path: " + GetPath(args) + ")");
    }
    else if (args.Severity == XmlSeverityType.Error)
    {
        errors.Add("Error: " + args.Message + " (Path: " + GetPath(args) + ")");
    }
}

The secret is to get the "Exception" property data of the "args" parameter. Do like this:

// Return this parent node
private string GetPath(ValidationEventArgs args)
{
    var tagProblem =((XmlElement)((XmlSchemaValidationException)args.Exception).SourceObject);
    return iterateParentNode(tagProblem.ParentNode) + "/" +tagProblem.Name;
}

private string iterateParentNode(XmlNode args)
{
    var node = args.ParentNode;

    if (args.ParentNode.NodeType == XmlNodeType.Element)
    {
        return interateParentNode(node) + @"/" + args.Name;
    }
    return "";
}