/**
* Valider un fichier XML à partir d'un fichier XML Schema
**/
int XML01_SchemaValidation(char * XMLSchemaFile_pathname, char * XMLfile_pathname)
{
	xmlSchemaPtr ptr_schema = NULL;
	xmlSchemaParserCtxtPtr ptr_ctxt;
	xmlSchemaValidCtxtPtr ptr_validctxt;
	int vl_return;
	xmlDocPtr vl_doc;
	HINSTANCE vl_hModule;
 
 
	/* Ouverture du fichier XML Schema */
	ptr_ctxt = xmlSchemaNewParserCtxt(XMLSchemaFile_pathname);
	xmlSchemaSetParserErrors(ptr_ctxt,
	    (xmlSchemaValidityErrorFunc) fprintf,
	    (xmlSchemaValidityWarningFunc) fprintf,
	    stderr);
 
	ptr_schema = xmlSchemaParse(ptr_ctxt);
	xmlSchemaFreeParserCtxt(ptr_ctxt);
 
	/* Si le XML Schema n'a pas pu être chargé*/
	if (ptr_schema == NULL){
		printf("XMLSCHEMA: Could not open XML Schema %s\n", XMLSchemaFile_pathname);
		xmlSchemaCleanupTypes();
		xmlCleanupParser();
		xmlMemoryDump();
		FreeLibrary(vl_hModule);
		return -1;
	}
 
 
	vl_doc =xmlReadFile(XMLfile_pathname,NULL,0);
	/* Si le fichier XML ne peut pas être ouvert on signale l'erreur*/
	if (vl_doc == NULL) {
	    printf("XML: Could not parse %s\n", XMLfile_pathname);
	} else /* Sinon on vérifie la validité du fichier XML */
	{
		/* Chargement du contenu du XML SChema  */
		ptr_validctxt = xmlSchemaNewValidCtxt(ptr_schema);
		xmlSchemaSetValidErrors(ptr_validctxt,
		    (xmlSchemaValidityErrorFunc) fprintf,
		    (xmlSchemaValidityWarningFunc) fprintf,
		    stderr);
 
		/* On valide le fichier XML à partir de la structure du XML Schema*/
		vl_return = (fct_xmlSchemaValidateDoc)(ptr_validctxt, vl_doc);
		
		/* On affiche le résultat */
		if (vl_return == 0){ // If the XML file is valid
			printf("XMLSCHEMA VERDICT : Xml file <%s> validates.\n", XMLfile_pathname);
		} 
		else if (vl_return > 0){ // Si le fichier XML ne correspond pas à la structure du XML Schema
			printf("XMLSCHEMA VERDICT : Xml file <%s> fails to validate.\n", XMLfile_pathname);
		} 
		else { // Autre erreur
			printf("XMLSCHEMA VERDICT : <%s> validation generated an internal error\n", XMLfile_pathname);
		}
		xmlSchemaFreeValidCtxt(ptr_validctxt);
		xmlFreeDoc(vl_doc);
	}
	FreeLibrary(vl_hModule);	
	return(0);
}

using System.Xml;
using System.Xml.Schema;
 
public static void ValideXml()
{
    FileStream fs = new FileStream(@".\books.xml", FileMode.Open);   
    XmlValidatingReader xmlValidatingReader = new XmlValidatingReader(new XmlTextReader(fs));
    xmlValidatingReader.ValidationType = ValidationType.Schema;
    XmlSchemaCollection sc = new XmlSchemaCollection();
    sc.Add(null, @".\books.xsd");
    xmlValidatingReader.ValidationEventHandler += new ValidationEventHandler(XmlValidationError);
    xmlValidatingReader.Schemas.Add(sc);
    while (xmlValidatingReader.Read()) ;
    xmlValidatingReader.Close();
}
...
private static void XmlValidationError(object sender, ValidationEventArgs e)
{
    // code à exécuter si erreur à la validation du Xml suivant le schéma Xsd
    // on passe autant de fois dans ce code qu'il y a d'erreurs
    string error = e.Exception.Message;
}

Imports System.Xml
Imports System.Xml.Schema
...
Public Shared Sub ValideXml()
    Dim fs As FileStream = New FileStream(".\books.xml", FileMode.Open)
    Dim xmlValidatingReader As XmlValidatingReader = New XmlValidatingReader(New XmlTextReader(fs))
    xmlValidatingReader.ValidationType = ValidationType.Schema
    Dim sc As XmlSchemaCollection = New XmlSchemaCollection()
    sc.Add(Nothing, ".\books.xsd")
    AddHandler xmlValidatingReader.ValidationEventHandler, AddressOf XmlValidationError
    xmlValidatingReader.Schemas.Add(sc)
    While (xmlValidatingReader.Read())
    End While
    xmlValidatingReader.Close()
End Sub
...
Private Shared Sub XmlValidationError(ByVal sender As Object, ByVal e As ValidationEventArgs)
    ' code à exécuter si erreur à la validation du Xml suivant le schéma Xsd
    ' on passe autant de fois dans ce code qu'il y a d'erreurs
    Dim str As String = e.Exception.Message
End Sub

using namespace System::Xml;
using namespace System::Xml::Schema;
...
public:
    static void ValideXml()
    {
	FileStream ^ fs = gcnew FileStream(".\\books.xml", FileMode::Open);
	XmlValidatingReader ^ xmlValidatingReader = gcnew XmlValidatingReader(gcnew XmlTextReader(fs));
	xmlValidatingReader->ValidationType = ValidationType::Schema;
	XmlSchemaCollection ^ sc = gcnew XmlSchemaCollection();
	sc->Add(nullptr, ".\\books.xsd");
	xmlValidatingReader->ValidationEventHandler += gcnew ValidationEventHandler(XmlValidationError);
	xmlValidatingReader->Schemas->Add(sc);
	while (xmlValidatingReader->Read()) ;
	xmlValidatingReader->Close();
    }
...
private:
    static void XmlValidationError(Object ^ sender, ValidationEventArgs ^ e)
    {
        // code à exécuter si erreur à la validation du Xml suivant le schéma Xsd
        // on passe autant de fois dans ce code qu'il y a d'erreurs
        String ^ str = e->Exception->Message;
    }

using System.Xml;
using System.Xml.Schema;
 
public static void ValideXml()
{
    XmlReaderSettings settings = new XmlReaderSettings();
    settings.Schemas.Add(null, @".\books.xsd");
    settings.ValidationType = ValidationType.Schema;
    settings.ValidationEventHandler += new ValidationEventHandler(XmlValidationError);
    XmlReader reader = XmlReader.Create(@".\books.xml", settings);
    while (reader.Read()) ;
}
...
private static void XmlValidationError(object sender, ValidationEventArgs e)
{
    // code à exécuter si erreur à la validation du Xml suivant le schéma Xsd
    // on passe autant de fois dans ce code qu'il y a d'erreurs
    string error = e.Exception.Message;
}

Imports System.Xml
Imports System.Xml.Schema
...
Public Shared Sub ValideXml()
    Dim settings As XmlReaderSettings = New XmlReaderSettings()
    settings.Schemas.Add(Nothing, ".\books.xsd")
    settings.ValidationType = ValidationType.Schema
    AddHandler settings.ValidationEventHandler, AddressOf XmlValidationError
    Dim reader As XmlReader = XmlReader.Create(".\books.xml", settings)
    While (reader.Read())
    End While
End Sub
...
Private Shared Sub XmlValidationError(ByVal sender As Object, ByVal e As ValidationEventArgs)
    ' code à exécuter si erreur à la validation du Xml suivant le schéma Xsd
    ' on passe autant de fois dans ce code qu'il y a d'erreurs
    Dim str As String = e.Exception.Message
End Sub

using namespace System::Xml;
using namespace System::Xml::Schema;
...
public:
    static void ValideXml()
    {
        XmlReaderSettings ^ settings = gcnew XmlReaderSettings();
        settings->Schemas->Add(nullptr, ".\\books.xsd");
        settings->ValidationType = ValidationType::Schema;
        settings->ValidationEventHandler += gcnew ValidationEventHandler(XmlValidationError);
        XmlReader ^ reader = XmlReader::Create(".\\books.xml", settings);
        while (reader->Read()) ;
    }
...
private:
    static void XmlValidationError(Object ^ sender, ValidationEventArgs ^ e)
    {
        // code à exécuter si erreur à la validation du Xml suivant le schéma Xsd
        // on passe autant de fois dans ce code qu'il y a d'erreurs
        String ^ str = e->Exception->Message;
    }

String language = XMLConstants.W3C_XML_SCHEMA_NS_URI;
SchemaFactory factory = SchemaFactory.newInstance(language); 
factory.setErrorHandler(new MyErrorHandler()); 
factory.setResourceResolver( new MyResourceResolver()); 
StreamSource ss = new StreamSource(new File("schema.xsd"));
Schema schema;
try {
	schema = factory.newSchema(ss);
	Validator validator = schema.newValidator();
	validator.setErrorHandler( new MyErrorHandler());
	validator.validate(new StreamSource("fichier.xml"));
} 
catch (SAXException e) {e.printStackTrace();}
catch (IOException e) {e.printStackTrace();}

/usr/bin/xmllint -noout  -schema "chemin d'acces au schema .xsd" "chemin d'acces au fichier.xml"

Dim WshShell
Set WshShell=CreateObject("WScript.Shell")
 
Dim xmlDoc
set xmlDoc=CreateObject("Msxml2.DOMDocument.6.0")
xmlDoc.async=false
xmlDoc.validateOnParse=true
 
Dim xmlSchema
set xmlSchema=CreateObject("Msxml2.DOMDocument.6.0")
xmlSchema.async=false
xmlSchema.validateOnParse=true
xmlSchema.load {le chemin d acces au schema}
 
Dim xsdCache
set xsdCache=CreateObject("Msxml2.XMLSchemaCache.6.0")
xsdCache.add {namespace}, xmlSchema
Set xmlDoc.schemas = xsdCache
 
xmlDoc.load {le chemin d acces au fichier XML}
 
Set myErr=xmlDoc.parseError
If(myErr.errorCode<>0)Then
        WScript.Echo("errorReason="+myErr.reason)
else
        WScript.Echo("ok")
End If

<?php 
$xml = new DOMDocument(); 
$xml->load('my.xml'); 
if ($xml->schemaValidate("my.xsd")) { 
     echo "OK"; 
} else { 
     echo "Erreur"; 
} 
?>

unit UXMLvalidation;

interface

uses
  Classes, SysUtils, msxmldom, 
  MSXML2_TLB, { Il faut importer l'activeX MSXML DOM2 4.0 pour obtenir l'unité MSXML2_TLB.pas } 
  xmldom, 
  XMLDoc, XMLIntf; { Pour une utilisation de TXMLDocument }

type
  EXMLDOMValidationError = class(Exception)
  private
    FSrcText: DOMString;
    FURL: DOMString;
    FReason: DOMString;
    FErrorCode: Integer;
    FLine: Integer;
    FLinePos: Integer;
    FFilePos: Integer;
  public
    constructor Create(const ValidationError: IXMLDOMParseError);
    property ErrorCode: Integer read FErrorCode;
    property URL: DOMString read FURL;
    property Reason: DOMString read FReason;
    property SrcText: DOMString read FSrcText;
    property Line: Integer read FLine;
    property LinePos: Integer read FLinePos;
    property FilePos: Integer read FFilePos;
  end;


procedure ValidateXMLFileName(XMLFilename,  XSDFilename: TFileName; NameSpaceSchema: string);
procedure ValidateXMLText(XMLText: string; XSDFilename: TFileName; NameSpaceSchema: string);
procedure ValidateXMLDoc(XMLDoc, XSDDoc: IXMLDOMDocument2;   NameSpaceSchema: string);

// Génère une exception EXMLDOMValidationError si errorcode<>0
procedure CheckValidationError(ValidationError: IXMLDOMParseError);

// Permet de retrouver l'interface COM de MSXML à partir d'un IXMLDocument (Borland)
// Attention: le IXMLDocument doit avoir dans ce cas MSXML comme Vendor !
function GetXMLDOMDocument2(XMLDoc: IXMLDocument): IXMLDOMDocument2;

resourcestring
  RS_EXMLDOM_FILE_VALIDATION_ERROR = 'Document XML non conforme au schéma.'#13#10#13#10+
                                     'Raison:'#13#10'%s'#13#10+
                                     'Ligne: %d'#13#10+
                                     'Position: %d'#13#10+
                                     'Position dans le fichier: %d'#13#10+
                                     'URL: %s'#13#10+
                                     'XML: '#13#10'%s';

  RS_EXMLDOM_NOFILE_VALIDATION_ERROR = 'Document XML non conforme au schéma.'#13#10#13#10+
                                       'Raison:'#13#10'%s'#13#10;

implementation

{ EXMLDOMValidationError }

constructor EXMLDOMValidationError.Create(
  const ValidationError: IXMLDOMParseError);
begin
  FSrcText := ValidationError.srcText;
  FURL := ValidationError.url;
  FReason := ValidationError.reason;
  FErrorCode := ValidationError.errorCode;
  FLine := ValidationError.line;
  FLinePos := ValidationError.linepos;
  FFilePos := ValidationError.filepos;

  if FLine>0 then
    inherited CreateResFmt(@RS_EXMLDOM_FILE_VALIDATION_ERROR, [FReason,
                                                               FLine,
                                                               FLinePos,
                                                               FFilePos,
                                                               FURL,
                                                               FSrcText])
  else
    inherited CreateResFmt(@RS_EXMLDOM_FILE_VALIDATION_ERROR, [FReason]);
end;

function GetXMLDOMDocument2(XMLDoc: IXMLDocument): IXMLDOMDocument2;
begin
  XMLDoc.Active := True;
  Result := ((XMLDoc.DOMDocument as IXMLDOMNodeRef).GetXMLDOMNode as IXMLDOMDocument2);
end;

procedure CheckValidationError(ValidationError: IXMLDOMParseError);
begin
  if ValidationError.errorCode<>0 then
    raise EXMLDOMValidationError.Create(ValidationError);
end;

procedure ValidateXMLDoc(XMLDoc, XSDDoc: IXMLDOMDocument2;
  NameSpaceSchema: string);
var
  vSchemaCollection: IXMLDOMSchemaCollection2;
begin
  vSchemaCollection := CoXMLSchemaCache40.Create;
  vSchemaCollection.add(NameSpaceSchema, XSDDoc);
  XMLDoc.schemas := vSchemaCollection;
  CheckValidationError(XMLDoc.validate);
end;

procedure ValidateXMLFilename(XMLFilename,
  XSDFilename: TFileName; NameSpaceSchema: string);
var
  vXML,
  vSchema: IXMLDOMDocument2;
  vSchemaCollection: IXMLDOMSchemaCollection2;
begin
  vSchema := CoDOMDocument40.Create;
  vSchema.async := False;
  vSchema.load(XSDFilename);

  vSchemaCollection := CoXMLSchemaCache40.Create;
  vSchemaCollection.add(NameSpaceSchema, vSchema);

  vXML := CoDOMDocument40.Create;
  vXML.async := False;
  vXML.validateOnParse := True;
  vXML.schemas := vSchemaCollection;
  vXML.load(XMLFilename);

  CheckValidationError(vXML.parseError);
end;

procedure ValidateXMLText(XMLText: string;
  XSDFilename: TFileName; NameSpaceSchema: string);
var
  vXML,
  vSchema: IXMLDOMDocument2;
  vSchemaCollection: IXMLDOMSchemaCollection2;
begin
  vSchema := CoDOMDocument40.Create;
  vSchema.async := False;
  vSchema.load(XSDFilename);

  vSchemaCollection := CoXMLSchemaCache40.Create;
  vSchemaCollection.add(NameSpaceSchema, vSchema);

  vXML := CoDOMDocument40.Create;
  vXML.async := False;
  vXML.validateOnParse := True;
  vXML.schemas := vSchemaCollection;
  vXML.loadXML(XMLText);

  CheckValidationError(vXML.parseError);
end;

 
end.