iPad上的Cookie到底有多長？

【故事背景】：

公司某個站點，特別依賴Cookie的使用，而且用的比較狠。在設計之初想當然地以為到達Cookie上限是猴年馬月的事兒，沒想到時過境遷，這個上限真的來了。

着手改吧，也不想投入太多。於是下面的思路就涌上心頭：

【問題】

目前遇到的瓶頸主要是單個Cookie的尺寸超大，在IE下，沒有問題，在Firefox下和Chrome下均出現單個Cookie過大，以至於被丟棄的現象。

【思路】

因此為了不侵入舊代碼，打算在站點前加一個HttpModule來切分和拼裝Cookie。為了保證一次成型，減少投入，仔細閱讀了RFC2109文檔/RFC6265（http://www.w3.org/Protocols/rfc2109/rfc2109 或http://www.rfc-editor.org/rfc/rfc6265.txt），下面是文檔里關於對瀏覽器Cookie實現的一些說明：

6.3  Implementation Limits

   Practical user agent implementations have limits on the number and
   size of cookies that they can store.  In general, user agents' cookie
   support should have no fixed limits.  They should strive to store as
   many frequently-used cookies as possible.  Furthermore, general-use
   user agents should provide each of the following minimum capabilities
   individually, although not necessarily simultaneously:

      * at least 300 cookies

      * at least 4096 bytes per cookie (as measured by the size of the
        characters that comprise the cookie non-terminal in the syntax
        description of the Set-Cookie header)

      * at least 20 cookies per unique host or domain name

   User agents created for specific purposes or for limited-capacity
   devices should provide at least 20 cookies of 4096 bytes, to ensure
   that the user can interact with a session-based origin server.

   The information in a Set-Cookie response header must be retained in
   its entirety.  If for some reason there is inadequate space to store
   the cookie, it must be discarded, not truncated.

   Applications should use as few and as small cookies as possible, and
   they should cope gracefully with the loss of a cookie.

文檔中，要求：

至少有300個Cookie總量

每個Cookie至少4096kb

每個域/主機下至少能有20個Cookie

並且還要求：

如果沒有什么特殊原因，Cookie就別做啥限制啦！

【實現】

• 難點1：單個Cookie的尺寸限制是包括“Set-Cookie:”以后的部分，而不是Cookie.Value的部分。作為全局Cookie過濾，包括Path/Domain等值事先都是不知道的。我的做法是將.net類庫中的生成Cookie的方法翻出來抄一遍。詳見“GetSetCookieHeaderString”方法。然后就可以在輸出之前先檢查一下哪些值出現超長的現象。
• 難點2：不同的瀏覽器對Cookie的實現不盡相同。經過簡單的測試，
  • 在Win8.1下：
    • IE11：暫時沒發現上限
    • FireFox（30.0）：4145kb
    • Chrome（版本 36.0.1985.125 m）：4096kb
  • 這個世界發展地太快，其實這個問題的最初版本是因為在iOS下發現了兼容性問題，所以不可忽視的是iOS下的容量限制。
    • iPad-Safari（iOSversion：7.1.2(11D257)）：4125kb？
    • iPad-Chrome（iOSversion：7.1.2(11D257)）：4125kb？
    • iPad-QQ瀏覽器（iOSversion：7.1.2(11D257)）：4125kb？

為什么帶問號呢？因為這個地方其實最讓人頭疼。在測試的過程中，我發現Windows下，對Cookie標准理解最正確的是IE，其他瀏覽器也中規中矩地在做事，頂多是讓你做事的時候不得不畏手畏腳。但是iPad則似乎比較調皮，讓人捉摸不定。

iPad下的Cookie問題：

• 不論哪個瀏覽器，似乎都表現出了相同的行為，它們的Cookie是共享的？但其實不是，他們似乎只是遵循了這樣的規則，因為清除Cookie和數據后，只有Safari會受到影響。
• 單個Cookie長度是4125kb，但有時候似乎是4123kb，不知道是不是我腦子糊塗后錯誤地計算了邊界值。但是另一個問題，讓我放棄了繼續追蹤這個問題。當一個Cookie超過這個長度后，后續的Cookie就凌亂了。假設你有3個Cookie，如果有一個超長了，后續的Cookie就會丟失。不忙着下結論，繼續試驗，因此得出了下面的規律。
• 總的Cookie長度，不再像標准所述，每個域至少30個，且每個至少4096kb，總的容量相加的長度似乎也是有限的。我循環了30次，每個Cookie使用了相同的名稱，然后控制Cookie的長度，測量出的結果有9510kb這樣的長度（所有Cookie相加），但是這不是最終的值，因為一旦后續發生丟失后，不會丟失部分Cookie，要么單個Cookie全部丟失，要么全部保留，因此這個值很難被推算出來。但這個結論讓我開始糾結。因為即便所有Cookie都沒有超過限制，也沒有至少30個Cookie讓我存放。

現在講一下我Windows版本的基本實現思路：

• 在HttpModule.EndRequest事件中，將所有Response的Cookie進行逐一檢查，發現太長的，就將其拆成多個，並且在名稱上用原始名稱+標識符+遞增數字的方式進行顯示。然后將其添加到Response的Cookie中。為了保持類似IE這樣的瀏覽器仍然能夠使用較長的Cookie，而不使用拼拆的（IE仍然是我們的主流客戶，任何一次代碼調整，在遇到大規模發布的時候，盡量不要改變原來的實現方式，以防止問題大面積爆發），我仍然將原來較長的Cookie放進輸出流中。而Chrome這種存儲較短Cookie的瀏覽器，在遇到較長Cookie的時候，會自動丟棄，因此實現了較好的瀏覽器兼容。
• 在HttpModule.BeginRequest事件中，將所有從瀏覽器返回的Cookie進行檢查，然后將可能發生拼接的進行拼接后供后續程序使用。那么在IE下，如果存在原來名稱的Cookie就直接用了，忽略通過拼接回來的Cookie。在Chrome下，發現原本傳下去較長的Cookie已經丟失，因此只能使用拼接后的結果，因此也避免的Cookie丟失的問題。

但這一切在iPad下，就令人頭疼了。因為只有發現超長的時候，才進行拆分，而且同時為了向上兼容，那么兩個4096就已經接近其上限了，那么在這樣的場景下，再去使用，就會發生Cookie莫名其妙隨機丟失的情況，而實驗的結果也是如此。因此，可能就需要（還沒時間去測試）首先判斷瀏覽器是不是來自於移動設備？iOS？iPad?等，然后再進行Cookie實現，那么這個方案就會更復雜，但這個上限給人的感覺是，跑得了初一跑不了十五。很快這個Cookie值就會穿過枷鎖，讓你頭疼欲裂。

真是一失足成千古恨，任何一個依賴客戶端的場景都會因為時間地推移而變得無奈。關於iPad Cookie相關的問題，如果有園友知情的也請不吝留言告知。

附上代碼：

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web;

namespace LargeCookieModule
{
    public class CookieHelper
    {
        /// <summary>
        /// firefox.total:4145
        /// chrome.total:4096
        /// </summary>
        private const int CONST_MAX_COOKIE_BYTES = 4096;
        private const string CONST_BEYOND_SEPARATOR = "_C_SPO_";
        /// <summary>
        /// http://www.rfc-editor.org/rfc/rfc6265.txt
        /// At least 4096 bytes per cookie (as measured by the sum of the length of the cookie's name, value, and attributes).
        /// At least 50 cookies per domain.
        /// At least 3000 cookies total.
        /// 目前考慮最多2位數來解決cookie溢出的問題。
        /// 另CONST_BEYOND_SEPARATOR.Length位用來解決SEPARATOR的問題。
        /// </summary>
        private const int CONST_BEYOND_CHARS = (2 + 7);
        private static System.Text.Encoding defaultEncoding
        {
            get
            {
                return System.Text.Encoding.UTF8;
            }
        }

        public static string GetSetCookieHeaderString(HttpContext context, HttpCookie cookie)
        {
            string name = cookie.Name;
            string value = cookie.Value;
            string domain = cookie.Domain;
            DateTime expires = cookie.Expires;
            string path = cookie.Path;
            bool secure = cookie.Secure;
            bool httpOnly = cookie.HttpOnly;

            StringBuilder stringBuilder = new StringBuilder();
            if (!string.IsNullOrEmpty(name))
            {
                stringBuilder.Append(name);
                stringBuilder.Append('=');
            }
            if (!string.IsNullOrEmpty(value))
            {
                stringBuilder.Append(value);
            }
            if (!string.IsNullOrEmpty(domain))
            {
                stringBuilder.Append("; domain=");
                stringBuilder.Append(domain);
            }
            if (expires != DateTime.MinValue)
            {
                stringBuilder.Append("; expires=");
                stringBuilder.Append(FormatHttpCookieDateTime(expires));
            }
            if (!string.IsNullOrEmpty(path))
            {
                stringBuilder.Append("; path=");
                stringBuilder.Append(path);
            }
            if (secure)
            {
                stringBuilder.Append("; secure");
            }
            if (httpOnly && SupportsHttpOnly(context))
            {
                stringBuilder.Append("; HttpOnly");
            }
            return stringBuilder.ToString();
        }

        private static bool SupportsHttpOnly(HttpContext context)
        {
            if (context != null && context.Request != null)
            {
                HttpBrowserCapabilities browser = context.Request.Browser;
                return browser != null && (browser.Type != "IE5" || browser.Platform != "MacPPC");
            }
            return false;
        }

        /// <summary>
        /// equals to HttpUtility.FormatHttpCookieDateTime
        /// for java system to rewrite code.
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        private static string FormatHttpCookieDateTime(DateTime dt)
        {
            if (dt < DateTime.MaxValue.AddDays(-1.0) && dt > DateTime.MinValue.AddDays(1.0))
            {
                dt = dt.ToUniversalTime();
            }
            return dt.ToString("ddd, dd-MMM-yyyy HH':'mm':'ss 'GMT'", DateTimeFormatInfo.InvariantInfo);
        }


        /// <summary>
        /// 是否是合法的Cookies（目前只考慮長度）
        /// 目前暫時只知道用System.Text.Encoding.UTF8來解決。無法獲取客戶端存儲的情況。
        /// </summary>
        /// <param name="context"></param>
        /// <param name="cookie"></param>
        /// <returns></returns>
        public static bool IsLengthLegalCookie(HttpContext context, HttpCookie cookie)
        {
            if (cookie == null)
                return false;
            string cookieString = CookieHelper.GetSetCookieHeaderString(context, cookie);

            if (cookieString != null && defaultEncoding.GetByteCount(cookieString) <= CONST_MAX_COOKIE_BYTES)
            {
                return true;
            }
                        
            return false;
        }

        /// <summary>
        /// 獲取除了Value（name+value）值以外的字符長度
        /// </summary>
        /// <param name="context"></param>
        /// <param name="cookie"></param>
        /// <returns></returns>
        private static int GetLengthExceptValue(HttpContext context, HttpCookie cookie)
        {
            if (cookie == null)
                return 0;
            string cookieString = CookieHelper.GetSetCookieHeaderString(context, cookie);
            if (!string.IsNullOrEmpty(cookieString))
            {
                int index = cookieString.IndexOf(';');
                // if index equals to -1 result is - (-1) - 1.
                return cookieString.Length - index - 1;
            }
            return 0;
        }

        public static List<HttpCookie> GetCookies(HttpCookieCollection cookies)
        {
            Dictionary<string, HttpCookie> resultCookies = new Dictionary<string, HttpCookie>();
            SeparatorSortedDictionary<HttpCookie> separatorCookies = new SeparatorSortedDictionary<HttpCookie>();

            if (cookies != null && cookies.AllKeys != null && cookies.AllKeys.Length > 0)
            {
                foreach (string key in cookies.AllKeys)
                {
                    HttpCookie cookie = cookies[key];
                    if (cookie != null && !string.IsNullOrEmpty(cookie.Name))
                    {
                        int separatorIndex = cookie.Name.IndexOf(CONST_BEYOND_SEPARATOR);
                        if (separatorIndex != -1)
                        {
                            string prefixName = cookie.Name.Substring(0, separatorIndex);
                            string sOrder = cookie.Name.Substring(prefixName.Length + CONST_BEYOND_SEPARATOR.Length);
                            int iOrder = 0;
                            if (int.TryParse(sOrder, out iOrder))
                            {
                                separatorCookies.Add(prefixName, iOrder, cookie);
                            }
                        }
                        else
                        {
                            resultCookies[cookie.Name] = cookie;
                        }
                    }
                }
                List<string> separatorKeys = separatorCookies.Keys;
                foreach (string key in separatorKeys)
                {
                    if(resultCookies.ContainsKey(key))
                        continue;
                    HttpCookie joinCookie = separatorCookies.Join(key,
                        (c) => c.Value,
                        (s, c) => { c.Value = s; return c; },
                        CloneHttpCookie);
                    resultCookies[key] = joinCookie;
                }
            }
            return resultCookies.Values.ToList();
        }

        public static List<HttpCookie> GetSetCookies(HttpContext context, HttpCookie cookie)
        {
            if (IsLengthLegalCookie(context, cookie))
            {
                List<HttpCookie> cookies = new List<HttpCookie>();
                cookies.Add(cookie);
                return cookies;
            }
            else
            {
                string name = cookie.Name;
                string value = cookie.Value;
                int maxValueCount = CONST_MAX_COOKIE_BYTES - CONST_BEYOND_CHARS - GetLengthExceptValue(context, cookie) - name.Length - 1/*name=value后面的分號*/;
                if (maxValueCount > 0)
                {
                    byte[] bValue = defaultEncoding.GetBytes(value);
                    int iEachChunk = 0, iChunkNum, iChunkCount = 0;
                    SortedList<int, byte[]> chunks = new SortedList<int, byte[]>();
                    iChunkCount = bValue.Length / maxValueCount + 1;
                    int iChunkLastIndex = iChunkCount-1;
                    for (iChunkNum = 0; iChunkNum < iChunkCount; ++iChunkNum)
                    {
                        byte[] chunk = null;
                        if (iChunkNum != iChunkLastIndex)
                        {
                            chunk = new byte[maxValueCount];
                        }
                        else 
                        {
                            chunk = new byte[bValue.Length % maxValueCount];
                        }
                        for (iEachChunk = 0; iEachChunk < chunk.Length; ++iEachChunk)
                        {
                            chunk[iEachChunk] = bValue[iChunkNum * maxValueCount + iEachChunk];
                        }
                        chunks.Add(iChunkNum, chunk);
                    }
                    List<HttpCookie> cookies = new List<HttpCookie>();
                    foreach (KeyValuePair<int, byte[]> item in chunks)
                    {
                        string itemName = name + CONST_BEYOND_SEPARATOR + item.Key.ToString();
                        string itemValue = defaultEncoding.GetString(item.Value);
                        HttpCookie cloneCookie = CloneHttpCookie(cookie);
                        cloneCookie.Name = itemName;
                        cloneCookie.Value = itemValue;
                        cookies.Add(cloneCookie);
                    }
                    return cookies;
                }
            }
            return null;
        }

        public static bool IsSeparatorCookie(HttpCookie cookie)
        {
            if (cookie == null)
                return false;
            if (!string.IsNullOrEmpty(cookie.Name) && cookie.Name.Contains(CONST_BEYOND_SEPARATOR))
            {
                return true;
            }
            return false;
        }

        private static HttpCookie CloneHttpCookie(HttpCookie cookie)
        {
            HttpCookie cloneCookie = new HttpCookie(cookie.Name);
            cloneCookie.Value = cookie.Value;
            cloneCookie.Path = cookie.Path;
            cloneCookie.Secure = cookie.Secure;
            cloneCookie.HttpOnly = cookie.HttpOnly;
            cloneCookie.Domain = cookie.Domain;
            cloneCookie.Expires = cookie.Expires;
            return cloneCookie;
        }

        public static void FilterRequestCookies(HttpContext context)
        {
            if (context != null)
            {
                IList<HttpCookie> cookies = CookieHelper.GetCookies(context.Request.Cookies);
                if (cookies != null)
                {
                    foreach (HttpCookie subCookie in cookies)
                    {
                        if (context.Request.Cookies[subCookie.Name] == null)
                        {
                            context.Request.Cookies.Add(subCookie);
                        }
                    }
                }
            }
        }

        public static void FilterResponseCookies(HttpContext context)
        {
            if (context != null && context.Response.Cookies != null && context.Response.Cookies.Keys.Count > 0)
            {
                int keyCount = context.Response.Cookies.Keys.Count;
                if (keyCount > 0)
                {
                    string[] keys = new string[keyCount];
                    for (int i = 0; i < keyCount; ++i)
                    {
                        keys[i] = context.Response.Cookies.Keys[i];
                    }

                    foreach (string key in keys)
                    {
                        HttpCookie everyCookie = context.Response.Cookies[key];

                        IList<HttpCookie> cookies = CookieHelper.GetSetCookies(context, everyCookie);
                        if (cookies != null && cookies.Count > 1 /*means it is separator cookie or the raw cookie is not legal in length.*/)
                        {
                            foreach (HttpCookie subCookie in cookies)
                            {
                                if (IsSeparatorCookie(subCookie))
                                {
                                    context.Response.AppendCookie(subCookie);
                                }
                            }
                        }
                    }
                }
            }
        }

        internal class SeparatorSortedDictionary<T> : Dictionary<string, SortedList<int, T>>
        {
            Dictionary<string, SortedList<int, T>> _innerStore = new Dictionary<string, SortedList<int, T>>();
            public void Add(string name, int index, T value)
            {
                if (_innerStore != null)
                {
                    if (!_innerStore.ContainsKey(name))
                        _innerStore[name] = new SortedList<int, T>();
                    SortedList<int, T> itemCollection = _innerStore[name];
                    if (!itemCollection.ContainsKey(index))
                    {
                        itemCollection.Add(index, value);
                    }
                }
            }

            public T Join(string name, Func<T, string> toStringFunc, Func<string, T, T> fromStringFunc, Func<T, T> cloneFunc)
            {
                if (_innerStore != null)
                {
                    if (_innerStore.ContainsKey(name))
                    {
                        SortedList<int, T> itemCollection = _innerStore[name];
                        string value = string.Empty;
                        T firstElement = default(T);
                        bool getFirstElement = false;
                        foreach (T itemValue in itemCollection.Values)
                        {
                            if (!getFirstElement)
                            {
                                firstElement = itemValue;
                                getFirstElement = true;
                            }
                            value += toStringFunc(itemValue);
                        }
                        T cloneItem = cloneFunc(firstElement);
                        cloneItem = fromStringFunc(value, cloneItem);
                        return cloneItem;
                    }
                }
                return default(T);
            }

            public List<string> Keys
            {
                get
                {
                    List<string> result = new List<string>();
                    if (_innerStore != null)
                    {
                        foreach (string key in _innerStore.Keys)
                        {
                            result.Add(key);
                        }
                    }
                    return result;
                }
            }
        }
    }
}

 調用代碼：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web;

namespace LargeCookieModule
{
    public class LargeCookieModule : IHttpModule
    {
        public void Dispose()
        {
            throw new NotImplementedException();
        }

        public void Init(HttpApplication context)
        {
            context.BeginRequest += context_BeginRequest;
            context.EndRequest += context_EndRequest;
        }

        void context_BeginRequest(object sender, EventArgs e)
        {
            HttpApplication app = sender as HttpApplication;
            if (app != null)
            {
                if (app.Context.Request.ContentEncoding != null)
                    app.Context.Response.Write("app.Context.Request.ContentEncoding:" + app.Context.Request.ContentEncoding.ToString() + "<br />");

                app.Context.Response.Write("<br />-----------(start)raw request cookies, context_BeginRequest:--------------<br />");

                foreach (string key in app.Request.Cookies.AllKeys)
                {
                    HttpCookie cookie = app.Request.Cookies[key];
                    if (cookie != null)
                    {
                        string cookieString = CookieHelper.GetSetCookieHeaderString(app.Context, cookie);
                        app.Context.Response.Write("context_BeginRequest:" + cookieString + "<br />");
                        app.Context.Response.Write("context_BeginRequest.cookieLength:" + cookieString.Length + "<br />");
                        app.Context.Response.Write("context_BeginRequest.GetByteCount:" + System.Text.Encoding.UTF8.GetByteCount(cookieString) + "<br />");
                    }
                }

                app.Context.Response.Write("<br />-----------(end)raw request cookies, context_BeginRequest:--------------<br /><br />");

                app.Context.Response.Write("<br />-----------(start)merged by CookieHelper.cs, context_BeginRequest:--------------<br />");
                // 唯一一句用來過濾
                CookieHelper.FilterRequestCookies(app.Context);
                foreach (string key in app.Request.Cookies.AllKeys)
                {
                    HttpCookie cookie = app.Request.Cookies[key];
                    if (cookie != null)
                    {
                        string cookieString = CookieHelper.GetSetCookieHeaderString(app.Context, cookie);
                        app.Context.Response.Write("context_BeginRequest:" + cookieString + "<br />");
                        app.Context.Response.Write("context_BeginRequest.cookieLength:" + cookieString.Length + "<br />");
                        app.Context.Response.Write("context_BeginRequest.GetByteCount:" + System.Text.Encoding.UTF8.GetByteCount(cookieString) + "<br />");
                    }
                }
                app.Context.Response.Write("<br />-----------(end)merged by CookieHelper.cs, context_BeginRequest:--------------<br /><br />");
            }
        }

        void context_EndRequest(object sender, EventArgs e)
        {
            //HttpApplication app = sender as HttpApplication;
            //if (app != null)
            //{
            //    // CookieHelper.FilterResponseCookies(app.Context);
            //    app.Context.Response.Write("<br />-----------(start)response the merged cookies to the client, context_EndRequest:--------------<br />");
            //    foreach (string key in app.Response.Cookies.AllKeys)
            //    {
            //        HttpCookie cookie = app.Response.Cookies[key];
            //        if (cookie != null)
            //        {
            //            IList<HttpCookie> cookies = CookieHelper.GetSetCookies(app.Context, cookie);
            //            if (cookies != null)
            //            {
            //                foreach (HttpCookie subCookie in cookies)
            //                {
            //                    string cookieString = CookieHelper.GetSetCookieHeaderString(app.Context, subCookie);
            //                    app.Context.Response.AppendCookie(subCookie);
            //                    app.Context.Response.Write("context_EndRequest:" + cookieString + "<br />");
            //                    app.Context.Response.Write("context_EndRequest.cookieLength:" + cookieString.Length + "<br />");
            //                    app.Context.Response.Write("context_EndRequest.GetByteCount:" + System.Text.Encoding.UTF8.GetByteCount(cookieString) + "<br />");
            //                }
            //            }
            //        }
            //    }
            //    app.Context.Response.Write("<br />-----------(end)response the merged cookies to the client, context_EndRequest:--------------<br /><br />");
            //}

            HttpApplication app = sender as HttpApplication;
            if (app != null)
            {
                app.Context.Response.Write("<br />-----------(start)response the all cookies to the client, context_EndRequest:--------------<br />");

                CookieHelper.FilterResponseCookies(app.Context);

                List<HttpCookie> reverseList = new List<HttpCookie>();
                List<string> keys = app.Response.Cookies.AllKeys.ToList();
                foreach (string key in keys)
                {
                    HttpCookie cookie = app.Response.Cookies[key];
                    if (cookie != null)
                    {
                        reverseList.Add(cookie);
                        string cookieString = CookieHelper.GetSetCookieHeaderString(app.Context, cookie);
                        app.Context.Response.Write("context_EndRequest:" + cookieString + "<br />");
                        app.Context.Response.Write("context_EndRequest.cookieLength:" + cookieString.Length + "<br />");
                        app.Context.Response.Write("context_EndRequest.GetByteCount:" + System.Text.Encoding.UTF8.GetByteCount(cookieString) + "<br />");
                    }
                }

                app.Context.Response.Write("<br />-----------(end)response the all cookies to the client, context_EndRequest:--------------<br />");
            }
        }
    }
}

其中BeginRequest和EndRequest中其實只需要調用：

CookieHelper.FilterRequestCookies(app.Context);

CookieHelper.FilterResponseCookies(app.Context);

以上其余代碼都是用來測試的。

另外附上iPad測試的代碼：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace TestIPadCookie
{
    public partial class Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            for (int j = 0; j < 30; ++j)
            {
                string text = string.Empty;
                string cookieString = string.Empty;
                HttpCookie cookie = new HttpCookie("ipadTest" + j.ToString().PadLeft(2, '0'));
                cookie.Expires = DateTime.Now.AddDays(1);
                for (int i = 0; i < 10000; ++i)
                {
                    text += 'c';
                    cookie.Value = text;
                    cookieString = LargeCookieModule.CookieHelper.GetSetCookieHeaderString(HttpContext.Current, cookie);
                    if (System.Text.Encoding.UTF8.GetByteCount(cookieString) >= 317)
                    {
                        break;
                    }
                }
                HttpContext.Current.Response.AppendCookie(cookie);
                HttpContext.Current.Response.Write("cookieLength=" + cookieString.Length.ToString() + "<br />");
                HttpContext.Current.Response.Write("cookieValueLength=" + text.Length.ToString()
                    + ", gap = " + Math.Abs(cookieString.Length - text.Length) + "<br />");
                HttpContext.Current.Response.Write("cookieString=" + cookieString + "<br />");
                HttpContext.Current.Response.Write("<br />");
            }
        }
    }
}

 

源代碼打包下載：（點擊這里）

http://files.cnblogs.com/volnet/WebAppLargeCookieModule.zip