public IEnumerator GetEnumerator()
        {
            // we are going to return the default enumerator implementation of ConcurrentDictionary, but
            //      there is one snafu. The keys that have not been read yet are of type
            //      NotYetDeserializedPlaceholderValue, we need to deserialize them now.
            lock (this.enumLock)
            {
                foreach (KeyValuePair <string, object> itm in this.Items)
                {
                    if (itm.Value is NotYetDeserializedPlaceholderValue)
                    {
                        // deserialize the value
                        this.MemoizedDeserializeGet(itm.Key);
                    }
                }

                try
                {
                    return(this.Items.GetEnumerator());
                }
                catch (Exception exc)
                {
                    if (RedisSessionConfig.SessionExceptionLoggingDel != null)
                    {
                        RedisSessionConfig.SessionExceptionLoggingDel(exc);
                    }
                }
            }

            return(new ConcurrentDictionary <string, object>().GetEnumerator());
        }
        static void EnsureLocalCacheFreshness(object sender, ElapsedEventArgs e)
        {
            try
            {
                List <string> expiredKeys = new List <string>();

                DateTime now = DateTime.Now;

                foreach (KeyValuePair <string, SessionAndRefCount> val in LocalSharedSessionDictionary.localCache)
                {
                    if (val.Value.LastAccess.AddMilliseconds(cacheItemExpirationAgeMillis) < now ||
                        val.Value.RequestReferences <= 0)
                    {
                        expiredKeys.Add(val.Key);
                    }
                }

                foreach (string expKey in expiredKeys)
                {
                    SessionAndRefCount removed;
                    LocalSharedSessionDictionary.localCache.TryRemove(expKey, out removed);
                }
            }
            catch (Exception sharedDictExc)
            {
                if (RedisSessionConfig.SessionExceptionLoggingDel != null)
                {
                    RedisSessionConfig.SessionExceptionLoggingDel(sharedDictExc);
                }
            }
        }
 /// <summary>
 /// Helper method for getting a Redis key name from a Session Id
 /// </summary>
 /// <param name="context">The current HttpContext</param>
 /// <param name="sessId">The value of the Session ID cookie from the web request</param>
 /// <returns>A string which is the address of the Session in Redis</returns>
 public static string RedisHashIdFromSessionId(HttpContextBase context, string sessId)
 {
     if (RedisSessionConfig.RedisKeyFromSessionIdDel == null)
     {
         return(sessId);
     }
     else
     {
         return(RedisSessionConfig.RedisKeyFromSessionIdDel(context, sessId));
     }
 }
        /// <summary>
        /// Helper method for serializing objects to Redis
        /// </summary>
        /// <param name="confirmedChangedObjects">keys and values that have definitely changed</param>
        /// <param name="allObjects">keys and values that have been accessed during the current HttpContext</param>
        /// <param name="allObjectsOriginalState">keys and serialized values before we tampered with them</param>
        /// <param name="deletedObjects">keys that were deleted during the current HttpContext</param>
        /// <param name="currentRedisHashId">The current Redis key name</param>
        /// <param name="redisConn">A connection to Redis</param>
        public static void SerializeToRedis(
            HttpContextBase context,
            RedisSessionStateItemCollection redisItems,
            string currentRedisHashId,
            TimeSpan expirationTimeout)
        {
            var setItems = new List <KeyValuePair <string, string> >();
            var delItems = new List <string>();

            // Determine if we are adding or removing keys, separate them into their own lists
            // note that redisItems.GetChangedObjectsEnumerator contains complex logic
            foreach (KeyValuePair <string, string> changedObj in redisItems.GetChangedObjectsEnumerator())
            {
                if (changedObj.Value != null)
                {
                    setItems.Add(changedObj);
                }
                else
                {
                    delItems.Add(changedObj.Key);
                }
            }

            var rConnWrap = RedisSessionStateStoreProvider.RedisConnWrapper();

            if (setItems.Count > 0)
            {
                rConnWrap.HashSet(currentRedisHashId, setItems);

                // call appropriate delegate if set for changing keys
                if (RedisSessionConfig.RedisWriteFieldDel != null)
                {
                    RedisSessionConfig.RedisWriteFieldDel(context, setItems, currentRedisHashId);
                }
            }
            if (delItems != null && delItems.Count > 0)
            {
                rConnWrap.HashDelete(currentRedisHashId, delItems);

                // call appropriate delegate if set for removing keys
                if (RedisSessionConfig.RedisRemoveFieldDel != null)
                {
                    RedisSessionConfig.RedisRemoveFieldDel(context, delItems, currentRedisHashId);
                }
            }

            // always refresh the timeout of the session hash
            rConnWrap.KeyExpire(currentRedisHashId, expirationTimeout);
        }
        /// <summary>
        /// Gets a Session from Redis, indicating a non-exclusive lock on the Session. Note that GetItemExclusive
        ///     calls this method internally, meaning we do not support locks at all retrieving the Session.
        /// </summary>
        /// <param name="context">The HttpContext of the current request</param>
        /// <param name="id">The Session Id, which is the key name in Redis</param>
        /// <param name="locked">Whether or not the Session is locked to exclusive access for a single request
        ///     thread</param>
        /// <param name="lockAge">The age of the lock</param>
        /// <param name="lockId">The object used to lock the Session</param>
        /// <param name="actions">Whether or not to initialize the Session (never)</param>
        /// <returns>The Session objects wrapped in a SessionStateStoreData object</returns>
        public override SessionStateStoreData GetItem(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
        {
            locked  = false;
            lockAge = new TimeSpan(0);
            lockId  = null;
            actions = SessionStateActions.None;

            try
            {
                string parsedRedisHashId = RedisSessionStateStoreProvider.RedisHashIdFromSessionId(
                    new HttpContextWrapper(context),
                    id);

                LocalSharedSessionDictionary sharedSessDict = new LocalSharedSessionDictionary();

                RedisSessionStateItemCollection items = sharedSessDict.GetSessionForBeginRequest(
                    parsedRedisHashId,
                    (redisKey) =>
                {
                    return(RedisSessionStateStoreProvider.GetItemFromRedis(
                               redisKey,
                               new HttpContextWrapper(context),
                               this.SessionTimeout));
                });

                return(new SessionStateStoreData(
                           items,
                           SessionStateUtility.GetSessionStaticObjects(context),
                           Convert.ToInt32(this.SessionTimeout.TotalMinutes)));
            }
            catch (Exception e)
            {
                if (RedisSessionConfig.SessionExceptionLoggingDel != null)
                {
                    RedisSessionConfig.SessionExceptionLoggingDel(e);
                }
            }

            return(this.CreateNewStoreData(context, Convert.ToInt32(this.SessionTimeout.TotalMinutes)));
        }
        /// <summary>
        /// Checks if any items have changed in the Session, and stores the results to Redis
        /// </summary>
        /// <param name="context">The HttpContext of the current web request</param>
        /// <param name="id">The Session Id and Redis key name</param>
        /// <param name="item">The Session properties</param>
        /// <param name="lockId">The object used to exclusively lock the Session (there shouldn't be one)</param>
        /// <param name="newItem">Whether or not the Session was created in this HttpContext</param>
        public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
        {
            try
            {
                string currentRedisHashId = RedisSessionStateStoreProvider.RedisHashIdFromSessionId(
                    new HttpContextWrapper(context),
                    id);

                LocalSharedSessionDictionary    sharedSessDict = new LocalSharedSessionDictionary();
                RedisSessionStateItemCollection redisItems     =
                    sharedSessDict.GetSessionForEndRequest(currentRedisHashId);

                // we were unable to pull it from shared cache, meaning either this is the first request or
                //      something went wrong with the local cache. We still have all the parts needed to write
                //      to redis, however, by looking at SessionStateStoreData passed in from the Session module
                //      and the current hash key provided by the id parameter.
                if (redisItems == null)
                {
                    redisItems = (RedisSessionStateItemCollection)item.Items;
                }

                if (redisItems != null)
                {
                    RedisSessionStateStoreProvider.SerializeToRedis(
                        new HttpContextWrapper(context),
                        redisItems,
                        currentRedisHashId,
                        this.SessionTimeout);
                }
            }
            catch (Exception e)
            {
                if (RedisSessionConfig.SessionExceptionLoggingDel != null)
                {
                    RedisSessionConfig.SessionExceptionLoggingDel(e);
                }
            }
        }
        /// <summary>
        /// Gets a hash from Redis and passes it to the constructor of RedisSessionStateItemCollection
        /// </summary>
        /// <param name="redisKey">The key of the Redis hash</param>
        /// <param name="context">The HttpContext of the current web request</param>
        /// <returns>An instance of RedisSessionStateItemCollection, may be empty if Redis call fails</returns>
        public static RedisSessionStateItemCollection GetItemFromRedis(
            string redisKey,
            HttpContextBase context,
            TimeSpan expirationTimeout)
        {
            var rConnWrap = RedisSessionStateStoreProvider.RedisConnWrapper();

            try
            {
                var redisData = rConnWrap.HashGetAll(redisKey);
                rConnWrap.KeyExpire(redisKey, expirationTimeout);
                return(new RedisSessionStateItemCollection(redisData, rConnWrap.ConnectionId));
            }
            catch (Exception e)
            {
                if (RedisSessionConfig.SessionExceptionLoggingDel != null)
                {
                    RedisSessionConfig.SessionExceptionLoggingDel(e);
                }
            }

            return(new RedisSessionStateItemCollection());
        }
        /// <summary>
        /// Returns a class that allows iteration over the objects in the Session collection that have changed
        ///     since being pulled from Redis. Each key is checked for being all of the following: key was
        ///     accessed, key was not removed or set to null, if the key holds the same object reference as it
        ///     did when pulled from redis, then the current object at the reference address is serialized and
        ///     the serialized string is compared with the serialized string that was originally pulled from
        ///     Redis. The last condition is to ensure Dirty checking is correct, i.e.
        ///     ((List&lt;string&gt;)Session["a"]).Add("a");
        ///     does not change what Session["a"] refers to, but it does change the object and we need to write
        ///     that back to Redis at the end.
        /// </summary>
        /// <returns>an IEnumerator that allows iteration over the changed elements of the Session.</returns>
        public IEnumerable <KeyValuePair <string, string> > GetChangedObjectsEnumerator()
        {
            List <KeyValuePair <string, string> > changedObjs = new List <KeyValuePair <string, string> >();

            lock (enumLock)
            {
                try
                {
                    // for items that have definitely changed (ints, strings, value types and
                    //      reference types whose refs have changed), add to the resulting list
                    //      and reset their serialized raw data
                    foreach (KeyValuePair <string, ActionAndValue> changeData in ChangedKeysDict)
                    {
                        if (changeData.Value is SetValue)
                        {
                            string newSerVal = this.cereal.SerializeOne(changeData.Value.Value);

                            // now set the SerializedRawData of the key to what we are returning to the
                            //      Session provider, which will write it to Redis so the next thread won't
                            //      think the obj has changed when it tries to write
                            this.SerializedRawData.AddOrUpdate(
                                changeData.Key,
                                (key) =>
                            {
                                // ok we added to the initial state, return the new value
                                changedObjs.Add(
                                    new KeyValuePair <string, string>(
                                        changeData.Key,
                                        newSerVal));

                                return(newSerVal);
                            },
                                (key, oldVal) =>
                            {
                                if (oldVal != newSerVal)
                                {
                                    // ok we reset the initial state, return the new value
                                    changedObjs.Add(
                                        new KeyValuePair <string, string>(
                                            changeData.Key,
                                            newSerVal));

                                    return(newSerVal);
                                }

                                return(oldVal);
                            });
                        }
                        if (changeData.Value is DeleteValue)
                        {
                            // remove what SerializedRawData thinks is the original Redis state for the key,
                            //      because it will be removed by the Session provider once it reads from the
                            //      enumerator we are returning
                            string remSerVal;
                            if (this.SerializedRawData.TryRemove(changeData.Key, out remSerVal))
                            {
                                // null means delete to the serializer, perhaps change this in the future
                                changedObjs.Add(
                                    new KeyValuePair <string, string>(
                                        changeData.Key,
                                        null));
                            }
                        }
                    }

                    // check each key that was accessed for changes
                    foreach (KeyValuePair <string, object> itm in this.Items)
                    {
                        try
                        {
                            // only check keys that are not already in the changedObjs list
                            bool alreadyAdded = false;
                            foreach (KeyValuePair <string, string> markedItem in changedObjs)
                            {
                                if (markedItem.Key == itm.Key)
                                {
                                    alreadyAdded = true;
                                    break;
                                }
                            }

                            if (!alreadyAdded && !(itm.Value is NotYetDeserializedPlaceholderValue))
                            {
                                string serVal = this.cereal.SerializeOne(itm.Value);
                                string origSerVal;
                                if (this.SerializedRawData.TryGetValue(itm.Key, out origSerVal))
                                {
                                    if (serVal != origSerVal)
                                    {
                                        // object's value has changed, add to output list
                                        changedObjs.Add(
                                            new KeyValuePair <string, string>(
                                                itm.Key,
                                                serVal));

                                        // and reset the original state of it to what it is now
                                        this.SerializedRawData.TryUpdate(
                                            itm.Key,
                                            serVal,
                                            origSerVal);
                                    }
                                }
                            }
                        }
                        catch (Exception)
                        {
                        }
                    }
                }
                catch (Exception enumExc)
                {
                    if (RedisSessionConfig.SessionExceptionLoggingDel != null)
                    {
                        RedisSessionConfig.SessionExceptionLoggingDel(enumExc);
                    }
                }
            }

            return(changedObjs);
        }