Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.Web/httpstaticobjectscollection.cs

@@ -0,0 +1,336 @@
+//------------------------------------------------------------------------------
+// <copyright file="httpstaticobjectscollection.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+/*
+ * 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
+    //
+
+    /// <devdoc>
+    ///    <para>Provides a static objects collection for the 
+    ///       HTTPApplicationState.StaticObjects and TemplateParser.SessionObjects properties.</para>
+    /// </devdoc>
+    public sealed class HttpStaticObjectsCollection : ICollection {
+        private IDictionary _objects = new Hashtable(StringComparer.OrdinalIgnoreCase);
+
+
+        /// <devdoc>
+        ///    <para>
+        ///       Initializes a new instance of the <see cref='System.Web.HttpStaticObjectsCollection'/>
+        ///       class.
+        ///     </para>
+        /// </devdoc>
+        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;
+        }
+
+
+        /// <devdoc>
+        /// </devdoc>
+        public bool NeverAccessed {
+            get {return (GetInstanceCount() == 0);}
+        }
+
+        //
+        // Implementation of standard collection stuff
+        //
+
+
+        /// <devdoc>
+        ///    <para>Gets the object in the collection with the given name (case 
+        ///       insensitive). </para>
+        /// </devdoc>
+        public Object this[String name]
+        {
+            get {
+                HttpStaticObjectsEntry e = (HttpStaticObjectsEntry)_objects[name];
+                return(e != null) ? e.Instance : null;
+            }
+        }
+
+        // Alternative to the default property
+
+        /// <devdoc>
+        ///    <para>Gets the object in the collection with the given name 
+        ///       (case insensitive). Alternative to the <paramref name="this"/> accessor.</para>
+        /// </devdoc>
+        public Object GetObject(String name) {
+            return this[name];
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets the number of objects in the collection.</para>
+        /// </devdoc>
+        public int Count {
+            get {
+                return _objects.Count;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>Returns a dictionary enumerator used for iterating through the key/value 
+        ///       pairs contained in the collection.</para>
+        /// </devdoc>
+        public IEnumerator GetEnumerator() {
+            return new HttpStaticObjectsEnumerator((IDictionaryEnumerator)_objects.GetEnumerator());
+        }
+
+
+        /// <devdoc>
+        ///    <para>Copies members of the collection into an array.</para>
+        /// </devdoc>
+        public void CopyTo(Array array, int index) {
+            for (IEnumerator e = this.GetEnumerator(); e.MoveNext();)
+                array.SetValue(e.Current, index++);
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets an object that can be used to synchronize access to the collection.</para>
+        /// </devdoc>
+        public Object SyncRoot {
+            get { return this;}
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets a value indicating whether the collection is read-only.</para>
+        /// </devdoc>
+        public bool IsReadOnly {
+            get { return true;}
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets a value indicating whether the collection is synchronized.</para>
+        /// </devdoc>
+        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);
+            }
+        }
+    }
+
+}