2003-03-04 Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* HttpSessionState.cs: reworked to use SessionDictionary.
	* SessionDictionary.cs: implemented serialization/deserialization.

svn path=/trunk/mcs/; revision=12166

diff --git a/mcs/class/System.Web/System.Web.SessionState/ChangeLog b/mcs/class/System.Web/System.Web.SessionState/ChangeLog
index 73da2231b1e34bc11c95eaa8bea17d64f8a0abc1..6df3a3a99b3c0a63e7779202e83481e25d30924f 100644 (file)
--- a/mcs/class/System.Web/System.Web.SessionState/ChangeLog
+++ b/mcs/class/System.Web/System.Web.SessionState/ChangeLog
@@ -1,3 +1,8 @@
+2003-03-04  Gonzalo Paniagua Javier <gonzalo@ximian.com>
+
+       * HttpSessionState.cs: reworked to use SessionDictionary.
+       * SessionDictionary.cs: implemented serialization/deserialization.
+
 2003-03-03  Gonzalo Paniagua Javier <gonzalo@ximian.com>
 
        * SessionConfig.cs:

diff --git a/mcs/class/System.Web/System.Web.SessionState/HttpSessionState.cs b/mcs/class/System.Web/System.Web.SessionState/HttpSessionState.cs
index 324470a97cccc3ff9abc2da32d5c7f9810c28e1b..9b2b1e74ea6b3a4c989a8d21553d74c371bf9ddf 100644 (file)
--- a/mcs/class/System.Web/System.Web.SessionState/HttpSessionState.cs
+++ b/mcs/class/System.Web/System.Web.SessionState/HttpSessionState.cs
@@ -4,7 +4,7 @@
 // Authors:
 //     Gonzalo Paniagua Javier (gonzalo@ximian.com)
 //
-// (C) 2002 Ximian, Inc (http://www.ximian.com)
+// (C) 2002,2003 Ximian, Inc (http://www.ximian.com)
 //
 using System;
 using System.Collections;
@@ -15,7 +15,6 @@ using System.Threading;
 namespace System.Web.SessionState {
 public sealed class HttpSessionState : ICollection, IEnumerable
 {
-       private NameValueCollection _state; //FIXME: it should be a ManagementNamedValueCollection
        private string _id;
        private SessionDictionary _dict;
        private HttpStaticObjectsCollection _staticObjects;
@@ -59,7 +58,7 @@ public sealed class HttpSessionState : ICollection, IEnumerable
 
        public int Count
        {
-               get { return _state.Count; }
+               get { return _dict.Count; }
        }
 
        internal bool IsAbandoned
@@ -89,22 +88,22 @@ public sealed class HttpSessionState : ICollection, IEnumerable
 
        public object this [string key]
        {
-               get { return _state [key]; }
-               set { _state [key] = (string) value; }
+               get { return _dict [key]; }
+               set { _dict [key] = value; }
        }
 
        public object this [int index]
        {
-               get { return _state [index]; }
+               get { return _dict [index]; }
                set {
-                       string key = _state.Keys [index];
-                       _state [key] = (string) value;
+                       string key = _dict.Keys [index];
+                       _dict [key] = value;
                }
        }
 
        public NameObjectCollectionBase.KeysCollection Keys
        {
-               get { return _state.Keys; }
+               get { return _dict.Keys; }
        }
 
        public int LCID
@@ -146,53 +145,40 @@ public sealed class HttpSessionState : ICollection, IEnumerable
 
        public void Add (string name, object value)
        {
-               if (_state == null)
-                       _state = new NameValueCollection ();
-
-               _state.Add (name, (string) value);
+               _dict [name] = value;
        }
 
        public void Clear ()
        {
-               if (_state != null)
-                       _state.Clear ();
+               if (_dict != null)
+                       _dict.Clear ();
        }
        
        public void CopyTo (Array array, int index)
        {
-               if (_state == null)
-                       _state = new NameValueCollection ();
-
-               _state.CopyTo (array, index);
+               NameObjectCollectionBase.KeysCollection all = Keys;
+               for (int i = 0; i < all.Count; i++)
+                       array.SetValue (_dict [all [i]], i + index);
        }
 
        public IEnumerator GetEnumerator ()
        {
-               if (_state == null)
-                       _state = new NameValueCollection ();
-
-               return _state.GetEnumerator ();
+               return _dict.GetEnumerator ();
        }
        
        public void Remove (string name)
        {
-               if (_state != null)
-                       _state.Remove (name);
+               _dict.Remove (name);
        }
 
        public void RemoveAll ()
        {
-               if (_state != null)
-                       foreach (string key in _state.AllKeys)
-                               _state.Remove (key);
+               _dict.Clear ();
        }
 
-       [MonoTODO("Implement ManagementNameValueCollection")]
        public void RemoveAt (int index)
        {
-               throw new NotImplementedException ();
-               //if (_state != null)
-               //      _state.RemoveAt (index);
+               _dict.RemoveAt (index);
        }
 }
 }

diff --git a/mcs/class/System.Web/System.Web.SessionState/SessionDictionary.cs b/mcs/class/System.Web/System.Web.SessionState/SessionDictionary.cs
index a389125e1ddc59889debdbbd2fb2f20cb0fb4aca..8a916d08fbf7bd3be075af50b9a188936b477f56 100644 (file)
--- a/mcs/class/System.Web/System.Web.SessionState/SessionDictionary.cs
+++ b/mcs/class/System.Web/System.Web.SessionState/SessionDictionary.cs
@@ -4,67 +4,220 @@
 // Authors:
 //     Gonzalo Paniagua Javier (gonzalo@ximian.com)
 //
-// (C) 2002 Ximian, Inc (http://www.ximian.com)
+// (C) 2002,2003 Ximian, Inc (http://www.ximian.com)
 //
+
 using System;
 using System.IO;
+using System.Collections;
 using System.Collections.Specialized;
+using System.Runtime.Serialization.Formatters.Binary;
 
 namespace System.Web.SessionState {
 internal class SessionDictionary : NameObjectCollectionBase
 {
-       private bool _dirty;
+       static ArrayList types;
+       bool _dirty;
 
        static SessionDictionary ()
        {
+               types = new ArrayList ();
+               types.Add ("");
+               types.Add (typeof (string));
+               types.Add (typeof (int));
+               types.Add (typeof (bool));
+               types.Add (typeof (DateTime));
+               types.Add (typeof (Decimal));
+               types.Add (typeof (Byte));
+               types.Add (typeof (Char));
+               types.Add (typeof (Single));
+               types.Add (typeof (Double));
+               types.Add (typeof (short));
+               types.Add (typeof (long));
+               types.Add (typeof (ushort));
+               types.Add (typeof (uint));
+               types.Add (typeof (ulong));
        }
 
        public SessionDictionary ()
        {
        }
 
-       void Clear ()
+       internal void Clear ()
        {
                _dirty = true;
                BaseClear ();
        }
 
-       [MonoTODO]
-       static SessionDictionary Deserialize (BinaryReader r)
-       {
-               throw new NotImplementedException ();
-       }
-
-       public string GetKey (int index)
+       internal string GetKey (int index)
        {
                return BaseGetKey (index);
        }
 
-       [MonoTODO]
-       static bool IsInmutable (object o)
+       internal static bool IsInmutable (object o)
        {
-               throw new NotImplementedException ();
+               Type t = o.GetType ();
+               return (t == typeof (string) || t.IsPrimitive);
        }
 
-       void Remove (string s)
+       internal void Remove (string s)
        {
                BaseRemove (s);
                _dirty = true;
        }
 
-       void RemoveAt (int index)
+       internal void RemoveAt (int index)
        {
                BaseRemoveAt (index);
                _dirty = true;
        }
 
-       [MonoTODO]
-       void Serialize(BinaryWriter w)
+       internal void Serialize (BinaryWriter w)
        {
-               throw new NotImplementedException ();
+               w.Write (Count);
+               foreach (string key in Keys) {
+                       w.Write (key);
+                       object value = BaseGet (key);
+                       if (value == null) {
+                               w.Write (16); // types.Count + 1
+                               continue;
+                       }
+
+                       SerializeByType (w, value);
+               }
        }
 
-       bool Dirty
+       static void SerializeByType (BinaryWriter w, object value)
+       {
+               Type type = value.GetType ();
+               int i = types.IndexOf (type);
+               if (i == -1) {
+                       w.Write (15); // types.Count
+                       BinaryFormatter bf = new BinaryFormatter ();
+                       bf.Serialize (w.BaseStream, value);
+                       return;
+               }
+
+               w.Write (i);
+               switch (i) {
+               case 1:
+                       w.Write ((string) value);
+                       break;
+               case 2:
+                       w.Write ((int) value);
+                       break;
+               case 3:
+                       w.Write ((bool) value);
+                       break;
+               case 4:
+                       w.Write (((DateTime) value).Ticks);
+                       break;
+               case 5:
+                       w.Write ((decimal) value);
+                       break;
+               case 6:
+                       w.Write ((byte) value);
+                       break;
+               case 7:
+                       w.Write ((char) value);
+                       break;
+               case 8:
+                       w.Write ((float) value);
+                       break;
+               case 9:
+                       w.Write ((double) value);
+                       break;
+               case 10:
+                       w.Write ((short) value);
+                       break;
+               case 11:
+                       w.Write ((long) value);
+                       break;
+               case 12:
+                       w.Write ((ushort) value);
+                       break;
+               case 13:
+                       w.Write ((uint) value);
+                       break;
+               case 14:
+                       w.Write ((ulong) value);
+                       break;
+               }
+       }
+
+       internal static SessionDictionary Deserialize (BinaryReader r)
+       {
+               SessionDictionary result = new SessionDictionary ();
+               for (int i = r.ReadInt32 (); i > 0; i--) {
+                       string key = r.ReadString ();
+                       int index = r.ReadInt32 ();
+                       if (index == 16)
+                               result [key] = null;
+                       else
+                               result [key] = DeserializeFromIndex (index, r);
+               }
+
+               return result;
+       }
+
+       static object DeserializeFromIndex (int index, BinaryReader r)
+       {
+               if (index == 15){
+                       BinaryFormatter bf = new BinaryFormatter ();
+                       return bf.Deserialize (r.BaseStream);
+               }
+
+               object value = null;
+               switch (index) {
+               case 1:
+                       value = r.ReadString ();
+                       break;
+               case 2:
+                       value = r.ReadInt32 ();
+                       break;
+               case 3:
+                       value = r.ReadBoolean ();
+                       break;
+               case 4:
+                       value = new DateTime (r.ReadInt64 ());
+                       break;
+               case 5:
+                       value = r.ReadDecimal ();
+                       break;
+               case 6:
+                       value = r.ReadByte ();
+                       break;
+               case 7:
+                       value = r.ReadChar ();
+                       break;
+               case 8:
+                       value = r.ReadSingle ();
+                       break;
+               case 9:
+                       value = r.ReadDouble ();
+                       break;
+               case 10:
+                       value = r.ReadInt16 ();
+                       break;
+               case 11:
+                       value = r.ReadInt64 ();
+                       break;
+               case 12:
+                       value = r.ReadUInt16 ();
+                       break;
+               case 13:
+                       value = r.ReadUInt32 ();
+                       break;
+               case 14:
+                       value = r.ReadUInt64 ();
+                       break;
+               }
+
+               return value;
+       }
+
+
+       internal bool Dirty
        {
                get { return _dirty; }
                set { _dirty = value; }