private void ProcessInlineSchema()
{
if (!inlineSchemaParser.ParseReaderNode()) // Done
{
inlineSchemaParser.FinishParsing();
XmlSchema schema = inlineSchemaParser.XmlSchema;
string inlineNS = null;
if (schema != null && schema.ErrorCount == 0)
{
try {
SchemaInfo inlineSchemaInfo = new SchemaInfo();
inlineSchemaInfo.SchemaType = SchemaType.XSD;
inlineNS = schema.TargetNamespace == null? string.Empty : schema.TargetNamespace;
if (!SchemaInfo.TargetNamespaces.ContainsKey(inlineNS))
{
if (SchemaCollection.Add(inlineNS, inlineSchemaInfo, schema, true) != null) //If no errors on compile
//Add to validator's SchemaInfo
{
SchemaInfo.Add(inlineSchemaInfo, EventHandler);
}
}
}
catch (XmlSchemaException e) {
SendValidationEvent(Res.Sch_CannotLoadSchema, new string[] { BaseUri.AbsoluteUri, e.Message }, XmlSeverityType.Error);
}
}
inlineSchemaParser = null;
}
}
private void ValidateElement()
{
elementName.Init(reader.LocalName, XmlSchemaDatatype.XdrCanonizeUri(reader.NamespaceURI, NameTable, SchemaNames));
ValidateChildElement();
if (SchemaNames.IsXDRRoot(elementName.Name, elementName.Namespace) && reader.Depth > 0)
{
_inlineSchemaParser = new Parser(SchemaType.XDR, NameTable, SchemaNames, EventHandler);
_inlineSchemaParser.StartParsing(reader, null);
_inlineSchemaParser.ParseReaderNode();
}
else
{
ProcessElement();
}
}
private void ValidateElement()
{
elementName.Init(reader.LocalName, reader.NamespaceURI);
object particle = ValidateChildElement();
if (IsXSDRoot(elementName.Name, elementName.Namespace) && reader.Depth > 0)
{
inlineSchemaParser = new Parser(SchemaType.XSD, NameTable, SchemaNames, EventHandler);
inlineSchemaParser.StartParsing(reader, null);
inlineSchemaParser.ParseReaderNode();
}
else
{
ProcessElement(particle);
}
}
private void ProcessInlineSchema()
{
if (!_inlineSchemaParser.ParseReaderNode())
{ // Done
_inlineSchemaParser.FinishParsing();
SchemaInfo xdrSchema = _inlineSchemaParser.XdrSchema;
if (xdrSchema != null && xdrSchema.ErrorCount == 0)
{
foreach (string inlineNS in xdrSchema.TargetNamespaces.Keys)
{
if (!this.schemaInfo.HasSchema(inlineNS))
{
schemaInfo.Add(xdrSchema, EventHandler);
SchemaCollection.Add(inlineNS, xdrSchema, null, false);
break;
}
}
}
_inlineSchemaParser = null;
}
}
// SxS: This function calls ValidateElement on XmlSchemaValidator which is annotated with ResourceExposure attribute.
// Since the resource names (namespace location) are not provided directly by the user (they are read from the source
// document) and the function does not expose any resources it is fine to suppress the SxS warning.
private async Task ProcessElementEventAsync()
{
if (_processInlineSchema && IsXSDRoot(_coreReader.LocalName, _coreReader.NamespaceURI) && _coreReader.Depth > 0)
{
_xmlSchemaInfo.Clear();
_attributeCount = _coreReaderAttributeCount = _coreReader.AttributeCount;
if (!_coreReader.IsEmptyElement)
{ //If its not empty schema, then parse else ignore
_inlineSchemaParser = new Parser(SchemaType.XSD, _coreReaderNameTable, _validator.SchemaSet.GetSchemaNames(_coreReaderNameTable), _validationEvent);
await _inlineSchemaParser.StartParsingAsync(_coreReader, null).ConfigureAwait(false);
_inlineSchemaParser.ParseReaderNode();
_validationState = ValidatingReaderState.ParseInlineSchema;
}
else
{
_validationState = ValidatingReaderState.ClearAttributes;
}
}
else
{ //Validate element
//Clear previous data
_atomicValue = null;
_originalAtomicValueString = null;
_xmlSchemaInfo.Clear();
if (_manageNamespaces)
{
_nsManager.PushScope();
}
//Find Xsi attributes that need to be processed before validating the element
string xsiSchemaLocation = null;
string xsiNoNamespaceSL = null;
string xsiNil = null;
string xsiType = null;
if (_coreReader.MoveToFirstAttribute())
{
do
{
string objectNs = _coreReader.NamespaceURI;
string objectName = _coreReader.LocalName;
if (Ref.Equal(objectNs, _nsXsi))
{
if (Ref.Equal(objectName, _xsiSchemaLocation))
{
xsiSchemaLocation = _coreReader.Value;
}
else if (Ref.Equal(objectName, _xsiNoNamespaceSchemaLocation))
{
xsiNoNamespaceSL = _coreReader.Value;
}
else if (Ref.Equal(objectName, _xsiType))
{
xsiType = _coreReader.Value;
}
else if (Ref.Equal(objectName, _xsiNil))
{
xsiNil = _coreReader.Value;
}
}
if (_manageNamespaces && Ref.Equal(_coreReader.NamespaceURI, _nsXmlNs))
{
_nsManager.AddNamespace(_coreReader.Prefix.Length == 0 ? string.Empty : _coreReader.LocalName, _coreReader.Value);
}
} while (_coreReader.MoveToNextAttribute());
_coreReader.MoveToElement();
}
_validator.ValidateElement(_coreReader.LocalName, _coreReader.NamespaceURI, _xmlSchemaInfo, xsiType, xsiNil, xsiSchemaLocation, xsiNoNamespaceSL);
ValidateAttributes();
_validator.ValidateEndOfAttributes(_xmlSchemaInfo);
if (_coreReader.IsEmptyElement)
{
await ProcessEndElementEventAsync().ConfigureAwait(false);
}
_validationState = ValidatingReaderState.ClearAttributes;
}
}
private void ProcessElementEvent() {
if (this.processInlineSchema && IsXSDRoot(coreReader.LocalName, coreReader.NamespaceURI) && coreReader.Depth > 0) {
xmlSchemaInfo.Clear();
attributeCount = coreReaderAttributeCount = coreReader.AttributeCount;
if (!coreReader.IsEmptyElement) { //If its not empty schema, then parse else ignore
inlineSchemaParser = new Parser(SchemaType.XSD, coreReaderNameTable, validator.SchemaSet.GetSchemaNames(coreReaderNameTable), validationEvent);
inlineSchemaParser.StartParsing(coreReader, null);
inlineSchemaParser.ParseReaderNode();
validationState = ValidatingReaderState.ParseInlineSchema;
}
else {
validationState = ValidatingReaderState.ClearAttributes;
}
}
else { //Validate element
//Clear previous data
atomicValue = null;
originalAtomicValueString = null;
xmlSchemaInfo.Clear();
if (manageNamespaces) {
nsManager.PushScope();
}
//Find Xsi attributes that need to be processed before validating the element
string xsiSchemaLocation = null;
string xsiNoNamespaceSL = null;
string xsiNil = null;
string xsiType = null;
if (coreReader.MoveToFirstAttribute()) {
do {
string objectNs = coreReader.NamespaceURI;
string objectName = coreReader.LocalName;
if (Ref.Equal(objectNs, NsXsi)) {
if (Ref.Equal(objectName, XsiSchemaLocation)) {
xsiSchemaLocation = coreReader.Value;
}
else if (Ref.Equal(objectName, XsiNoNamespaceSchemaLocation)) {
xsiNoNamespaceSL = coreReader.Value;
}
else if (Ref.Equal(objectName, XsiType)) {
xsiType = coreReader.Value;
}
else if (Ref.Equal(objectName, XsiNil)) {
xsiNil = coreReader.Value;
}
}
if (manageNamespaces && Ref.Equal(coreReader.NamespaceURI, NsXmlNs)) {
nsManager.AddNamespace(coreReader.Prefix.Length == 0 ? string.Empty : coreReader.LocalName, coreReader.Value);
}
} while (coreReader.MoveToNextAttribute());
coreReader.MoveToElement();
}
validator.ValidateElement(coreReader.LocalName, coreReader.NamespaceURI, xmlSchemaInfo, xsiType, xsiNil, xsiSchemaLocation, xsiNoNamespaceSL);
ValidateAttributes();
validator.ValidateEndOfAttributes(xmlSchemaInfo);
if (coreReader.IsEmptyElement) {
ProcessEndElementEvent();
}
validationState = ValidatingReaderState.ClearAttributes;
}
}
private void ValidateElement() {
elementName.Init(reader.LocalName, XmlSchemaDatatype.XdrCanonizeUri(reader.NamespaceURI, NameTable, SchemaNames));
ValidateChildElement();
if (SchemaNames.IsXDRRoot(elementName.Name, elementName.Namespace) && reader.Depth > 0) {
inlineSchemaParser = new Parser(SchemaType.XDR, NameTable, SchemaNames, EventHandler);
inlineSchemaParser.StartParsing(reader, null);
inlineSchemaParser.ParseReaderNode();
}
else {
ProcessElement();
}
}
internal void Validate() {
if (inlineSchemaParser != null) {
if (!inlineSchemaParser.ParseReaderNode()) { // Done
XmlSchema schema = inlineSchemaParser.FinishParsing();
bool add = true;
if (schema != null) {
inlineNs = schema.TargetNamespace == null ? string.Empty : schema.TargetNamespace;
if (!SchemaInfo.HasSchema(inlineNs) && schema.ErrorCount == 0) {
schema.Compile(schemaCollection, nameTable, schemaNames, validationEventHandler, null, inlineSchemaInfo, true);
add = schema.ErrorCount == 0;
}
else {
add = false;
}
}
else {
inlineNs = inlineSchemaInfo.CurrentSchemaNamespace;
add = !SchemaInfo.HasSchema(inlineNs);
}
if (add) {
SchemaInfo.Add(inlineNs, inlineSchemaInfo, validationEventHandler);
schemaCollection.Add(inlineNs, inlineSchemaInfo, schema, false);
}
inlineSchemaParser = null;
inlineSchemaInfo = null;
inlineNs = null;
}
}
else {
this.name = QualifiedName(reader.Prefix, reader.LocalName, reader.NamespaceURI);
if (HasSchema) {
if (context != null) {
while (context != null && reader.Depth <= context.Depth) {
EndChildren();
}
ValidateElementContent(reader.NodeType);
}
if (reader.Depth == 0 && reader.NodeType == XmlNodeType.Element && SchemaInfo.SchemaType == SchemaType.DTD) {
if (!SchemaInfo.DocTypeName.Equals(this.name)) {
SendValidationEvent(Res.Sch_RootMatchDocType);
}
}
}
if (reader.NodeType == XmlNodeType.Element) {
if (schemaNames.IsSchemaRoot(this.name) &&
!SkipProcess(this.name == schemaNames.QnXsdSchema ? SchemaType.XSD : SchemaType.XDR) &&
IsCorrectSchemaType(this.name == schemaNames.QnXsdSchema ? SchemaType.XSD : SchemaType.XDR)) {
inlineSchemaInfo = new SchemaInfo(schemaNames);
inlineSchemaParser = new Parser(schemaCollection, nameTable, schemaNames, validationEventHandler);
inlineSchemaParser.StartParsing(reader, null, inlineSchemaInfo);
inlineSchemaParser.ParseReaderNode();
}
else {
ProcessElement();
}
}
}
}
private void ValidateElement() {
elementName.Init(reader.LocalName, reader.NamespaceURI);
object particle = ValidateChildElement ();
if (IsXSDRoot(elementName.Name, elementName.Namespace) && reader.Depth > 0) {
inlineSchemaParser = new Parser(SchemaType.XSD, NameTable, SchemaNames, EventHandler);
inlineSchemaParser.StartParsing(reader, null);
inlineSchemaParser.ParseReaderNode();
}
else {
ProcessElement(particle);
}
}
