Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/State/SessionStateContainer.cs

@@ -0,0 +1,325 @@
+//------------------------------------------------------------------------------
+// <copyright file="SessionState.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+/*
+ * HttpSessionState
+ * 
+ * Copyright (c) 1998-1999, Microsoft Corporation
+ * 
+ */
+
+namespace System.Web.SessionState {
+
+    using System.Threading;
+    using System.Runtime.InteropServices;
+    using System.Web;
+    using System.Web.Util;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Text;
+    using System.Globalization;
+    using System.Security.Permissions;
+
+    public class HttpSessionStateContainer : IHttpSessionState {
+        String                      _id;
+        ISessionStateItemCollection      _sessionItems;
+        HttpStaticObjectsCollection _staticObjects;
+        int                         _timeout;
+        bool                        _newSession;
+        HttpCookieMode              _cookieMode;
+        SessionStateMode            _mode;
+        bool                        _abandon;
+        bool                        _isReadonly;
+        SessionStateModule          _stateModule;   // used for optimized InProc session id callback
+
+        public HttpSessionStateContainer(
+                                 String                      id, 
+                                 ISessionStateItemCollection sessionItems,
+                                 HttpStaticObjectsCollection staticObjects,
+                                 int                         timeout,
+                                 bool                        newSession,
+                                 HttpCookieMode              cookieMode,
+                                 SessionStateMode            mode,
+                                 bool                        isReadonly) 
+            : this(null, id, sessionItems, staticObjects, timeout, newSession, cookieMode, mode, isReadonly) {
+            if (id == null) {
+                throw new ArgumentNullException("id");
+            }
+        }
+
+        internal HttpSessionStateContainer(
+                                 SessionStateModule          stateModule, 
+                                 string                      id,
+                                 ISessionStateItemCollection      sessionItems,
+                                 HttpStaticObjectsCollection staticObjects,
+                                 int                         timeout,
+                                 bool                        newSession,
+                                 HttpCookieMode              cookieMode,
+                                 SessionStateMode            mode,
+                                 bool                        isReadonly) {
+            _stateModule = stateModule;
+            _id = id;   // If null, it means we're delaying session id reading
+            _sessionItems = sessionItems;
+            _staticObjects = staticObjects;
+            _timeout = timeout;    
+            _newSession = newSession; 
+            _cookieMode = cookieMode;
+            _mode = mode;
+            _isReadonly = isReadonly;
+        }
+
+        internal HttpSessionStateContainer() {
+        }
+
+        /*
+         * The Id of the session.
+         */
+        public String SessionID {
+            get {
+                if (_id == null) {
+                    Debug.Assert(_stateModule != null, "_stateModule != null");
+                    _id = _stateModule.DelayedGetSessionId();
+                }
+                return _id;
+            }
+        }
+
+        /*
+         * The length of a session before it times out, in minutes.
+         */
+        public int Timeout {
+            get {return _timeout;}
+            set {
+                if (value <= 0) {
+                    throw new ArgumentException(SR.GetString(SR.Timeout_must_be_positive));
+                }
+
+                if (value > SessionStateModule.MAX_CACHE_BASED_TIMEOUT_MINUTES &&
+                    (Mode == SessionStateMode.InProc ||
+                    Mode == SessionStateMode.StateServer)) {
+                    throw new ArgumentException(
+                        SR.GetString(SR.Invalid_cache_based_session_timeout));
+                }
+
+                _timeout = value;
+            }
+        }
+
+        /*
+         * Is this a new session?
+         */
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool IsNewSession {
+            get {return _newSession;}
+        }
+
+        /*
+         * Is session state in a separate process
+         */
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public SessionStateMode Mode {
+            get {return _mode;}
+        }
+
+        /*
+         * Is session state cookieless?
+         */
+        public bool IsCookieless {
+            get {
+                if (_stateModule != null) {
+                    // See VSWhidbey 399907
+                    return _stateModule.SessionIDManagerUseCookieless;
+                }
+                else {
+                    // For container created by custom session state module,
+                    // sorry, we currently don't have a way to tell and thus we rely blindly
+                    // on cookieMode.
+                    return CookieMode == HttpCookieMode.UseUri;
+                }
+            }
+        }
+
+        public HttpCookieMode CookieMode {
+            get {return _cookieMode;}
+        }
+
+        /*
+         * Abandon the session.
+         * 
+         */
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void Abandon() {
+            _abandon = true;
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public int LCID {
+            // 
+
+
+            get { return Thread.CurrentThread.CurrentCulture.LCID; }
+            set { Thread.CurrentThread.CurrentCulture = HttpServerUtility.CreateReadOnlyCultureInfo(value); }
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public int CodePage {
+            // 
+
+
+            get { 
+                if (HttpContext.Current != null)
+                    return HttpContext.Current.Response.ContentEncoding.CodePage;
+                else
+                    return Encoding.Default.CodePage;
+            }
+            set { 
+                if (HttpContext.Current != null)
+                    HttpContext.Current.Response.ContentEncoding = Encoding.GetEncoding(value);
+            }
+        }
+
+        public bool IsAbandoned {
+            get {return _abandon;}
+        }
+
+        public HttpStaticObjectsCollection StaticObjects {
+            get { return _staticObjects;}
+        }
+
+        public Object this[String name]
+        {
+            get {
+                return _sessionItems[name];
+            }
+            set {
+                _sessionItems[name] = value;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public Object this[int index]
+        {
+            get {return _sessionItems[index];}
+            set {_sessionItems[index] = value;}
+        }
+        
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void Add(String name, Object value) {
+            _sessionItems[name] = value;        
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void Remove(String name) {
+            _sessionItems.Remove(name);
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void RemoveAt(int index) {
+            _sessionItems.RemoveAt(index);
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void Clear() {
+            _sessionItems.Clear();
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void RemoveAll() {
+            Clear();
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public int Count {
+            get {return _sessionItems.Count;}
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public NameObjectCollectionBase.KeysCollection Keys {
+            get {return _sessionItems.Keys;}
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public IEnumerator GetEnumerator() {
+            return _sessionItems.GetEnumerator();
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void CopyTo(Array array, int index) {
+            for (IEnumerator e = this.GetEnumerator(); e.MoveNext();)
+                array.SetValue(e.Current, index++);
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public Object SyncRoot {
+            get { return this;}
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool IsReadOnly {
+            get { return _isReadonly;}
+        }
+
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool IsSynchronized {
+            get { return false;}
+        }
+    }
+}
+