void DeserializeItem(String name, bool check) { object val; lock (_serializedItemsLock) { if (check) { // No-op if SessionStateItemCollection is not deserialized from a persistent storage, if (_serializedItems == null) { return; } // User is asking for an item we don't have. if (!_serializedItems.ContainsKey(name)) { return; } } Debug.Assert(_serializedItems != null); Debug.Assert(_stream != null); SerializedItemPosition position = (SerializedItemPosition)_serializedItems[name]; if (position.IsDeserialized) { // It has been deserialized already. return; } // Position the stream to the place where the item is stored. _stream.Seek(position.Offset, SeekOrigin.Begin); // Set the value Debug.Trace("SessionStateItemCollection", "Deserialized an item: keyname=" + name); if (!HttpRuntime.DisableProcessRequestInApplicationTrust) { // VSWhidbey 427316: Sandbox Serialization in non full trust cases if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) { HttpRuntime.NamedPermissionSet.PermitOnly(); } } // This deserialization work used to be done in AcquireRequestState event when // there is no user code on the stack. // In whidbey we added this on-demand deserialization for performance reason. However, // in medium and low trust cases the page doesn't have permission to do it. // So we have to assert the permission. // (See VSWhidbey 275003) val = ReadValueFromStreamWithAssert(); BaseSet(name, val); // At the end, mark the item as deserialized by making the offset -1 position.MarkDeserializedOffsetAndCheck(); } }
private void DeserializeItem(string name, bool check) { lock (this._serializedItemsLock) { if (!check || ((this._serializedItems != null) && this._serializedItems.ContainsKey(name))) { SerializedItemPosition position = (SerializedItemPosition)this._serializedItems[name]; if (!position.IsDeserialized) { this._stream.Seek((long)position.Offset, SeekOrigin.Begin); if ((!HttpRuntime.DisableProcessRequestInApplicationTrust && (HttpRuntime.NamedPermissionSet != null)) && HttpRuntime.ProcessRequestInApplicationTrust) { HttpRuntime.NamedPermissionSet.PermitOnly(); } object obj2 = this.ReadValueFromStreamWithAssert(); base.BaseSet(name, obj2); position.MarkDeserializedOffsetAndCheck(); } } } }
public void Serialize(BinaryWriter writer) { int count; int i; long iOffsetStart; long iValueStart; string key; object value; long curPos; byte[] buffer = null; Stream baseStream = writer.BaseStream; if (!HttpRuntime.DisableProcessRequestInApplicationTrust) { // VSWhidbey 427316: Sandbox Serialization in non full trust cases if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) { HttpRuntime.NamedPermissionSet.PermitOnly(); } } lock (_serializedItemsLock) { count = Count; writer.Write(count); if (count > 0) { if (BaseGet(null) != null) { // We have a value with a null key. Find its index. for (i = 0; i < count; i++) { key = BaseGetKey(i); if (key == null) { writer.Write(i); break; } } Debug.Assert(i != count); } else { writer.Write(NO_NULL_KEY); } // Write out all the keys. for (i = 0; i < count; i++) { key = BaseGetKey(i); if (key != null) { writer.Write(key); } } // Next, allocate space to store the offset: // - We won't store the offset of first item because it's always zero. // - The offset of an item is counted from the beginning of serialized values // - But we will store the offset of the first byte off the last item because // we need that to calculate the size of the last item. iOffsetStart = baseStream.Position; baseStream.Seek(SIZE_OF_INT32 * count, SeekOrigin.Current); iValueStart = baseStream.Position; for (i = 0; i < count; i++) { // See if that item has not be deserialized yet. if (_serializedItems != null && i < _serializedItems.Count && !((SerializedItemPosition)_serializedItems[i]).IsDeserialized) { SerializedItemPosition position = (SerializedItemPosition)_serializedItems[i]; Debug.Assert(_stream != null); // The item is read as serialized data from a store, and it's still // serialized, meaning no one has referenced it. Just copy // the bytes over. // Move the stream to the serialized data and copy it over to writer _stream.Seek(position.Offset, SeekOrigin.Begin); if (buffer == null || buffer.Length < position.DataLength) { buffer = new Byte[position.DataLength]; } #if DBG int read = #endif _stream.Read(buffer, 0, position.DataLength); #if DBG Debug.Assert(read == position.DataLength); #endif baseStream.Write(buffer, 0, position.DataLength); } else { value = BaseGet(i); WriteValueToStreamWithAssert(value, writer); } curPos = baseStream.Position; // Write the offset baseStream.Seek(i * SIZE_OF_INT32 + iOffsetStart, SeekOrigin.Begin); writer.Write((int)(curPos - iValueStart)); // Move back to current position baseStream.Seek(curPos, SeekOrigin.Begin); Debug.Trace("SessionStateItemCollection", "Serialize: curPost=" + curPos + ", offset= " + (int)(curPos - iValueStart)); } } #if DBG writer.Write((byte)0xff); #endif } }
public void Serialize(BinaryWriter writer) { byte[] buffer = null; Stream baseStream = writer.BaseStream; if ((!HttpRuntime.DisableProcessRequestInApplicationTrust && (HttpRuntime.NamedPermissionSet != null)) && HttpRuntime.ProcessRequestInApplicationTrust) { HttpRuntime.NamedPermissionSet.PermitOnly(); } lock (this._serializedItemsLock) { int count = this.Count; writer.Write(count); if (count > 0) { int num2; if (base.BaseGet((string)null) != null) { for (num2 = 0; num2 < count; num2++) { if (base.BaseGetKey(num2) == null) { writer.Write(num2); break; } } } else { writer.Write(-1); } num2 = 0; while (num2 < count) { string str = base.BaseGetKey(num2); if (str != null) { writer.Write(str); } num2++; } long num3 = baseStream.Position; baseStream.Seek((long)(4 * count), SeekOrigin.Current); long num4 = baseStream.Position; for (num2 = 0; num2 < count; num2++) { if (((this._serializedItems != null) && (num2 < this._serializedItems.Count)) && !((SerializedItemPosition)this._serializedItems[num2]).IsDeserialized) { SerializedItemPosition position = (SerializedItemPosition)this._serializedItems[num2]; this._stream.Seek((long)position.Offset, SeekOrigin.Begin); if ((buffer == null) || (buffer.Length < position.DataLength)) { buffer = new byte[position.DataLength]; } this._stream.Read(buffer, 0, position.DataLength); baseStream.Write(buffer, 0, position.DataLength); } else { object obj2 = base.BaseGet(num2); this.WriteValueToStreamWithAssert(obj2, writer); } long offset = baseStream.Position; baseStream.Seek((num2 * 4) + num3, SeekOrigin.Begin); writer.Write((int)(offset - num4)); baseStream.Seek(offset, SeekOrigin.Begin); } } } }