internal void Serialize(BinaryWriter writer)
{
IDictionaryEnumerator e;
HttpStaticObjectsEntry entry;
bool hasInstance;
writer.Write(Count);
e = _objects.GetEnumerator();
while (e.MoveNext())
{
entry = (HttpStaticObjectsEntry)e.Value;
writer.Write(entry.Name);
hasInstance = entry.HasInstance;
writer.Write(hasInstance);
if (hasInstance)
{
AltSerialization.WriteValueToStream(entry.Instance, writer);
}
else
{
writer.Write(entry.ObjectType.FullName);
writer.Write(entry.LateBound);
}
}
}
static internal HttpStaticObjectsCollection Deserialize(BinaryReader reader)
{
int count;
string name;
string typename;
bool hasInstance;
Object instance;
HttpStaticObjectsEntry entry;
HttpStaticObjectsCollection col;
col = new HttpStaticObjectsCollection();
count = reader.ReadInt32();
while (count-- > 0)
{
name = reader.ReadString();
hasInstance = reader.ReadBoolean();
if (hasInstance)
{
instance = AltSerialization.ReadValueFromStream(reader);
entry = new HttpStaticObjectsEntry(name, instance, 0);
}
else
{
typename = reader.ReadString();
bool lateBound = reader.ReadBoolean();
entry = new HttpStaticObjectsEntry(name, Type.GetType(typename), lateBound);
}
col._objects.Add(name, entry);
}
return(col);
}
static internal SessionDictionary Deserialize(BinaryReader reader)
{
SessionDictionary d = new SessionDictionary();
int count;
int nullKey;
String key;
Object value;
int i;
count = reader.ReadInt32();
nullKey = reader.ReadInt32();
for (i = 0; i < count; i++)
{
if (i == nullKey)
{
key = null;
}
else
{
key = reader.ReadString();
}
value = AltSerialization.ReadValueFromStream(reader);
d.BaseSet(key, value);
}
d._dirty = false;
return(d);
}
public void DeserializeValueFields(object value, AltSerialization serialization)
{
IntPtr ptr = IntPtr.Zero;
#if !SAFE_COPY
ptr = GetPtr(value);
#endif
DeserializeValueFields(value, serialization, ptr);
}
public static MemoryStream SerializeToStream(object value, byte useCompression, bool altSerialization = USE_ALT)
{
using (var memory = new MemoryStream())
{
if (altSerialization)
{
memory.WriteByte((byte)'a');
memory.WriteByte(useCompression);
}
else
{
if (useCompression > 0)
{
memory.WriteByte((byte)'c');
memory.WriteByte(useCompression);
}
else
{
memory.WriteByte((byte)'b');
}
}
Stream gzip = null;
switch (useCompression)
{
case 0: gzip = memory; break;
case 1: gzip = new GZipStream(memory, CompressionMode.Compress); break;
case 2: gzip = new DeflateStream(memory, CompressionMode.Compress); break;
//case 3: gzip = new SevenZip.LzmaEncodeStream(memory); break;
}
using (gzip)
{
if (altSerialization)
#if !SAFE_COPY
{ lock (AltSerialization.Locker)
#endif
AltSerialization.Serialize(gzip, value); }
else
{
var bi = new BinaryFormatter();
bi.Serialize(gzip, value);
}
}
return(memory);
}
}
public static object DeserializeFromStream(Stream stream)
{
int dataType = stream.ReadByte();
if (dataType < 0)
{
return(null);
}
object o = null;
byte useCompression = 0;
Stream gzip = null;
if (dataType == 'c' || dataType == 'a')
{
useCompression = (byte)stream.ReadByte();
}
switch (useCompression)
{
case 0: gzip = stream; break;
case 1: gzip = new GZipStream(stream, CompressionMode.Decompress); break;
case 2: gzip = new DeflateStream(stream, CompressionMode.Decompress); break;
//case 3: gzip = new SevenZip.LzmaDecodeStream(stream); break;
}
using (gzip)
{
if (dataType == 'a')
#if !SAFE_COPY
{ lock (AltSerialization.Locker)
#endif
o = AltSerialization.Deserialize(gzip); }
else
{
var bi = new BinaryFormatter();
o = bi.Deserialize(gzip);
}
}
return(o);
}
internal void Serialize(BinaryWriter writer)
{
int count;
int i;
String key;
Object value;
count = Count;
writer.Write(count);
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);
}
for (i = 0; i < count; i++)
{
key = BaseGetKey(i);
if (key != null)
{
writer.Write(key);
}
value = BaseGet(i);
AltSerialization.WriteValueToStream(value, writer);
}
}
void SerializeValueFields(object value, AltSerialization serialization, IntPtr ptr)
{
if (BaseType != null)
{
BaseType.SerializeValueFields(value, serialization, ptr);
}
#if SAFE_COPY
foreach (var field in ValueFields)
{
serialization.Serialize(field.GetValue(value), field.FieldType.IsSealed ? field.FieldType : null);
}
#else
if (valueFieldsSize > 0)
{
//lock (locker)
Marshal.Copy(ptr + valueFieldsStart, data, 0, valueFieldsSize);
serialization.Writer.Write(data, 0, valueFieldsSize);
}
#endif
}
void DeserializeValueFields(object value, AltSerialization serialization, IntPtr ptr)
{
if (BaseType != null)
{
BaseType.DeserializeValueFields(value, serialization, ptr);
}
#if SAFE_COPY
foreach (var field in ValueFields)
{
field.SetValue(value, serialization.Deserialize(field.FieldType.IsSealed ? field.FieldType : null));
}
#else
if (valueFieldsSize > 0)
{
//var data = new byte[valueFieldsSize];
serialization.Reader.Read(data, 0, valueFieldsSize);
//lock (locker)
Marshal.Copy(data, 0, ptr + valueFieldsStart, valueFieldsSize);
}
#endif
}
public void Serialize(BinaryWriter writer)
{
writer.Write(this.Count);
IDictionaryEnumerator enumerator = this._objects.GetEnumerator();
while (enumerator.MoveNext())
{
HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)enumerator.Value;
writer.Write(entry.Name);
bool hasInstance = entry.HasInstance;
writer.Write(hasInstance);
if (hasInstance)
{
AltSerialization.WriteValueToStream(entry.Instance, writer);
}
else
{
writer.Write(entry.ObjectType.FullName);
writer.Write(entry.LateBound);
}
}
}
public static HttpStaticObjectsCollection Deserialize(BinaryReader reader)
{
HttpStaticObjectsCollection objectss = new HttpStaticObjectsCollection();
int num = reader.ReadInt32();
while (num-- > 0)
{
HttpStaticObjectsEntry entry;
string name = reader.ReadString();
if (reader.ReadBoolean())
{
object instance = AltSerialization.ReadValueFromStream(reader);
entry = new HttpStaticObjectsEntry(name, instance, 0);
}
else
{
string typeName = reader.ReadString();
bool lateBound = reader.ReadBoolean();
entry = new HttpStaticObjectsEntry(name, Type.GetType(typeName), lateBound);
}
objectss._objects.Add(name, entry);
}
return(objectss);
}
private void WriteValueToStreamWithAssert(object value, BinaryWriter writer)
{
AltSerialization.WriteValueToStream(value, writer);
}
private object ReadValueFromStreamWithAssert()
{
return(AltSerialization.ReadValueFromStream(new BinaryReader(_stream)));
}
