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);
}
}
}
}
