No way to change the serialization about cookietempdata HOT 7 CLOSED

/// <summary>
    /// A provider for TempData that stores data on cookies. 
    /// Based on https://github.com/brockallen/CookieTempData
    /// Changes:
    ///     - Use Json.Net BsonSerializer
    ///     - Do not compress
    /// </summary>
    public class CookieTempDataProvider : ITempDataProvider
    {
        const string AnonymousCookieValuePrefix = "_";
        const string AuthenticatedCookieValuePrefix = ".";
        const string CookieName = "tmp";
        const string MachineKeyPurpose = "CookieTempDataProvider:{0}";
        const string Anonymous = "<anonymous>";

        public static event EventHandler<Exception> ValidationException;

        private readonly JsonSerializer jsonSerializer;

        public CookieTempDataProvider()
        {
            this.jsonSerializer = new JsonSerializer();
            this.jsonSerializer.Formatting = Formatting.None;
            this.jsonSerializer.NullValueHandling = NullValueHandling.Ignore;
            this.jsonSerializer.TypeNameHandling = TypeNameHandling.Auto;
        }

        public void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
        {
            byte[] bytes = SerializeWithJsonNetBson(values);
            //bytes = Compress(bytes);
            var value = Protect(bytes, controllerContext.HttpContext);
            IssueCookie(controllerContext, value);
        }

        public IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
        {
            var value = GetCookieValue(controllerContext);
            var bytes = Unprotect(value, controllerContext.HttpContext);
            if (bytes == null && value != null)
            {
                // failure, so remove cookie
                IssueCookie(controllerContext, null);
                return null;
            }
            else
            {
                //bytes = Decompress(bytes);
                return DeserializeWithJsonNetBson(bytes);
            }
        }

        private string GetCookieValue(ControllerContext controllerContext)
        {
            if (controllerContext.HttpContext.Request.Cookies.AllKeys.Contains(CookieName))
            {
                HttpCookie c = controllerContext.HttpContext.Request.Cookies[CookieName];
                if (c != null)
                {
                    return c.Value;
                }
            }
            return null;
        }

        private void IssueCookie(ControllerContext controllerContext, string value)
        {
            // if we don't have a value and there's no prior cookie then exit
            if (value == null && !controllerContext.HttpContext.Request.Cookies.AllKeys.Contains(CookieName)) return;

            HttpCookie c = new HttpCookie(CookieName, value)
            {
                // don't allow javascript access to the cookie
                HttpOnly = true,
                // set the path so other apps on the same server don't see the cookie
                Path = controllerContext.HttpContext.Request.ApplicationPath,
                // ideally we're always going over SSL, but be flexible for non-SSL apps
                Secure = controllerContext.HttpContext.Request.IsSecureConnection
            };

            if (value == null)
            {
                // if we have no data then issue an expired cookie to clear the cookie
                c.Expires = DateTime.Now.AddMonths(-1);
            }

            controllerContext.HttpContext.Response.Cookies.Add(c);
        }

        private string GetAnonMachineKeyPurpose()
        {
            return String.Format(MachineKeyPurpose, Anonymous);
        }

        private string GetMachineKeyPurpose(HttpContextBase ctx)
        {
            if (ctx.User == null || ctx.User.Identity == null || !ctx.User.Identity.IsAuthenticated) return GetAnonMachineKeyPurpose();
            return String.Format(MachineKeyPurpose, ctx.User.Identity == null ? "" : ctx.User.Identity.Name);
        }

        private string GetMachineKeyPurposeFromPrefix(string prefix, HttpContextBase ctx)
        {
            if (prefix == AnonymousCookieValuePrefix)
            {
                return GetAnonMachineKeyPurpose();
            }
            if (prefix == AuthenticatedCookieValuePrefix && ctx.User.Identity.IsAuthenticated)
            {
                return String.Format(MachineKeyPurpose, ctx.User.Identity.Name);
            }
            return null;
        }

        private string GetMachineKeyPrefix(HttpContextBase ctx)
        {
            if (ctx.User == null || ctx.User.Identity == null) return AnonymousCookieValuePrefix;

            return (ctx.User.Identity.IsAuthenticated) ?
                AuthenticatedCookieValuePrefix :
                AnonymousCookieValuePrefix;
        }

        private string Protect(byte[] data, HttpContextBase ctx)
        {
            if (data == null || data.Length == 0) return null;

            var purpose = GetMachineKeyPurpose(ctx);
            var value = MachineKey.Protect(data, purpose);

            var prefix = GetMachineKeyPrefix(ctx);
            return prefix + Convert.ToBase64String(value);
        }

        private byte[] Unprotect(string value, HttpContextBase ctx)
        {
            if (String.IsNullOrWhiteSpace(value)) return null;

            var prefix = value[0].ToString();
            var purpose = GetMachineKeyPurposeFromPrefix(prefix, ctx);
            if (purpose == null) return null;

            value = value.Substring(1);
            var bytes = Convert.FromBase64String(value);
            try
            {
                return MachineKey.Unprotect(bytes, purpose);
            }
            catch (CryptographicException ex)
            {
                if (ValidationException != null)
                {
                    ValidationException(this, ex);
                }
                return null;
            }
        }

        private byte[] SerializeWithJsonNetBson(IDictionary<string, object> data)
        {
            if (data == null || data.Keys.Count == 0) return null;

            var ms = new MemoryStream();
            
            using (var writer = new BsonWriter(ms))
            {
                this.jsonSerializer.Serialize(writer, data);
            }

            return ms.ToArray();
            
        }

        private IDictionary<string, object> DeserializeWithJsonNetBson(byte[] data)
        {
            if (data == null || data.Length == 0) return null;

            var ms = new MemoryStream(data);
            using (var reader = new BsonReader(ms))
            {
                return this.jsonSerializer.Deserialize<IDictionary<string, object>>(reader);
            }
        }
    }

from cookietempdata.