XmlSchemaCollection.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / schema / XmlSchemaCollection.cs / 1305376 / 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;
    using System.Runtime.Versioning; 

 
    ///  
    /// 
    ///    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.
        ///  
        [ResourceConsumption(ResourceScope.Machine)]
        [ResourceExposure(ResourceScope.Machine)]
        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.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Schema { 

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

 
    ///  
    /// 
    ///    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.
        ///  
        [ResourceConsumption(ResourceScope.Machine)]
        [ResourceExposure(ResourceScope.Machine)]
        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.

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• XmlSchemaSubstitutionGroup.cs
• Closure.cs
• SqlUtil.cs
• DataViewManagerListItemTypeDescriptor.cs
• _BufferOffsetSize.cs
• CodeTypeReferenceCollection.cs
• ComboBoxItem.cs
• IResourceProvider.cs
• SapiRecognizer.cs
• BamlBinaryWriter.cs
• HostedElements.cs
• LocationSectionRecord.cs
• TCPClient.cs
• XmlIncludeAttribute.cs
• StrokeRenderer.cs
• ListenUriMode.cs
• DataKeyCollection.cs
• XmlRawWriter.cs
• MeasureItemEvent.cs
• ServiceBuildProvider.cs
• FrameworkContentElementAutomationPeer.cs
• RecordManager.cs
• QuaternionKeyFrameCollection.cs
• DesignerForm.cs
• ServiceInstallComponent.cs
• SkipStoryboardToFill.cs
• XmlSchemaValidator.cs
• FreezableDefaultValueFactory.cs
• Visitor.cs
• EventBuilder.cs
• ScrollItemPatternIdentifiers.cs
• WebPartRestoreVerb.cs
• TextServicesHost.cs
• PKCS1MaskGenerationMethod.cs
• KeyValueSerializer.cs
• ReadOnlyObservableCollection.cs
• ColorAnimationBase.cs
• InternalRelationshipCollection.cs
• ErrorTableItemStyle.cs
• XpsS0ValidatingLoader.cs
• Comparer.cs
• SectionVisual.cs
• peersecuritysettings.cs
• VersionPair.cs
• MetabaseSettings.cs
• ADRole.cs
• AsymmetricAlgorithm.cs
• WebPageTraceListener.cs
• StrokeCollectionConverter.cs
• AuthenticateEventArgs.cs
• ResourceSet.cs
• Int64Converter.cs
• ServiceOperationHelpers.cs
• SingleAnimation.cs
• PackageRelationshipSelector.cs
• FillBehavior.cs
• DocumentOrderQuery.cs
• XamlSerializerUtil.cs
• Speller.cs
• DataSourceProvider.cs
• DataGridViewCell.cs
• DropTarget.cs
• JournalEntry.cs
• ApplicationBuildProvider.cs
• XmlStreamStore.cs
• IconBitmapDecoder.cs
• DbConnectionFactory.cs
• CodeValidator.cs
• XPathMultyIterator.cs
• CardSpaceSelector.cs
• HMACRIPEMD160.cs
• SoapExtension.cs
• PropertyEmitterBase.cs
• SplitterCancelEvent.cs
• RectAnimation.cs
• LinkUtilities.cs
• SerializationObjectManager.cs
• XmlFormatWriterGenerator.cs
• FlowDocumentReader.cs
• AnonymousIdentificationSection.cs
• OutputCacheSection.cs
• AtomicFile.cs
• PointHitTestResult.cs
• TcpDuplicateContext.cs
• WebServicesSection.cs
• AutoSizeToolBoxItem.cs
• DataKeyArray.cs
• RecordBuilder.cs
• WindowsTooltip.cs
• PropertyEntry.cs
• EditBehavior.cs
• WebMessageEncoderFactory.cs
• FullTrustAssembly.cs
• IndependentlyAnimatedPropertyMetadata.cs
• DataObjectFieldAttribute.cs
• NotificationContext.cs
• WmlPhoneCallAdapter.cs
• MaxValueConverter.cs
• MetadataArtifactLoaderResource.cs
• DelegateSerializationHolder.cs