public void TestAdd ()
		{
			XmlSchemaCollection col = new XmlSchemaCollection ();
			XmlSchema schema = new XmlSchema ();
			XmlSchemaElement elem = new XmlSchemaElement ();
			elem.Name = "foo";
			schema.Items.Add (elem);
			schema.TargetNamespace = "urn:foo";
			col.Add (schema);
			col.Add (schema);	// No problem !?

			XmlSchema schema2 = new XmlSchema ();
			schema2.Items.Add (elem);
			schema2.TargetNamespace = "urn:foo";
			col.Add (schema2);	// No problem !!

			schema.Compile (null);
			col.Add (schema);
			col.Add (schema);	// Still no problem !!!

			schema2.Compile (null);
			col.Add (schema2);

			schema = GetSchema ("Test/XmlFiles/xsd/3.xsd");
			schema.Compile (null);
			col.Add (schema);

			schema2 = GetSchema ("Test/XmlFiles/xsd/3.xsd");
			schema2.Compile (null);
			col.Add (schema2);
		}

        public bool Execute(XmlSchema schema, string targetNamespace, bool loadExternals, XmlSchemaCollection xsc) {
            this.schema = schema;
            Xmlns = NameTable.Add("xmlns");

            Cleanup(schema);
            if (loadExternals && xmlResolver != null) {
                schemaLocations = new Hashtable(); //new Dictionary<Uri, Uri>();
                if (schema.BaseUri != null) {
                    schemaLocations.Add(schema.BaseUri, schema.BaseUri);
                }
                LoadExternals(schema, xsc);
            }
            ValidateIdAttribute(schema);
            Preprocess(schema, targetNamespace, Compositor.Root);
            if (!HasErrors) {
                schema.IsPreprocessed = true;
                for (int i = 0; i < schema.Includes.Count; ++i) {
                    XmlSchemaExternal include = (XmlSchemaExternal)schema.Includes[i];
                    if (include.Schema != null) {
                        include.Schema.IsPreprocessed = true;
                    }
                }
            }
            return !HasErrors;
        }

        private string consultaNFe()
        {
            XmlSchemaCollection myschema = new XmlSchemaCollection();
            string sxdoc = "";
            XNamespace pf = "http://www.portalfiscal.inf.br/nfe";

            try
            {
                XDocument xdoc = new XDocument(new XElement(pf + "consSitNFe", new XAttribute("versao", sversaoLayoutCons),//sversaoLayoutCons),
                                                  new XElement(pf + "tpAmb", Acesso.TP_AMB.ToString()),
                                                   new XElement(pf + "xServ", "CONSULTAR"),
                                                   new XElement(pf + "chNFe", objPesquisa.sCHAVENFE)));

                string sCaminhoConsulta = Pastas.PROTOCOLOS + "Consulta_" + objPesquisa.sCHAVENFE + ".xml";
                if (File.Exists(sCaminhoConsulta))
                {
                    File.Delete(sCaminhoConsulta);
                }
                StreamWriter writer = new StreamWriter(sCaminhoConsulta);
                writer.Write(xdoc.ToString());
                writer.Close();
                //belValidaXml.ValidarXml("http://www.portalfiscal.inf.br/nfe", Pastas.SCHEMA_NFE + "\\2.01\\consSitNFe_v2.01.xsd", sCaminhoConsulta);
                sxdoc = xdoc.ToString();

            }
            catch (XmlException x)
            {
                throw new Exception(x.Message.ToString());
            }
            catch (XmlSchemaException x)
            {
                throw new Exception(x.Message.ToString());
            }
            return sxdoc;
        }

        /// <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);
            }
        }

 public clsSValidator(string sXMLFileName, string sSchemaFileName)
 {
     m_sXMLFileName = sXMLFileName;
     m_sSchemaFileName = sSchemaFileName;
     m_objXmlSchemaCollection = new XmlSchemaCollection ();
     //adding the schema file to the newly created schema collection
     m_objXmlSchemaCollection.Add (null, m_sSchemaFileName);
 }

		public void TestAddDoesCompilation ()
		{
			XmlSchema schema = new XmlSchema ();
			Assert (!schema.IsCompiled);
			XmlSchemaCollection col = new XmlSchemaCollection ();
			col.Add (schema);
			Assert (schema.IsCompiled);
		}

        public NSTScorePartwise ParseString(string dataString)
        {
            //todo: parse string
            IList<NSTPart> partList = new List<NSTPart>();
            XmlTextReader textReader = new XmlTextReader(new FileStream("C:\\NM\\ScoreTranscription\\NETScoreTranscription\\NETScoreTranscriptionLibrary\\OtherDocs\\musicXML.xsd", System.IO.FileMode.Open)); //todo: pass stream in instead of absolute location for unit testing
            XmlSchemaCollection schemaCollection = new XmlSchemaCollection();
            schemaCollection.Add(null, textReader);

            NSTScorePartwise score;

            using (XmlValidatingReader reader = new XmlValidatingReader(XmlReader.Create(new StringReader(dataString), new XmlReaderSettings() { DtdProcessing = DtdProcessing.Parse }))) //todo: make unobsolete
            {
                reader.Schemas.Add(schemaCollection);
                reader.ValidationType = ValidationType.Schema;
                reader.ValidationEventHandler += new System.Xml.Schema.ValidationEventHandler(ValidationEventHandler);

                XmlSerializer serializer = new XmlSerializer(typeof(NSTScorePartwise), new XmlRootAttribute("score-partwise"));
                score = (NSTScorePartwise)serializer.Deserialize(reader);

                /*
                while (reader.Read())
                {
                    if (reader.IsEmptyElement)
                        throw new Exception(reader.Value); //todo: test

                    switch (reader.NodeType)
                    {
                        case XmlNodeType.Element:
                            switch (reader.Name.ToLower())
                            {
                                case "part-list":
                                    break;
                                case "score-partwise":
                                    break;
                                case "part-name":
                                    throw new Exception("pn");
                                    break;
                            }
                            break;
                        case XmlNodeType.Text:

                            break;
                        case XmlNodeType.XmlDeclaration:
                        case XmlNodeType.ProcessingInstruction:

                            break;
                        case XmlNodeType.Comment:

                            break;
                        case XmlNodeType.EndElement:

                            break;
                    }
                }*/
            }

            return score;
        }

        /// <summary>
        /// Instantiate a new XmlSchemaCompiler class.
        /// </summary>
        /// <param name="outputDir">The output directory for all compiled files.</param>
        /// <param name="versionNumber">The version number to append to Elements.</param>
        public XmlSchemaCompiler(string outputDir, string versionNumber)
        {
            this.outputDir = outputDir;
            this.versionNumber = versionNumber;

            this.elements = new Hashtable();
            this.schemaFiles = new StringCollection();
            this.schemas = new XmlSchemaCollection();
        }

        /// <summary>
        /// Instantiate a new XmlSchemaCompiler class.
        /// </summary>
        /// <param name="outputDir">The output directory for all compiled files.</param>
        public XmlSchemaCompiler(string outputDir)
        {
            this.mainSchemas = new XmlSchemaCollection();
            this.outputDir = outputDir;

            this.elements = new Hashtable();
            this.attributes = new Hashtable();
            this.schemas = new XmlSchemaCollection();
        }

 public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) {
     Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
     this.reader = reader;
     this.schemaCollection = schemaCollection;
     this.eventHandling = eventHandling;
     nameTable = reader.NameTable;
     positionInfo = PositionInfo.GetPositionInfo(reader);
     elementName = new XmlQualifiedName();
 }

 public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling)
 {
     this.reader = reader;
     this.schemaCollection = schemaCollection;
     this.eventHandling = eventHandling;
     this.nameTable = reader.NameTable;
     this.positionInfo = System.Xml.PositionInfo.GetPositionInfo(reader);
     this.elementName = new XmlQualifiedName();
 }

        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();
        }

		/// <summary>
		/// Gets an appropriate <see cref="System.Xml.XmlReader"/> implementation
		/// for the supplied <see cref="System.IO.Stream"/>.
		/// </summary>
		/// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param>
		/// <param name="xmlResolver"><see cref="XmlResolver"/> to be used for resolving external references</param>
		/// <param name="schemas">XML schemas that should be used for validation.</param>
		/// <param name="eventHandler">Validation event handler.</param>
		/// <returns>
		/// A validating <see cref="System.Xml.XmlReader"/> implementation.
		/// </returns>
		public static XmlReader CreateValidatingReader(Stream stream, XmlResolver xmlResolver, XmlSchemaCollection schemas, ValidationEventHandler eventHandler)
		{
			XmlValidatingReader reader = new XmlValidatingReader(new XmlTextReader(stream));
			reader.XmlResolver = xmlResolver;
			reader.Schemas.Add(schemas);
			reader.ValidationType = ValidationType.Schema;
			if (eventHandler != null)
			{
				reader.ValidationEventHandler += eventHandler;
			}
			return reader;
		}

        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;
        }

        //[Variation(Desc = "v2 - Contains with not added schema")]
        public void v2()
        {
            XmlSchemaSet sc = new XmlSchemaSet();
#pragma warning disable 0618
            XmlSchemaCollection scl = new XmlSchemaCollection();
#pragma warning restore 0618

            XmlSchema Schema = scl.Add(null, TestData._XsdAuthor);

            Assert.Equal(sc.Contains(Schema), false);

            return;
        }

        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);
            }
        }

 public void Add(XmlSchemaCollection schema)
 {
     if (schema == null)
     {
         throw new ArgumentNullException("schema");
     }
     if (this != schema)
     {
         IDictionaryEnumerator enumerator = schema.collection.GetEnumerator();
         while (enumerator.MoveNext())
         {
             XmlSchemaCollectionNode node = (XmlSchemaCollectionNode) enumerator.Value;
             this.Add(node.NamespaceURI, node);
         }
     }
 }

		#pragma warning restore 618

		static CodeFormatter()
		{
			//Load the schema collection.
			var resource =
				typeof (CodeFormatter)
					.Assembly
					.GetManifestResourceStream("Rsdn.Framework.Formatting.CodeFormat.Patterns.PatternSchema.xsd");
			Debug.Assert(resource != null);
			#pragma warning disable 618
			_xmlSchemas =
				new XmlSchemaCollection
				{
					XmlSchema.Read(resource, null)
				};
			#pragma warning restore 618
		}

		protected override XmlValidatingReader GetReader() {
			if (LogDispatcher != null)
				LogDispatcher.DispatchLog("XSLTRulesFileDriver loading "+xmlSource, LogEventImpl.INFO);
			
			XmlReader fileReader = GetXmlInputReader(xmlSource, inputXMLSchema);

	  	MemoryStream stream = new MemoryStream();
	  	GetXSLT().Transform(new XPathDocument(fileReader), null, stream, null);
			fileReader.Close();
	  	stream.Seek(0, SeekOrigin.Begin);
			XmlSchemaCollection schemas = new XmlSchemaCollection();
			
	    XmlValidatingReader streamReader = (XmlValidatingReader) GetXmlInputReader(stream,
                                                                                   Parameter.GetString("businessrules.xsd", "resource.businessRules.xsd"));
			return streamReader;
		}

        /// <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;
            }
        }