private void OnCacheItemRemoved(string key, object value, CacheItemRemovedReason reason) { IntPtr ptr; CachedContent content = (CachedContent)value; content._spinLock.AcquireWriterLock(); try { ptr = content._stateItem; content._content = null; content._stateItem = IntPtr.Zero; } finally { content._spinLock.ReleaseWriterLock(); } UnsafeNativeMethods.STWNDDeleteStateItem(ptr); if ((content._extraFlags & 2) == 0) { switch (reason) { case CacheItemRemovedReason.Removed: this.IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_ABANDONED); break; case CacheItemRemovedReason.Expired: this.IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_TIMED_OUT); break; } this.DecrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE); } }
private void ReportLocked(HttpContext context, CachedContent content) { HttpResponse response = context.Response; response.StatusCode = 0x1a7; DateTime time = DateTimeUtil.ConvertToLocalTime(content._utcLockDate); TimeSpan span = (TimeSpan)(DateTime.UtcNow - content._utcLockDate); long num = span.Ticks / 0x989680L; response.AppendHeader("LockDate", time.Ticks.ToString(CultureInfo.InvariantCulture)); response.AppendHeader("LockAge", num.ToString(CultureInfo.InvariantCulture)); response.AppendHeader("LockCookie", content._lockCookie.ToString(CultureInfo.InvariantCulture)); }
internal /*public*/ void DoDelete(HttpContext context) { string key = CreateKey(context.Request); CacheInternal cacheInternal = HttpRuntime.CacheInternal; CachedContent content = (CachedContent)cacheInternal.Get(key); /* If the item isn't there, we probably took too long to run. */ if (content == null) { ReportNotFound(context); return; } int lockCookie; if (!GetOptionalNonNegativeInt32HeaderValue(context, StateHeaders.LOCKCOOKIE_NAME, out lockCookie)) { return; } content._spinLock.AcquireWriterLock(); try { if (content._content == null) { ReportNotFound(context); return; } /* Only remove the item if we are the owner */ if (content._locked && (lockCookie == -1 || content._lockCookie != lockCookie)) { ReportLocked(context, content); return; } /* * If not locked, keep it locked until it is completely removed. * Prevent overwriting when we drop the lock. */ content._locked = true; content._lockCookie = 0; } finally { content._spinLock.ReleaseWriterLock(); } cacheInternal.Remove(key); }
private void ReportLocked(HttpContext context, CachedContent content) { HttpResponse response; DateTime localLockDate; long lockAge; // Note that due to a response = context.Response; response.StatusCode = 423; localLockDate = DateTimeUtil.ConvertToLocalTime(content._utcLockDate); lockAge = (DateTime.UtcNow - content._utcLockDate).Ticks / TimeSpan.TicksPerSecond; response.AppendHeader(StateHeaders.LOCKDATE_NAME_RAW, localLockDate.Ticks.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKAGE_NAME_RAW, lockAge.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKCOOKIE_NAME_RAW, content._lockCookie.ToString(CultureInfo.InvariantCulture)); }
private void ReportLocked(HttpContext context, CachedContent content) { HttpResponse response; DateTime localLockDate; long lockAge; // Note that due to a bug in the RTM state server client, // we cannot add to body of the response when sending this // message, otherwise the client will leak memory. response = context.Response; response.StatusCode = 423; localLockDate = DateTimeUtil.ConvertToLocalTime(content._utcLockDate); lockAge = (DateTime.UtcNow - content._utcLockDate).Ticks / TimeSpan.TicksPerSecond; response.AppendHeader(StateHeaders.LOCKDATE_NAME_RAW, localLockDate.Ticks.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKAGE_NAME_RAW, lockAge.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKCOOKIE_NAME_RAW, content._lockCookie.ToString(CultureInfo.InvariantCulture)); }
internal void DoDelete(HttpContext context) { string key = this.CreateKey(context.Request); CacheInternal cacheInternal = HttpRuntime.CacheInternal; CachedContent content = (CachedContent)cacheInternal.Get(key); if (content == null) { this.ReportNotFound(context); } else { int num; if (this.GetOptionalNonNegativeInt32HeaderValue(context, "Http_LockCookie", out num)) { content._spinLock.AcquireWriterLock(); try { if (content._content == null) { this.ReportNotFound(context); return; } if (content._locked && ((num == -1) || (content._lockCookie != num))) { this.ReportLocked(context, content); return; } content._locked = true; content._lockCookie = 0; } finally { content._spinLock.ReleaseWriterLock(); } cacheInternal.Remove(key); } } }
unsafe IntPtr FinishPut(HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; Stream requestStream; byte[] buf; int timeoutMinutes; TimeSpan timeout; int extraFlags; string key; CachedContent content; CachedContent contentCurrent; int lockCookie; int lockCookieNew = 1; IntPtr stateItem; CacheInternal cacheInternal = HttpRuntime.CacheInternal; /* create the content */ requestStream = request.InputStream; int bufferSize = (int)(requestStream.Length - requestStream.Position); buf = new byte[bufferSize]; requestStream.Read(buf, 0, buf.Length); fixed(byte *pBuf = buf) { // The ctor of StateHttpWorkerRequest convert the native pointer address // into an array of bytes, and in our we revert it back to an IntPtr stateItem = (IntPtr)(*((void **)pBuf)); } /* get headers */ if (!GetOptionalNonNegativeInt32HeaderValue(context, StateHeaders.TIMEOUT_NAME, out timeoutMinutes)) { return(stateItem); } if (timeoutMinutes == -1) { timeoutMinutes = SessionStateModule.TIMEOUT_DEFAULT; } if (timeoutMinutes > SessionStateModule.MAX_CACHE_BASED_TIMEOUT_MINUTES) { ReportInvalidHeader(context, StateHeaders.TIMEOUT_NAME); return(stateItem); } timeout = new TimeSpan(0, timeoutMinutes, 0); bool found; if (!GetOptionalInt32HeaderValue(context, StateHeaders.EXTRAFLAGS_NAME, out extraFlags, out found)) { return(stateItem); } if (!found) { extraFlags = 0; } /* lookup current value */ key = CreateKey(request); CacheEntry entry = (CacheEntry)cacheInternal.Get(key, CacheGetOptions.ReturnCacheEntry); if (entry != null) { // DevDivBugs 146875: Expired Session State race condition // We make sure we do not overwrite an already existing item with an uninitialized item. if (((int)SessionStateItemFlags.Uninitialized & extraFlags) == 1) { return(stateItem); } if (!GetOptionalNonNegativeInt32HeaderValue(context, StateHeaders.LOCKCOOKIE_NAME, out lockCookie)) { return(stateItem); } contentCurrent = (CachedContent)entry.Value; contentCurrent._spinLock.AcquireWriterLock(); try { if (contentCurrent._content == null) { ReportNotFound(context); return(stateItem); } /* Only set the item if we are the owner */ if (contentCurrent._locked && (lockCookie == -1 || lockCookie != contentCurrent._lockCookie)) { ReportLocked(context, contentCurrent); return(stateItem); } if (entry.SlidingExpiration == timeout && contentCurrent._content != null) { /* delete the old state item */ IntPtr stateItemOld = contentCurrent._stateItem; /* change the item in place */ contentCurrent._content = buf; contentCurrent._stateItem = stateItem; contentCurrent._locked = false; return(stateItemOld); } /* * The timeout has changed. In this case, we are removing the old item and * inserting a new one. * Update _extraFlags to ignore the cache item removed callback (this way, * we will not decrease the number of active sessions). */ contentCurrent._extraFlags |= (int)SessionStateItemFlags.IgnoreCacheItemRemoved; /* * If not locked, keep it locked until it is completely replaced. * Prevent overwriting when we drop the lock. */ contentCurrent._locked = true; contentCurrent._lockCookie = 0; lockCookieNew = lockCookie; } finally { contentCurrent._spinLock.ReleaseWriterLock(); } } content = new CachedContent(buf, stateItem, false, DateTime.MinValue, lockCookieNew, extraFlags); cacheInternal.UtcInsert( key, content, null, Cache.NoAbsoluteExpiration, timeout, CacheItemPriority.NotRemovable, _removedHandler); if (entry == null) { IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_TOTAL); IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE); } return(IntPtr.Zero); }
unsafe IntPtr FinishPut(HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; Stream requestStream; byte[] buf; int timeoutMinutes; TimeSpan timeout; int extraFlags; string key; CachedContent content; CachedContent contentCurrent; int lockCookie; int lockCookieNew = 1; IntPtr stateItem; CacheInternal cacheInternal = HttpRuntime.CacheInternal; /* create the content */ requestStream = request.InputStream; int bufferSize = (int)(requestStream.Length - requestStream.Position); buf = new byte[bufferSize]; requestStream.Read(buf, 0 , buf.Length); fixed (byte * pBuf = buf) { // The ctor of StateHttpWorkerRequest convert the native pointer address // into an array of bytes, and in our we revert it back to an IntPtr stateItem = (IntPtr)(*((void **)pBuf)); } /* get headers */ if (!GetOptionalNonNegativeInt32HeaderValue(context, StateHeaders.TIMEOUT_NAME, out timeoutMinutes)) { return stateItem; } if (timeoutMinutes == -1) { timeoutMinutes = SessionStateModule.TIMEOUT_DEFAULT; } if (timeoutMinutes > SessionStateModule.MAX_CACHE_BASED_TIMEOUT_MINUTES) { ReportInvalidHeader(context, StateHeaders.TIMEOUT_NAME); return stateItem; } timeout = new TimeSpan(0, timeoutMinutes, 0); bool found; if (!GetOptionalInt32HeaderValue(context, StateHeaders.EXTRAFLAGS_NAME, out extraFlags, out found)) { return stateItem; } if (!found) { extraFlags = 0; } /* lookup current value */ key = CreateKey(request); CacheEntry entry = (CacheEntry) cacheInternal.Get(key, CacheGetOptions.ReturnCacheEntry); if (entry != null) { // DevDivBugs 146875: Expired Session State race condition // We make sure we do not overwrite an already existing item with an uninitialized item. if (((int)SessionStateItemFlags.Uninitialized & extraFlags) == 1) { return stateItem; } if (!GetOptionalNonNegativeInt32HeaderValue(context, StateHeaders.LOCKCOOKIE_NAME, out lockCookie)) { return stateItem; } contentCurrent = (CachedContent) entry.Value; contentCurrent._spinLock.AcquireWriterLock(); try { if (contentCurrent._content == null) { ReportNotFound(context); return stateItem; } /* Only set the item if we are the owner */ if (contentCurrent._locked && (lockCookie == -1 || lockCookie != contentCurrent._lockCookie)) { ReportLocked(context, contentCurrent); return stateItem; } if (entry.SlidingExpiration == timeout && contentCurrent._content != null) { /* delete the old state item */ IntPtr stateItemOld = contentCurrent._stateItem; /* change the item in place */ contentCurrent._content = buf; contentCurrent._stateItem = stateItem; contentCurrent._locked = false; return stateItemOld; } /* The timeout has changed. In this case, we are removing the old item and inserting a new one. Update _extraFlags to ignore the cache item removed callback (this way, we will not decrease the number of active sessions). */ contentCurrent._extraFlags |= (int)SessionStateItemFlags.IgnoreCacheItemRemoved; /* * If not locked, keep it locked until it is completely replaced. * Prevent overwriting when we drop the lock. */ contentCurrent._locked = true; contentCurrent._lockCookie = 0; lockCookieNew = lockCookie; } finally { contentCurrent._spinLock.ReleaseWriterLock(); } } content = new CachedContent(buf, stateItem, false, DateTime.MinValue, lockCookieNew, extraFlags); cacheInternal.UtcInsert( key, content, null, Cache.NoAbsoluteExpiration, timeout, CacheItemPriority.NotRemovable, _removedHandler); if (entry == null) { IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_TOTAL); IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE); } return IntPtr.Zero; }
private void ReportLocked(HttpContext context, CachedContent content) { HttpResponse response; DateTime localLockDate; long lockAge; // Note that due to a bug in the RTM state server client, // we cannot add to body of the response when sending this // message, otherwise the client will leak memory. response = context.Response; response.StatusCode = 423; localLockDate = DateTimeUtil.ConvertToLocalTime(content._utcLockDate); lockAge = (DateTime.UtcNow - content._utcLockDate).Ticks / TimeSpan.TicksPerSecond; response.AppendHeader(StateHeaders.LOCKDATE_NAME_RAW, localLockDate.Ticks.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKAGE_NAME_RAW, lockAge.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKCOOKIE_NAME_RAW, content._lockCookie.ToString(CultureInfo.InvariantCulture)); }
internal void DoGet(HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; string key = this.CreateKey(request); CacheEntry entry = (CacheEntry)HttpRuntime.CacheInternal.Get(key, CacheGetOptions.ReturnCacheEntry); if (entry == null) { this.ReportNotFound(context); } else { string str = request.Headers["Http_Exclusive"]; CachedContent content = (CachedContent)entry.Value; content._spinLock.AcquireWriterLock(); try { if (content._content == null) { this.ReportNotFound(context); } else { int comparand = content._extraFlags; if (((comparand & 1) != 0) && (comparand == Interlocked.CompareExchange(ref content._extraFlags, comparand & -2, comparand))) { this.ReportActionFlags(context, 1); } if (str == "release") { int num; if (this.GetRequiredNonNegativeInt32HeaderValue(context, "Http_LockCookie", out num)) { if (content._locked) { if (num == content._lockCookie) { content._locked = false; } else { this.ReportLocked(context, content); } } else { context.Response.StatusCode = 200; } } } else if (content._locked) { this.ReportLocked(context, content); } else { if (str == "acquire") { content._locked = true; content._utcLockDate = DateTime.UtcNow; content._lockCookie++; response.AppendHeader("LockCookie", content._lockCookie.ToString(CultureInfo.InvariantCulture)); } response.AppendHeader("Timeout", ((int)(entry.SlidingExpiration.Ticks / 0x23c34600L)).ToString(CultureInfo.InvariantCulture)); Stream outputStream = response.OutputStream; byte[] buffer = content._content; outputStream.Write(buffer, 0, buffer.Length); response.Flush(); } } } finally { content._spinLock.ReleaseWriterLock(); } } }
private unsafe IntPtr FinishPut(HttpContext context) { int num; int num2; IntPtr ptr; bool flag; HttpRequest request = context.Request; HttpResponse response = context.Response; int lockCookie = 1; CacheInternal cacheInternal = HttpRuntime.CacheInternal; Stream inputStream = request.InputStream; int num5 = (int)(inputStream.Length - inputStream.Position); byte[] buffer = new byte[num5]; inputStream.Read(buffer, 0, buffer.Length); fixed(byte *numRef = buffer) { ptr = *((IntPtr *)numRef); } if (!this.GetOptionalNonNegativeInt32HeaderValue(context, "Http_Timeout", out num)) { return(ptr); } if (num == -1) { num = 20; } if (num > 0x80520) { this.ReportInvalidHeader(context, "Http_Timeout"); return(ptr); } TimeSpan slidingExpiration = new TimeSpan(0, num, 0); if (!this.GetOptionalInt32HeaderValue(context, "Http_ExtraFlags", out num2, out flag)) { return(ptr); } if (!flag) { num2 = 0; } string key = this.CreateKey(request); CacheEntry entry = (CacheEntry)cacheInternal.Get(key, CacheGetOptions.ReturnCacheEntry); if (entry != null) { int num3; if ((1 & num2) == 1) { return(ptr); } if (!this.GetOptionalNonNegativeInt32HeaderValue(context, "Http_LockCookie", out num3)) { return(ptr); } CachedContent content2 = (CachedContent)entry.Value; content2._spinLock.AcquireWriterLock(); try { if (content2._content == null) { this.ReportNotFound(context); return(ptr); } if (content2._locked && ((num3 == -1) || (num3 != content2._lockCookie))) { this.ReportLocked(context, content2); return(ptr); } if ((entry.SlidingExpiration == slidingExpiration) && (content2._content != null)) { IntPtr ptr2 = content2._stateItem; content2._content = buffer; content2._stateItem = ptr; content2._locked = false; return(ptr2); } content2._extraFlags |= 2; content2._locked = true; content2._lockCookie = 0; lockCookie = num3; } finally { content2._spinLock.ReleaseWriterLock(); } } CachedContent content = new CachedContent(buffer, ptr, false, DateTime.MinValue, lockCookie, num2); cacheInternal.UtcInsert(key, content, null, Cache.NoAbsoluteExpiration, slidingExpiration, CacheItemPriority.NotRemovable, this._removedHandler); if (entry == null) { this.IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_TOTAL); this.IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE); } return(IntPtr.Zero); }
unsafe IntPtr FinishPut(HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; Stream requestStream; byte[] buf; int timeoutMinutes; TimeSpan timeout; string key; CachedContent content; CachedContent contentCurrent; int lockCookie; IntPtr stateItem; CacheInternal cacheInternal = HttpRuntime.CacheInternal; /* create the content */ requestStream = request.InputStream; int bufferSize = (int)(requestStream.Length - requestStream.Position); buf = new byte[bufferSize]; requestStream.Read(buf, 0, buf.Length); fixed(byte *pBuf = buf) { stateItem = (IntPtr)(*((void **)pBuf)); } /* get headers */ if (!GetOptionalNonNegativeInt32HeaderValue(context, StateHeaders.TIMEOUT_NAME, out timeoutMinutes)) { return(stateItem); } if (timeoutMinutes == -1) { timeoutMinutes = SessionStateModule.TIMEOUT_DEFAULT; } timeout = new TimeSpan(0, timeoutMinutes, 0); /* lookup current value */ key = CreateKey(request); CacheEntry entry = (CacheEntry)cacheInternal.Get(key, CacheGetOptions.ReturnCacheEntry); if (entry != null) { if (!GetOptionalNonNegativeInt32HeaderValue(context, StateHeaders.LOCKCOOKIE_NAME, out lockCookie)) { return(stateItem); } contentCurrent = (CachedContent)entry.Value; contentCurrent._spinLock.AcquireWriterLock(); try { if (contentCurrent._content == null) { ReportNotFound(context); return(stateItem); } /* Only set the item if we are the owner */ if (contentCurrent._locked && (lockCookie == -1 || lockCookie != contentCurrent._lockCookie)) { ReportLocked(context, contentCurrent); return(stateItem); } if (entry.SlidingExpiration == timeout && contentCurrent._content != null) { /* delete the old state item */ IntPtr stateItemOld = contentCurrent._stateItem; /* change the item in place */ contentCurrent._content = buf; contentCurrent._stateItem = stateItem; contentCurrent._locked = false; return(stateItemOld); } /* * If not locked, keep it locked until it is completely replaced. * Prevent overwriting when we drop the lock. */ contentCurrent._locked = true; contentCurrent._lockCookie = 0; } finally { contentCurrent._spinLock.ReleaseWriterLock(); } } content = new CachedContent(buf, stateItem, false, DateTime.MinValue, 1); cacheInternal.UtcInsert( key, content, null, Cache.NoAbsoluteExpiration, timeout, CacheItemPriority.NotRemovable, _removedHandler); if (entry == null) { IncrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_TOTAL); IncrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_ACTIVE); } return(IntPtr.Zero); }
private void ReportLocked(HttpContext context, CachedContent content) { HttpResponse response = context.Response; response.StatusCode = 0x1a7; DateTime time = DateTimeUtil.ConvertToLocalTime(content._utcLockDate); TimeSpan span = (TimeSpan) (DateTime.UtcNow - content._utcLockDate); long num = span.Ticks / 0x989680L; response.AppendHeader("LockDate", time.Ticks.ToString(CultureInfo.InvariantCulture)); response.AppendHeader("LockAge", num.ToString(CultureInfo.InvariantCulture)); response.AppendHeader("LockCookie", content._lockCookie.ToString(CultureInfo.InvariantCulture)); }
private unsafe IntPtr FinishPut(HttpContext context) { int num; int num2; IntPtr ptr; bool flag; HttpRequest request = context.Request; HttpResponse response = context.Response; int lockCookie = 1; CacheInternal cacheInternal = HttpRuntime.CacheInternal; Stream inputStream = request.InputStream; int num5 = (int) (inputStream.Length - inputStream.Position); byte[] buffer = new byte[num5]; inputStream.Read(buffer, 0, buffer.Length); fixed (byte* numRef = buffer) { ptr = *((IntPtr*) numRef); } if (!this.GetOptionalNonNegativeInt32HeaderValue(context, "Http_Timeout", out num)) { return ptr; } if (num == -1) { num = 20; } if (num > 0x80520) { this.ReportInvalidHeader(context, "Http_Timeout"); return ptr; } TimeSpan slidingExpiration = new TimeSpan(0, num, 0); if (!this.GetOptionalInt32HeaderValue(context, "Http_ExtraFlags", out num2, out flag)) { return ptr; } if (!flag) { num2 = 0; } string key = this.CreateKey(request); CacheEntry entry = (CacheEntry) cacheInternal.Get(key, CacheGetOptions.ReturnCacheEntry); if (entry != null) { int num3; if ((1 & num2) == 1) { return ptr; } if (!this.GetOptionalNonNegativeInt32HeaderValue(context, "Http_LockCookie", out num3)) { return ptr; } CachedContent content2 = (CachedContent) entry.Value; content2._spinLock.AcquireWriterLock(); try { if (content2._content == null) { this.ReportNotFound(context); return ptr; } if (content2._locked && ((num3 == -1) || (num3 != content2._lockCookie))) { this.ReportLocked(context, content2); return ptr; } if ((entry.SlidingExpiration == slidingExpiration) && (content2._content != null)) { IntPtr ptr2 = content2._stateItem; content2._content = buffer; content2._stateItem = ptr; content2._locked = false; return ptr2; } content2._extraFlags |= 2; content2._locked = true; content2._lockCookie = 0; lockCookie = num3; } finally { content2._spinLock.ReleaseWriterLock(); } } CachedContent content = new CachedContent(buffer, ptr, false, DateTime.MinValue, lockCookie, num2); cacheInternal.UtcInsert(key, content, null, Cache.NoAbsoluteExpiration, slidingExpiration, CacheItemPriority.NotRemovable, this._removedHandler); if (entry == null) { this.IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_TOTAL); this.IncrementStateServiceCounter(StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE); } return IntPtr.Zero; }
private void ReportLocked(HttpContext context, CachedContent content) { HttpResponse response; DateTime localLockDate; long lockAge; // Note that due to a response = context.Response; response.StatusCode = 423; localLockDate = DateTimeUtil.ConvertToLocalTime(content._utcLockDate); lockAge = (DateTime.UtcNow - content._utcLockDate).Ticks / TimeSpan.TicksPerSecond; response.AppendHeader(StateHeaders.LOCKDATE_NAME_RAW, localLockDate.Ticks.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKAGE_NAME_RAW, lockAge.ToString(CultureInfo.InvariantCulture)); response.AppendHeader(StateHeaders.LOCKCOOKIE_NAME_RAW, content._lockCookie.ToString(CultureInfo.InvariantCulture)); }