Validierung von XML-Knoten, nicht das gesamte Dokument

Question

Ich arbeite mit einigen XML-Snippets, die Elemente in der XML-Form bilden. Ich habe das Schema, aber ich kann diese Dateien nicht validieren, weil sie keine vollständigen XML-Dokumente sind. Diese Snippets werden mit den erforderlichen übergeordneten Elementen umschlossen, um gültiges XML zu bilden, wenn sie in anderen Tools verwendet werden, so dass ich nicht viele Optionen habe, um sie in gültiges XML umzuwandeln oder das Schema zu ändern.

Ist es möglich, ein Element und nicht das gesamte Dokument zu validieren? Wenn nicht, welche Workarounds könnten vorgeschlagen werden?

Ich arbeite in C# mit .NET 2.0 Framework.

Answer 1

Ich hatte ein ähnliches Problem, wo ich nur Teile meines XML-Dokuments validieren konnte. Ich kam hierher mit dieser Methode auf:

private void ValidateSubnode(XmlNode node, XmlSchema schema) 
{ 
    XmlTextReader reader = new XmlTextReader(node.OuterXml, XmlNodeType.Element, null); 

    XmlReaderSettings settings = new XmlReaderSettings(); 
    settings.ConformanceLevel = ConformanceLevel.Fragment; 
    settings.Schemas.Add(schema); 
    settings.ValidationType = ValidationType.Schema; 
    settings.ValidationEventHandler += new ValidationEventHandler(XSDValidationEventHandler); 

    using (XmlReader validationReader = XmlReader.Create(reader, settings)) 
    {  
     while (validationReader.Read()) 
     { 
     } 
    } 
} 

private void XSDValidationEventHandler(object sender, ValidationEventArgs args) 
{ 
    errors.AppendFormat("XSD - Severity {0} - {1}", 
         args.Severity.ToString(), args.Message); 
} 

Grundsätzlich gibt ich ihm ein XmlNode (was ich aus dem gesamten XmlDocument wähle mittels .SelectSingleNode) und ein XML-Schema, das ich aus einer eingebetteten Ressource XSD lade innen meine App. Alle Überprüfungsfehler, die auftreten könnten, werden in einen String Builder für "Fehler" eingefügt, den ich dann am Ende auslese, um zu sehen, ob irgendwelche Fehler aufgezeichnet wurden oder nicht.

Works für mich - die Leistung kann variieren :-)

Answer 2

Sie können einen speziellen Namespace-Alias ​​verwenden, um die Elemente zu kennzeichnen, die Sie validieren möchten, und dann nur ein Schema für diesen Namespace-Alias ​​hinzufügen, aber nicht für andere. Auf diese Weise werden nur die Elemente mit Ihrem speziellen Namespacepräfix validiert.

Answer 3

Es gibt eine XmlDocument.Validate Methode, die ein als Argument akzeptiert und nur diesen Knoten validiert. Das könnte sein, was Sie suchen ...

Answer 4

Es scheint nicht möglich zu tun, was ich tun möchte. Meine aktuelle Arbeit besteht darin, ein leeres XML-Dokument zu erstellen. Dann ersetzen Sie das gewünschte Element durch mein Snippet. Von da an glaube ich, dass die Validate-Methode dann praktikabel wäre. Die dynamische Erstellung dieses Templates scheint jedoch eine weitere entmutigende Aufgabe zu sein. Es scheint keine einfache Möglichkeit zu geben, ein "Skelett" -Dokument zu erstellen.

Answer 5

Ok, hier ist ein anderer Ansatz:

Sie könnten Ihre Schemadatei mit Hilfe einer XSLT-Transformation in ein neues Schema umwandeln, die Ihre Schnipsel Elemente als Wurzel hat. Sagen Sie Ihre ursprüngliche Schema wäre

<xs:schema id="MySchema" xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
    <xs:element name="RootElement"> 
    <xs:complexType> 
     <xs:sequence> 
     <xs:element name="NestedElement"> 
      <xs:complexType> 
      <xs:attribute name="Name" type="xs:string" use="required"/> 
      </xs:complexType> 
     </xs:element> 
     </xs:sequence> 
    </xs:complexType> 
    </xs:element> 
</xs:schema> 

Sie Schnipsel vom Typ haben NestedElement, die Sie überprüfen möchten:

<NestedElement Name1="Name1" /> 

Dann Sie eine XSLT-Vorlage verwenden könnte wie

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
    <xsl:template match="xs:element[@name='NestedElement']" 
       xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
    <xs:schema id="MySchema"> 
     <xsl:copy-of select="."/> 
    </xs:schema> 
    </xsl:template> 
</xsl:stylesheet> 

a zu erstellen neues Schema, das NestedElement als root hat. Das resultierende Schema würde aussehen wie

<xs:schema id="MySchema" xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
    <xs:element name="NestedElement"> 
    <xs:complexType> 
     <xs:attribute name="Name" type="xs:string" use="required" /> 
    </xs:complexType> 
    </xs:element> 
</xs:schema> 

Sie können dann einen Schnipsel Dokument gegen dieses neue Schema validieren einen Code wie

XmlSchema schema; 
using (MemoryStream stream = new MemoryStream()) 
using (FileStream fs = new FileStream("MySchema.xsd", FileMode.Open)) 
using(XmlReader reader = XmlReader.Create(fs)) { 
    XslCompiledTransform transform = new XslCompiledTransform(); 
    transform.Load("SchemaTransform.xslt"); 
    transform.Transform(reader, null, stream); 
    stream.Seek(0, SeekOrigin.Begin); 
    schema = XmlSchema.Read(stream, null); 
} 
XmlDocument doc = new XmlDocument(); 
doc.Schemas.Add(schema); 
doc.Load("rootelement.xml"); 
doc.Validate(ValidationHandler); 

MySchema.xsd verwendet, ist das ursprüngliche Schema, SchemaTransform.xslt die Transformation (wie oben dargestellt) rootelement.xml ist ein XML-Dokument, das einen einzelnen Snippet-Knoten enthält.

Answer 6

ich hatte das gleiche Problem. Auch hier nach einer Lösung gefragt. Ich habe einen Workaround gefunden.

Das Problem ist, dass nur Root-Elemente validiert werden können. Also ... ich das Schema IN MEMORY bearbeiten und das Element/Typ hinzufügen, an die Wurzel

public static void AddElementToSchema(XmlSchema xmlSchema, string elementName, string elementType, string xmlNamespace) 
{ 
    XmlSchemaElement testNode = new XmlSchemaElement(); 
    testNode.Name = elementName; 
    testNode.Namespaces.Add("", xmlNamespace); 
    testNode.SchemaTypeName = new XmlQualifiedName(elementType, xmlNamespace); 
    xmlSchema.Items.Add(testNode); 
    xmlSchema.Compile(XMLValidationEventHandler); 
} 

Nur ein paar Zeilen zu bestätigen und Sie müssen alle XSD-Dateien :) Mit dieser einfachen Änderung nicht ändern oder ergänzen Wenn Sie Ihr speicherinternes Schema verwenden, können Sie das Fragment mit demselben Code validieren, den Sie zum Validieren eines vollständigen Dokuments verwenden. Stellen Sie sicher, dass das Wurzelelement des zu validierenden Fragments den Namespace enthält. :)