XmlSchemaCollection.cs source code in C# .NET

                        
Code:
                         / Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / 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.
// 
// [....] 
//-----------------------------------------------------------------------------
 
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.

                        

                        

                        
                        

Link Menu

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

• ConstructorBuilder.cs
• SqlConnectionPoolProviderInfo.cs
• TextParaClient.cs
• LocalizationComments.cs
• CodeArgumentReferenceExpression.cs
• RijndaelCryptoServiceProvider.cs
• PageBuildProvider.cs
• CatalogPart.cs
• XmlAnyElementAttribute.cs
• shaperfactory.cs
• ViewCellSlot.cs
• Pkcs7Recipient.cs
• HandlerFactoryWrapper.cs
• CompiledQuery.cs
• XmlSchemaCompilationSettings.cs
• LongValidator.cs
• XmlSchemaIdentityConstraint.cs
• Clock.cs
• SqlConnection.cs
• EncoderParameters.cs
• ResourceIDHelper.cs
• SQLDateTimeStorage.cs
• Pkcs7Recipient.cs
• QilExpression.cs
• CachedPathData.cs
• DescriptionAttribute.cs
• SchemaContext.cs
• ForceCopyBuildProvider.cs
• ToolStripPanel.cs
• WeakReferenceKey.cs
• UnsafeNativeMethods.cs
• CdpEqualityComparer.cs
• SmiContextFactory.cs
• MemberPath.cs
• StringArrayConverter.cs
• XmlHierarchicalEnumerable.cs
• ListViewPagedDataSource.cs
• ToolstripProfessionalRenderer.cs
• ServiceHttpModule.cs
• SetterBase.cs
• CustomGrammar.cs
• PropertyPathConverter.cs
• ToolStripItemBehavior.cs
• ParameterCollection.cs
• GlyphingCache.cs
• PathGeometry.cs
• TreeNode.cs
• TimeStampChecker.cs
• FormatterServices.cs
• XmlSerializableServices.cs
• TableLayoutPanelCellPosition.cs
• Encoder.cs
• Set.cs
• ADConnectionHelper.cs
• XsdBuilder.cs
• TemplateAction.cs
• SortedList.cs
• CalendarDay.cs
• AliasedSlot.cs
• VisualTarget.cs
• DataGridCellsPresenter.cs
• RangeContentEnumerator.cs
• DataGridViewAccessibleObject.cs
• ControlParameter.cs
• XmlEntityReference.cs
• AssociationSetMetadata.cs
• ChtmlTextWriter.cs
• GeneralTransform3DGroup.cs
• DataGridColumnHeaderItemAutomationPeer.cs
• DirectoryRootQuery.cs
• BinaryReader.cs
• BitmapEffect.cs
• Wildcard.cs
• XmlComment.cs
• CodeObject.cs
• ItemAutomationPeer.cs
• DataBindingHandlerAttribute.cs
• EntryPointNotFoundException.cs
• BindableTemplateBuilder.cs
• AppDomainCompilerProxy.cs
• UInt32.cs
• CleanUpVirtualizedItemEventArgs.cs
• AsymmetricSignatureDeformatter.cs
• WorkflowOwnerAsyncResult.cs
• ScrollContentPresenter.cs
• ServiceMemoryGates.cs
• ButtonStandardAdapter.cs
• DataGridViewRowCancelEventArgs.cs
• FloaterParagraph.cs
• StylusPointDescription.cs
• MouseCaptureWithinProperty.cs
• SecurityValidationBehavior.cs
• WsiProfilesElementCollection.cs
• UrlAuthorizationModule.cs
• TextBoxBase.cs
• CodeThrowExceptionStatement.cs
• StandardOleMarshalObject.cs
• SiteMapHierarchicalDataSourceView.cs
• ArgumentDirectionHelper.cs
• BitmapPalettes.cs