httpstaticobjectscollection.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / httpstaticobjectscollection.cs / 1305376 / httpstaticobjectscollection.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 * Static objects collection for application and session state 
 * with deferred creation
 */ 
namespace System.Web {
    using System.Runtime.InteropServices;

    using System.Collections; 
    using System.Collections.Specialized;
    using System.IO; 
    using System.Web; 
    using System.Web.Util;
    using System.Security.Permissions; 

    //
    // Static objects collection class
    // 

    ///  
    ///    Provides a static objects collection for the 
    ///       HTTPApplicationState.StaticObjects and TemplateParser.SessionObjects properties.
    ///  
    public sealed class HttpStaticObjectsCollection : ICollection {
        private IDictionary _objects = new Hashtable(StringComparer.OrdinalIgnoreCase);

 
        /// 
        ///     
        ///       Initializes a new instance of the  
        ///       class.
        ///      
        /// 
        public HttpStaticObjectsCollection() {
        }
 
        internal void Add(String name, Type t, bool lateBound) {
            _objects.Add(name, new HttpStaticObjectsEntry(name, t, lateBound)); 
        } 

        // Expose the internal dictionary (for codegen purposes) 
        internal IDictionary Objects {
            get { return _objects;}
        }
 
        /*
         * Create a copy without copying instances (names and types only) 
         */ 
        internal HttpStaticObjectsCollection Clone() {
            HttpStaticObjectsCollection c = new HttpStaticObjectsCollection(); 

            IDictionaryEnumerator e = _objects.GetEnumerator();

            while (e.MoveNext()) { 
                HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)e.Value;
                c.Add(entry.Name, entry.ObjectType, entry.LateBound); 
            } 

            return c; 
        }

        /*
         * Get number of real instances created 
         */
        internal int GetInstanceCount() { 
            int count = 0; 

            IDictionaryEnumerator e = _objects.GetEnumerator(); 

            while (e.MoveNext()) {
                HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)e.Value;
 
                if (entry.HasInstance)
                    count++; 
            } 

            return count; 
        }


        ///  
        /// 
        public bool NeverAccessed { 
            get {return (GetInstanceCount() == 0);} 
        }
 
        //
        // Implementation of standard collection stuff
        //
 

        ///  
        ///    Gets the object in the collection with the given name (case 
        ///       insensitive). 
        ///  
        public Object this[String name]
        {
            get {
                HttpStaticObjectsEntry e = (HttpStaticObjectsEntry)_objects[name]; 
                return(e != null) ? e.Instance : null;
            } 
        } 

        // Alternative to the default property 

        /// 
        ///    Gets the object in the collection with the given name
        ///       (case insensitive). Alternative to the  accessor. 
        /// 
        public Object GetObject(String name) { 
            return this[name]; 
        }
 

        /// 
        ///    Gets the number of objects in the collection.
        ///  
        public int Count {
            get { 
                return _objects.Count; 
            }
        } 


        /// 
        ///    Returns a dictionary enumerator used for iterating through the key/value 
        ///       pairs contained in the collection.
        ///  
        public IEnumerator GetEnumerator() { 
            return new HttpStaticObjectsEnumerator((IDictionaryEnumerator)_objects.GetEnumerator());
        } 


        /// 
        ///    Copies members of the collection into an array. 
        /// 
        public void CopyTo(Array array, int index) { 
            for (IEnumerator e = this.GetEnumerator(); e.MoveNext();) 
                array.SetValue(e.Current, index++);
        } 


        /// 
        ///    Gets an object that can be used to synchronize access to the collection. 
        /// 
        public Object SyncRoot { 
            get { return this;} 
        }
 

        /// 
        ///    Gets a value indicating whether the collection is read-only.
        ///  
        public bool IsReadOnly {
            get { return true;} 
        } 

 
        /// 
        ///    Gets a value indicating whether the collection is synchronized.
        /// 
        public bool IsSynchronized { 
            get { return false;}
        } 
 

        public void Serialize(BinaryWriter writer) { 
            IDictionaryEnumerator   e;
            HttpStaticObjectsEntry  entry;
            bool                    hasInstance;
 
            writer.Write(Count);
 
            e = _objects.GetEnumerator(); 
            while (e.MoveNext()) {
                entry = (HttpStaticObjectsEntry)e.Value; 
                writer.Write(entry.Name);
                hasInstance = entry.HasInstance;
                writer.Write(hasInstance);
 
                if (hasInstance) {
                    AltSerialization.WriteValueToStream(entry.Instance, writer); 
                } 
                else {
                    writer.Write(entry.ObjectType.FullName); 
                    writer.Write(entry.LateBound);
                }
            }
        } 

 
        static public HttpStaticObjectsCollection Deserialize(BinaryReader reader) { 
            int     count;
            string  name; 
            string  typename;
            bool    hasInstance;
            Object  instance;
            HttpStaticObjectsEntry  entry; 
            HttpStaticObjectsCollection col;
 
            col = new HttpStaticObjectsCollection(); 

            count = reader.ReadInt32(); 
            while (count-- > 0) {
                name = reader.ReadString();
                hasInstance = reader.ReadBoolean();
                if (hasInstance) { 
                    instance = AltSerialization.ReadValueFromStream(reader);
                    entry = new HttpStaticObjectsEntry(name, instance, 0); 
                } 
                else {
                    typename = reader.ReadString(); 
                    bool lateBound = reader.ReadBoolean();
                    entry = new HttpStaticObjectsEntry(name, Type.GetType(typename), lateBound);
                }
 
                col._objects.Add(name, entry);
            } 
 
            return col;
        } 
    }

//
// Dictionary entry class 
//
 
    internal class HttpStaticObjectsEntry { 
        private String _name;
        private Type   _type; 
        private bool   _lateBound;
        private Object _instance;

        internal HttpStaticObjectsEntry(String name, Type t, bool lateBound) { 
            _name = name;
            _type = t; 
            _lateBound = lateBound; 
            _instance = null;
        } 

        internal HttpStaticObjectsEntry(String name, Object instance, int dummy) {
            _name = name;
            _type = instance.GetType(); 
            _instance = instance;
        } 
 
        internal String Name {
            get { return _name;} 
        }

        internal Type ObjectType {
            get { return _type;} 
        }
 
        internal bool LateBound { 
            get { return _lateBound;}
        } 

        internal Type DeclaredType {
            get { return _lateBound ? typeof(object) : ObjectType; }
        } 

        internal bool HasInstance { 
            get { return(_instance != null);} 
        }
 
        internal Object Instance {
            get {
                if (_instance == null) {
                    lock (this) { 
                        if (_instance == null)
                            _instance = Activator.CreateInstance(_type); 
                    } 
                }
 
                return _instance;
            }
        }
    } 

    // 
    // Enumerator class for static objects collection 
    //
    internal class HttpStaticObjectsEnumerator : IDictionaryEnumerator { 
        private IDictionaryEnumerator _enum;

        internal HttpStaticObjectsEnumerator(IDictionaryEnumerator e) {
            _enum = e; 
        }
 
        // Dictionary enumarator implementation 

        public void Reset() { 
            _enum.Reset();
        }

        public bool MoveNext() { 
            return _enum.MoveNext();
        } 
 
        public Object Key {
            get { 
                return _enum.Key;
            }
        }
 
        public Object Value {
            get { 
                HttpStaticObjectsEntry e = (HttpStaticObjectsEntry)_enum.Value; 

                if (e == null) 
                    return null;

                return e.Instance;
            } 
        }
 
        public Object Current { 
            get {
                return Entry; 
            }
        }

        public DictionaryEntry Entry { 
            get {
                return new DictionaryEntry(_enum.Key, this.Value); 
            } 
        }
    } 

}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
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
httpstaticobjectscollection.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
