XmlSchemaCollection.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / Xml / System / Xml / schema / XmlSchemaCollection.cs / 1 / XmlSchemaCollection.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Schema { 

    using System; 
    using System.Threading;
    using System.Collections;
    using System.Xml.Schema;
 

    ///  
    ///  
    ///    The XmlSchemaCollection contains a set of namespace URI's.
    ///       Each namespace also have an associated private data cache 
    ///       corresponding to the XML-Data Schema or W3C XML Schema.
    ///       The XmlSchemaCollection will able to load XSD and XDR schemas,
    ///       and compile them into an internal "cooked schema representation".
    ///       The Validate method then uses this internal representation for 
    ///       efficient runtime validation of any given subtree.
    ///  
    [Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. http://go.microsoft.com/fwlink/?linkid=14202")] 
    public sealed class XmlSchemaCollection: ICollection {
        private Hashtable               collection; 
        private XmlNameTable            nameTable;
        private SchemaNames             schemaNames;
        private ReaderWriterLock        wLock;
        private int                     timeout = Timeout.Infinite; 
        private bool                    isThreadSafe = true;
        private ValidationEventHandler  validationEventHandler = null; 
        private XmlResolver             xmlResolver = null; 

 
        /// 
        /// 
        ///    Construct a new empty schema collection.
        ///  
        public XmlSchemaCollection() : this(new NameTable()) {
        } 
 
        /// 
        ///  
        ///    Construct a new empty schema collection with associated XmlNameTable.
        ///       The XmlNameTable is used when loading schemas
        /// 
        public XmlSchemaCollection(XmlNameTable nametable) { 
            if (nametable == null) {
                throw new ArgumentNullException("nametable"); 
            } 
            nameTable = nametable;
            collection = Hashtable.Synchronized(new Hashtable()); 
            xmlResolver = new XmlUrlResolver();
            isThreadSafe = true;
            if (isThreadSafe) {
                wLock = new ReaderWriterLock(); 
            }
        } 
 
        /// 
        ///  
        ///    Returns the number of namespaces defined in this collection
        ///       (whether or not there is an actual schema associated with those namespaces or not).
        /// 
        public int Count { 
            get { return collection.Count;}
        } 
 
        /// 
        ///  
        ///    The default XmlNameTable used by the XmlSchemaCollection when loading new schemas.
        /// 
        public XmlNameTable NameTable {
            get { return nameTable;} 
        }
 
        ///  
        public  event ValidationEventHandler ValidationEventHandler {
            add { validationEventHandler += value; } 
            remove { validationEventHandler -= value; }
        }

        internal XmlResolver XmlResolver 
        {
            set { 
                xmlResolver = value; 
            }
        } 


        /// 
        ///  
        ///    Add the schema located by the given URL into the schema collection.
        ///       If the given schema references other namespaces, the schemas for those other 
        ///       namespaces are NOT automatically loaded. 
        /// 
        public XmlSchema Add(string ns, string uri) { 
            if (uri == null || uri.Length == 0)
                throw new ArgumentNullException("uri");
            XmlTextReader reader = new XmlTextReader(uri, nameTable);
            reader.XmlResolver = xmlResolver; 

            XmlSchema schema = null; 
            try { 
                schema = Add(ns, reader, xmlResolver);
                while(reader.Read());// wellformness check 
            }
            finally {
                reader.Close();
            } 
            return schema;
        } 
 
 	/// 
        public XmlSchema Add(String ns, XmlReader reader) { 
	    return Add(ns, reader, xmlResolver);	
	}

        ///  
        /// 
        ///    Add the given schema into the schema collection. 
        ///       If the given schema references other namespaces, the schemas for those 
        ///       other namespaces are NOT automatically loaded.
        ///  
        public XmlSchema Add(String ns, XmlReader reader, XmlResolver resolver) {
            if (reader == null)
                throw new ArgumentNullException("reader");
            XmlNameTable readerNameTable = reader.NameTable; 
            SchemaInfo schemaInfo = new SchemaInfo();
	 
            Parser parser = new Parser(SchemaType.None, readerNameTable, GetSchemaNames(readerNameTable), validationEventHandler); 
            parser.XmlResolver = resolver;
            SchemaType schemaType; 
            try {
                schemaType = parser.Parse(reader, ns);
            }
            catch (XmlSchemaException e) { 
                SendValidationEvent(e);
                return null; 
            } 

            if (schemaType == SchemaType.XSD) { 
 				schemaInfo.SchemaType = SchemaType.XSD;
                return Add(ns, schemaInfo, parser.XmlSchema, true, resolver);
            }
            else { 
                SchemaInfo xdrSchema = parser.XdrSchema;
                return Add(ns, parser.XdrSchema, null, true, resolver); 
            } 
        }
 
        /// 
        /// 
        ///    [To be supplied.]
        ///  
        public XmlSchema Add(XmlSchema schema) {
			return Add(schema, xmlResolver); 
        } 

        ///  
 	    public XmlSchema Add(XmlSchema schema, XmlResolver resolver) {
            if (schema == null)
                throw new ArgumentNullException("schema");
 
            SchemaInfo schemaInfo = new SchemaInfo();
            schemaInfo.SchemaType = SchemaType.XSD; 
            return Add(schema.TargetNamespace, schemaInfo, schema, true, resolver); 
        }
 
        /// 
        /// 
        ///    Adds all the namespaces defined in the given collection
        ///       (including their associated schemas) to this collection. 
        /// 
        public void Add(XmlSchemaCollection schema) { 
            if (schema == null) 
                throw new ArgumentNullException("schema");
            if (this == schema) 
                return;
            IDictionaryEnumerator enumerator = schema.collection.GetEnumerator();
            while (enumerator.MoveNext()) {
                XmlSchemaCollectionNode node = (XmlSchemaCollectionNode) enumerator.Value; 
                Add(node.NamespaceURI, node);
            } 
        } 

 
        /// 
        /// 
        ///    Looks up the schema by it's associated namespace URI
        ///  
        public XmlSchema this[string ns] {
            get { 
                XmlSchemaCollectionNode node = (XmlSchemaCollectionNode)collection[(ns != null) ? ns: string.Empty]; 
                return (node != null) ? node.Schema : null;
            } 
        }

        /// 
        ///  
        ///    [To be supplied.]
        ///  
        public bool Contains(XmlSchema schema) { 
            if (schema == null) {
                throw new ArgumentNullException("schema"); 
            }
            return this[schema.TargetNamespace] != null;
        }
 
        /// 
        public bool Contains(string ns) { 
            return collection[(ns != null) ? ns : string.Empty] != null; 
        }
 
        /// 
        /// 
        /// 
        /// Get a IEnumerator of the XmlSchemaCollection. 
        /// 
        IEnumerator IEnumerable.GetEnumerator() { 
            return new XmlSchemaCollectionEnumerator(collection); 
        }
 
        /// 
        public XmlSchemaCollectionEnumerator GetEnumerator() {
            return new XmlSchemaCollectionEnumerator(collection);
        } 

        ///  
        ///  
        void ICollection.CopyTo(Array array, int index) {
            if (array == null) 
                throw new ArgumentNullException("array");
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");
            for (XmlSchemaCollectionEnumerator e = this.GetEnumerator(); e.MoveNext();) { 
                if (index == array.Length && array.IsFixedSize) {
                    throw new ArgumentOutOfRangeException("index"); 
                } 
                array.SetValue(e.Current, index++);
            } 
        }

        /// 
        ///  
        ///    [To be supplied.]
        ///  
        public void CopyTo(XmlSchema[] array, int index) { 
            if (array == null)
                throw new ArgumentNullException("array"); 
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");
            for (XmlSchemaCollectionEnumerator e = this.GetEnumerator(); e.MoveNext();) {
                XmlSchema schema = e.Current; 
                if (schema != null) {
                    if (index == array.Length) { 
                        throw new ArgumentOutOfRangeException("index"); 
                    }
                    array[index++] = e.Current; 
                }
            }
        }
 
        /// 
        ///  
        bool ICollection.IsSynchronized { 
            get { return true; }
        } 

        /// 
        /// 
        object ICollection.SyncRoot { 
            get { return this; }
        } 
 
        /// 
        ///  
        int ICollection.Count {
            get { return collection.Count; }
        }
 
        internal SchemaInfo GetSchemaInfo(string ns) {
            XmlSchemaCollectionNode node = (XmlSchemaCollectionNode)collection[(ns != null) ? ns : string.Empty]; 
            return (node != null) ? node.SchemaInfo : null; 
        }
 
        internal SchemaNames GetSchemaNames(XmlNameTable nt) {
            if (nameTable != nt) {
                return new SchemaNames(nt);
            } 
            else {
                if (schemaNames == null) { 
                    schemaNames = new SchemaNames( nameTable ); 
                }
                return schemaNames; 
            }
        }

        internal XmlSchema Add(string ns, SchemaInfo schemaInfo, XmlSchema schema, bool compile) { 
 		return Add(ns, schemaInfo, schema, compile, xmlResolver);
	} 
 
        private XmlSchema Add(string ns, SchemaInfo schemaInfo, XmlSchema schema, bool compile, XmlResolver resolver) {
            int errorCount = 0; 
            if (schema != null) {
                if (schema.ErrorCount == 0 && compile) {
 					if (!schema.CompileSchema(this, resolver, schemaInfo, ns, validationEventHandler, nameTable, true)) {
						errorCount = 1; 
					}
					ns = schema.TargetNamespace == null ? string.Empty : schema.TargetNamespace; 
                } 
 				errorCount += schema.ErrorCount;
            } 
            else {
                errorCount += schemaInfo.ErrorCount;
                //ns = ns == null? string.Empty : NameTable.Add(ns);
                ns = NameTable.Add(ns); //Added without checking for ns == null, since XDR cannot have null namespace 
            }
            if (errorCount == 0) { 
                XmlSchemaCollectionNode node = new XmlSchemaCollectionNode(); 
                node.NamespaceURI = ns;
                node.SchemaInfo = schemaInfo; 
				node.Schema = schema;
                Add(ns, node);
                return schema;
            } 
            return null;
        } 
 
        private void Add(string ns, XmlSchemaCollectionNode node) {
            if (isThreadSafe) 
                wLock.AcquireWriterLock(timeout);
            try {
                if (collection[ns] != null)
                    collection.Remove(ns); 
                collection.Add(ns, node);
            } 
            finally { 
                if (isThreadSafe)
                    wLock.ReleaseWriterLock(); 
            }
        }

        private void SendValidationEvent(XmlSchemaException e) { 
            if (validationEventHandler != null) {
                validationEventHandler(this, new ValidationEventArgs(e)); 
            } 
            else {
                throw e; 
            }
        }

        internal ValidationEventHandler EventHandler { 
            get {
                return validationEventHandler; 
            } 
            set {
                validationEventHandler = value; 
            }
        }
    };
 

    internal sealed class XmlSchemaCollectionNode { 
        private String      namespaceUri; 
        private SchemaInfo  schemaInfo;
        private XmlSchema   schema; 

        internal String NamespaceURI {
            get { return namespaceUri;}
            set { namespaceUri = value;} 
        }
 
        internal SchemaInfo SchemaInfo { 
            get { return schemaInfo;}
            set { schemaInfo = value;} 
        }

        internal XmlSchema Schema {
            get { return schema;} 
            set { schema = value;}
        } 
} 

 
    /// 
    /// 
    ///    [To be supplied.]
    ///  
    public sealed class XmlSchemaCollectionEnumerator: IEnumerator {
        private IDictionaryEnumerator     enumerator; 
 
        internal XmlSchemaCollectionEnumerator( Hashtable collection ) {
            enumerator = collection.GetEnumerator(); 
        }

        /// 
        ///  
        void IEnumerator.Reset() {
            enumerator.Reset(); 
        } 

        ///  
        /// 
        bool IEnumerator.MoveNext() {
            return enumerator.MoveNext();
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        public bool MoveNext() {
            return enumerator.MoveNext();
        }
 
        /// 
        ///  
        object IEnumerator.Current { 
            get { return this.Current; }
        } 

        /// 
        /// 
        ///    [To be supplied.] 
        /// 
        public XmlSchema Current { 
            get { 
                XmlSchemaCollectionNode n = (XmlSchemaCollectionNode)enumerator.Value;
                if (n != null) 
                    return n.Schema;
                else
                    return null;
            } 
        }
 
        internal XmlSchemaCollectionNode CurrentNode { 
            get {
                XmlSchemaCollectionNode n = (XmlSchemaCollectionNode)enumerator.Value; 
                return n;
            }
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK