public override void SkipDirect(CompactBinaryReader reader, object graph)
{
int length = reader.ReadInt32();
IList list = (IList)graph;
for (int i = 0; i < length; i++)
reader.SkipObject();
}
static void Main()
{
var data = Enumerable.Range(0, 255).Select(i => (byte)i).ToArray();
var src = new Example
{
ListOfBlobs =
{
new ArraySegment<byte>(data, 0, 10),
new ArraySegment<byte>(data, 10, 10)
},
NullableBlob = new ArraySegment<byte>(data, 20, 10),
UninitializeBlob = new ArraySegment<byte>(data, 30, 70)
};
var output = new OutputBuffer();
var writer = new CompactBinaryWriter<OutputBuffer>(output);
Serialize.To(writer, src);
var input = new InputBuffer(output.Data);
var reader = new CompactBinaryReader<InputBuffer>(input);
var dst = Deserialize<Example>.From(reader);
Debug.Assert(Comparer.Equal(src, dst));
}
public override object Deserialize(Stream inputStream)
{
Initialize();
var input = new InputStream(inputStream);
var reader = new CompactBinaryReader<InputStream>(input);
return _deserializerStream.Deserialize(reader);
}
static void Main()
{
// The Example type internally uses instances generic schemas Generic1 and Generic2
var src = new Example
{
Field = { Field = new Generic2<int> { Field = 13 } }
};
// We can also instantiate generic schema in the C# program
var src1 = new Generic1<Example> { Field = src };
var src2 = new Generic2<double> {Field = 3.14};
var output = new OutputBuffer();
var writer = new CompactBinaryWriter<OutputBuffer>(output);
Serialize.To(writer, src);
Serialize.To(writer, src1);
Serialize.To(writer, src2);
var input = new InputBuffer(output.Data);
var reader = new CompactBinaryReader<InputBuffer>(input);
var dst = Deserialize<Example>.From(reader);
Debug.Assert(Comparer.Equal(src, dst));
var dst1 = Deserialize<Generic1<Example>>.From(reader);
Debug.Assert(Comparer.Equal(src1, dst1));
var dst2 = Deserialize<Generic2<double>>.From(reader);
Debug.Assert(Comparer.Equal(src2, dst2));
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
Decimal[] array = (Decimal[])graph;
for (int i = 0; i < array.Length; i++)
array[i] = (decimal)CompactBinaryFormatter.Deserialize(reader, reader.CacheContext, false);
return array;
}
public override void Skip(CompactBinaryReader reader)
{
// Find an appropriate surrogate by handle
short handle = reader.ReadInt16();
ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.Context.CacheContext);
typeSurr.Skip(reader);
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
Array array = (Array)graph;
for (int i = 0; i < array.Length; i++)
array.SetValue(reader.ReadObject(), i);
return array;
}
public override object Deserialize(Stream stream)
{
var input = new InputStream(stream);
var reader = new CompactBinaryReader<InputStream>(input);
return Bond.Deserialize<object>.From(reader);
//return _deserializer.Deserialize(reader);
}
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
Array array = (Array)graph;
for (int i = 0; i < array.Length; i++)
reader.SkipObject();
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
Int32[] array = (Int32[])graph;
for (int i = 0; i < array.Length; i++)
array[i] = reader.ReadInt32();
return array;
}
public override object Deserialize(string serialized)
{
Initialize();
var bytes = Convert.FromBase64String(serialized);
var input = new InputBuffer(bytes);
var reader = new CompactBinaryReader<InputBuffer>(input);
return _deserializer.Deserialize(reader);
}
public override object Read(CompactBinaryReader reader)
{
int length = reader.ReadInt32();
byte[] stream = new byte[length];
stream = reader.ReadBytes(length);
return UTF8Encoding.UTF8.GetString(stream);
//return reader.ReadString();
}
public override object Read(CompactBinaryReader reader)
{
// Find an appropriate surrogate by handle
short handle = reader.ReadInt16();
ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle,reader.Context.CacheContext);
return Enum.ToObject(ActualType, typeSurr.Read(reader));
}
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
object[] array = (object[])graph;
short handle = reader.ReadInt16();
ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.CacheContext);
for (int i = 0; i < array.Length; i++)
reader.SkipObject();
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
int length = reader.ReadInt32();
IList list = (IList)graph;
for (int i = 0; i < length; i++)
list.Add(reader.ReadObject());
return list;
}
/// <summary>
/// Uses a <see cref="BinaryFormatter"/> to read an object of
/// type <see cref="ActualType"/> from the underlying stream.
/// </summary>
/// <param name="reader">stream reader</param>
/// <returns>object read from the stream reader</returns>
public override object Read(CompactBinaryReader reader)
{
object result = formatter.Deserialize(reader.BaseStream);
if (result != null)
{
Serializer.AlertLegacySerialization(result.GetType());
}
return result;
}
public override object Read(CompactBinaryReader reader)
{
ISerializationSurrogate decimalSurrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(decimal), null);
AverageResult result = new AverageResult();
result.Sum = (decimal)decimalSurrogate.Read(reader);
result.Count = (decimal)decimalSurrogate.Read(reader);
return result;
}
/// <summary>
/// Non default object construction. The idea is to circumvent constructor calls
/// and populate the object in <see cref="ICompactSerializable.Deserialize"/> method.
/// </summary>
/// <returns></returns>
public override object Instantiate(CompactBinaryReader reader)
{
object obj = null;
if(reader.Context.MemManager != null)
obj = GetInstance(reader.Context.MemManager);
if(obj == null)
obj = FormatterServices.GetUninitializedObject(ActualType);
return obj;
}
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
int length = reader.ReadInt32();
IDictionary dict = (IDictionary)graph;
for (int i = 0; i < length; i++)
{
reader.SkipObject();
reader.SkipObject();
}
}
public override void Skip(CompactBinaryReader reader)
{
int cookie = reader.ReadInt32();
object custom = reader.Context.GetObject(cookie);
if (custom == null)
{
custom = SessionStateItemCollection.Deserialize(reader.BaseReader);
reader.Context.RememberObject(custom,false);
}
}
public override object Instantiate(CompactBinaryReader reader)
{
int length = reader.ReadInt32();
string typeName = reader.ReadString();
Type t = Type.GetType(typeName);
object graph = Array.CreateInstance(t, length);
return graph;
}
/// <summary>
/// Uses a <see cref="BinaryFormatter"/> to read an object of
/// type <see cref="ActualType"/> from the underlying stream.
/// </summary>
/// <param name="reader">stream reader</param>
/// <returns>object read from the stream reader</returns>
public override object Read(CompactBinaryReader reader)
{
int cookie = reader.ReadInt32();
object custom = reader.Context.GetObject(cookie);
if (custom == null)
{
custom = HttpStaticObjectsCollection.Deserialize(reader.BaseReader);
reader.Context.RememberObject(custom,false);
}
return custom;
}
public override void Skip(CompactBinaryReader reader)
{
int cookie = reader.ReadInt32();
object custom = reader.Context.GetObject(cookie);
if (custom == null)
{
BinaryFormatter formatter = new BinaryFormatter();
custom = formatter.Deserialize(reader.BaseReader.BaseStream);
reader.Context.RememberObject(custom,false);
}
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
int length = reader.ReadInt32();
IDictionary dict = (IDictionary)graph;
for (int i = 0; i < length; i++)
{
object key = reader.ReadObject();
object value = reader.ReadObject();
dict.Add(key, value);
}
return dict;
}
private static object DeserializeCompactBinary(
ushort version,
byte[] data,
Deserializer<CompactBinaryReader<InputBuffer>> deserializer)
{
var inputStream = new InputBuffer(data);
var reader = new CompactBinaryReader<InputBuffer>(inputStream, version);
var outputObject = deserializer.Deserialize(reader);
return outputObject;
}
public SimpleMDInstrument(IEnvironment env, CompactBinaryReader theFile)
{
this.env = env;
this.theFile = theFile;
Model = new SimpleMDQuoteModel();
Run(0);
// env.Scheduler.ScheduleAt(timestamp, update.Dispatch);
// schedule loading of the next update
// env.Scheduler.ScheduleAt(timestamp, Run);
}
/// <summary>
/// Uses a <see cref="BinaryFormatter"/> to read an object of
/// type <see cref="ActualType"/> from the underlying stream.
/// </summary>
/// <param name="reader">stream reader</param>
/// <returns>object read from the stream reader</returns>
public override object Read(CompactBinaryReader reader)
{
int cookie = reader.ReadInt32();
object custom = reader.Context.GetObject(cookie);
if (custom == null)
{
//using new instance of binary fomatter instead of static which may cause exception when shared by multiple threads.
BinaryFormatter formatter = new BinaryFormatter();
custom = formatter.Deserialize(reader.BaseReader.BaseStream);
reader.Context.RememberObject(custom, false);
}
return custom;
}
public void StreamPositionLengthTest()
{
const int _50MB = 50*1024*1024;
var from1 = Random.Init<Containers>();
var from2 = Random.Init<Containers>();
var stream = new MemoryStream();
var output = new OutputStream(stream, 11);
var writer = new CompactBinaryWriter<OutputStream>(output);
Assert.IsTrue(output.Position == 0);
Serialize.To(writer, from1);
var pos = output.Position;
output.Flush();
Assert.IsTrue(output.Position == pos);
Assert.IsTrue(output.Position == stream.Length);
output.Position = _50MB;
Serialize.To(writer, from2);
output.Flush();
pos = output.Position;
stream.Position = 0;
var input = new InputStream(stream);
var reader = new CompactBinaryReader<InputStream>(input);
Assert.IsTrue(input.Position == stream.Position);
Assert.IsTrue(input.Length == stream.Length);
var to1 = Deserialize<Containers>.From(reader);
Assert.IsTrue(from1.IsEqual<Containers>(to1));
Assert.IsTrue(input.Length == stream.Length);
input.Position = _50MB;
var to2 = Deserialize<Containers>.From(reader);
Assert.IsTrue(from2.IsEqual<Containers>(to2));
Assert.IsTrue(input.Position == pos);
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
object[] array = (object[])graph;
short handle = reader.ReadInt16();
ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.CacheContext);
Object obj = Array.CreateInstance(surrogate.ActualType, array.Length);
for (int i = 0; i < array.Length; i++)
((Array)obj).SetValue(reader.ReadObject(), i);
//array[i] = reader.ReadObject();
return obj;
}
public override object Instantiate(CompactBinaryReader reader)
{
int argumentsCount = reader.ReadInt32();
Type[] arguments = new Type[argumentsCount];
for (int i = 0; i < argumentsCount; i++)
{
string typeName = reader.ReadString();
arguments[i] = Type.GetType(typeName);
}
object graph = SurrogateHelper.CreateGenericType("System.Collections.Generic.List", arguments);
return graph;
}
public override void Skip(CompactBinaryReader reader)
{
reader.SkipDateTime();
}
public override object Read(CompactBinaryReader reader)
{
return(Convert.ToDecimal(CompactBinaryFormatter.Deserialize(reader, reader.CacheContext, false)));
}
public override object Read(CompactBinaryReader reader)
{
return(new Guid(reader.ReadString()));
}
public override object Instantiate(CompactBinaryReader reader)
{
return(new ushort[reader.ReadInt32()]);
}
public override object Read(CompactBinaryReader reader)
{
return(reader.ReadChar());
}
public override object Instantiate(CompactBinaryReader reader)
{
int length = reader.ReadInt32();
return(new Guid[length]);
}
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
}
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
((ICompactSerializable)graph).Deserialize(reader);
}
public override void Skip(CompactBinaryReader reader)
{
reader.SkipChar();
}
public static void AllSerializeDeserialize <From, To>(From from, bool noTranscoding = false)
where From : class
where To : class
{
RoundtripMemory <From, To> memoryRoundtrip = (serialize, deserialize) =>
{
var data = serialize(from);
var to = deserialize(data);
Assert.IsTrue(from.IsEqual(to));
};
RoundtripPointer <From, To> pointerRoundtrip = (serialize, deserialize) =>
{
var ptr = RMarshal.AllocHGlobal(UnsafeBufferSize);
var data = serialize(from, ptr, UnsafeBufferSize);
var to = deserialize(data, UnsafeBufferSize);
Assert.IsTrue(from.IsEqual(to));
RMarshal.FreeHGlobal(data);
};
RoundtripMemoryPointer <From, To> memoryPointerRoundtrip = (serialize, deserialize) =>
{
var data = serialize(from);
var pinned = GCHandle.Alloc(data.Array, GCHandleType.Pinned);
var to = deserialize(RMarshal.UnsafeAddrOfPinnedArrayElement(data.Array, data.Offset), data.Count);
Assert.IsTrue(from.IsEqual(to));
pinned.Free();
};
RoundtripStream <From, To> streamRoundtrip = (serialize, deserialize) =>
{
var stream = new MemoryStream();
serialize(from, stream);
stream.Position = 0;
var to = deserialize(stream);
Assert.IsTrue(from.IsEqual(to));
};
MarshalStream <From> streamMarshal = serialize => streamRoundtrip(serialize, stream =>
{
stream.Position = 0;
return(Unmarshal <To> .From(new InputStream(stream)));
});
MarshalStream <From> streamMarshalSchema = serialize => streamRoundtrip(serialize, stream =>
{
stream.Position = 0;
return(Unmarshal.From(new InputStream(stream), Schema <From> .RuntimeSchema).Deserialize <To>());
});
MarshalStream <From> streamMarshalNoSchema = serialize => streamRoundtrip(serialize, stream =>
{
stream.Position = 0;
return(Unmarshal.From(new InputStream(stream)).Deserialize <To>());
});
MarshalMemory <From> memoryMarshal = serialize => memoryRoundtrip(serialize, Unmarshal <To> .From);
TranscodeStream <From, To> streamTranscode = (serialize, transcode, deserialize) =>
streamRoundtrip((obj, stream) =>
{
using (var tmp = new MemoryStream())
{
serialize(obj, tmp);
tmp.Position = 0;
transcode(tmp, stream);
}
}, deserialize);
if (noTranscoding)
{
streamTranscode = (serialize, transcode, deserialize) => { }
}
;
// Compact Binary
streamRoundtrip(SerializeCB, DeserializeCB <To>);
memoryRoundtrip(SerializeUnsafeCB, DeserializeSafeCB <To>);
memoryRoundtrip(SerializeUnsafeCB, DeserializeUnsafeCB <To>);
memoryPointerRoundtrip(SerializeUnsafeCB, DeserializePointerCB <To>);
pointerRoundtrip(SerializePointerCB, DeserializePointerCB <To>);
memoryRoundtrip(SerializeSafeCB, DeserializeSafeCB <To>);
memoryRoundtrip(SerializeSafeCB, DeserializeUnsafeCB <To>);
memoryPointerRoundtrip(SerializeSafeCB, DeserializePointerCB <To>);
memoryRoundtrip(SerializeSafeCBNoInlining, DeserializeSafeCB <To>);
streamMarshal(MarshalCB);
streamMarshal(SerializerMarshalCB);
streamMarshalSchema(MarshalCB);
streamMarshalNoSchema(MarshalCB);
memoryMarshal(MarshalCB);
streamTranscode(SerializeCB, TranscodeCBCB, DeserializeCB <To>);
streamTranscode(SerializeCB, TranscodeCBFB, DeserializeFB <To>);
streamRoundtrip(SerializeCB, stream =>
{
var input = new InputStream(stream);
var reader = new CompactBinaryReader <InputStream>(input);
return(DeserializeTagged <To>(reader));
});
// Compact Binary v2
streamRoundtrip(SerializeCB2, DeserializeCB2 <To>);
memoryRoundtrip(SerializeUnsafeCB2, DeserializeSafeCB2 <To>);
memoryRoundtrip(SerializeUnsafeCB2, DeserializeUnsafeCB2 <To>);
memoryPointerRoundtrip(SerializeUnsafeCB2, DeserializePointerCB2 <To>);
pointerRoundtrip(SerializePointerCB2, DeserializePointerCB2 <To>);
memoryRoundtrip(SerializeSafeCB2, DeserializeSafeCB2 <To>);
memoryRoundtrip(SerializeSafeCB2, DeserializeUnsafeCB2 <To>);
memoryPointerRoundtrip(SerializeSafeCB2, DeserializePointerCB2 <To>);
memoryRoundtrip(SerializeSafeCB2NoInlining, DeserializeSafeCB2 <To>);
streamMarshal(MarshalCB2);
streamMarshal(SerializerMarshalCB2);
streamMarshalSchema(MarshalCB2);
streamMarshalNoSchema(MarshalCB2);
memoryMarshal(MarshalCB2);
streamTranscode(SerializeCB2, TranscodeCB2CB2, DeserializeCB2 <To>);
streamTranscode(SerializeCB2, TranscodeCB2FB, DeserializeFB <To>);
streamRoundtrip(SerializeCB2, stream =>
{
var input = new InputStream(stream);
var reader = new CompactBinaryReader <InputStream>(input, 2);
return(DeserializeTagged <To>(reader));
});
// Fast Binary
streamRoundtrip(SerializeFB, DeserializeFB <To>);
memoryRoundtrip(SerializeFB, DeserializeSafeFB <To>);
memoryRoundtrip(SerializeFB, DeserializeUnsafeFB <To>);
memoryPointerRoundtrip(SerializeFB, DeserializePointerFB <To>);
streamMarshal(MarshalFB);
streamMarshal(SerializerMarshalFB);
streamMarshalSchema(MarshalFB);
streamMarshalNoSchema(MarshalFB);
memoryMarshal(MarshalFB);
streamTranscode(SerializeFB, TranscodeFBFB, DeserializeFB <To>);
streamTranscode(SerializeFB, TranscodeFBCB, DeserializeCB <To>);
streamRoundtrip(SerializeFB, stream =>
{
var input = new InputStream(stream);
var reader = new FastBinaryReader <InputStream>(input);
return(DeserializeTagged <To>(reader));
});
#if SUPPORTS_BIGINTEGER
const bool hasBigInteger = true;
#else
const bool hasBigInteger = false;
#endif
// Simple doesn't support omitting fields
if (typeof(From) != typeof(Nothing) && typeof(From) != typeof(GenericsWithNothing))
{
streamRoundtrip(SerializeSP, DeserializeSP <From, To>);
memoryRoundtrip(SerializeSP, DeserializeSafeSP <From, To>);
memoryRoundtrip(SerializeSP, DeserializeUnsafeSP <From, To>);
memoryPointerRoundtrip(SerializeSP, DeserializePointerSP <From, To>);
streamRoundtrip(SerializeSP2, DeserializeSP2 <From, To>);
memoryRoundtrip(SerializeSP2, DeserializeSafeSP2 <From, To>);
memoryRoundtrip(SerializeSP2, DeserializeUnsafeSP2 <From, To>);
streamTranscode(SerializeCB, TranscodeCBSP <From>, DeserializeSP <From, To>);
streamTranscode(SerializeFB, TranscodeFBSP <From>, DeserializeSP <From, To>);
streamTranscode(SerializeSP, TranscodeSPSP <From>, DeserializeSP <From, To>);
streamTranscode(SerializeSP, TranscodeSPCB <From>, DeserializeCB <To>);
streamTranscode(SerializeSP, TranscodeSPCB2 <From>, DeserializeCB2 <To>);
streamTranscode(SerializeSP, TranscodeSPFB <From>, DeserializeFB <To>);
// Pull parser doesn't support bonded<T>
if (!AnyField <From>(Reflection.IsBonded))
{
streamTranscode(SerializeSP, TranscodeSPXml <From>, DeserializeXml <To>);
// NewtonSoft JSON doesn't fully support uint64 in portable profile, so we skip
// MaxUInt64 type where BigInteger isn't avaiable
if (hasBigInteger || (typeof(From) != typeof(MaxUInt64)))
{
streamTranscode(SerializeSP, TranscodeSPJson <From>, DeserializeJson <To>);
}
}
streamRoundtrip(SerializeSP, stream =>
{
var input = new InputStream(stream);
var reader = new SimpleBinaryReader <InputStream>(input);
return(DeserializeUntagged <From, To>(reader));
});
streamMarshalSchema(MarshalSP);
}
// Pull parser doesn't support bonded<T>
if (!AnyField <From>(Reflection.IsBonded))
{
streamRoundtrip(SerializeXml, DeserializeXml <To>);
streamTranscode(SerializeCB, TranscodeCBXml <From>, DeserializeXml <To>);
streamTranscode(SerializeFB, TranscodeFBXml <From>, DeserializeXml <To>);
// NewtonSoft JSON doesn't fully support uint64 in portable profile, so we skip
// MaxUInt64 type where BigInteger isn't avaiable
if (hasBigInteger || (typeof(From) != typeof(MaxUInt64)))
{
streamRoundtrip(SerializeJson, DeserializeJson <To>);
streamTranscode(SerializeCB, TranscodeCBJson <From>, DeserializeJson <To>);
streamTranscode(SerializeFB, TranscodeFBJson <From>, DeserializeJson <To>);
}
}
}
delegate bool TypePredicate(Type field);
/// <summary>
/// Cria uma instancia.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public override object Instantiate(CompactBinaryReader reader)
{
int length = reader.ReadInt32();
return(Array.CreateInstance(base.ActualType.GetElementType(), length));
}
public override void Skip(CompactBinaryReader reader)
{
reader.ReadBoolean();
}
public override object Instantiate(CompactBinaryReader reader)
{
int length = reader.ReadInt32();
return(reader.ReadChars(length));
}
public override object Instantiate(CompactBinaryReader reader)
{
int count = reader.ReadInt32();
return(reader.ReadChars(count));
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
return(graph);
}
abstract public object ReadDirect(CompactBinaryReader reader, object graph);
public override void Skip(CompactBinaryReader reader)
{
reader.SkipSingle();
}
abstract public void SkipDirect(CompactBinaryReader reader, object graph);
public override void Skip(CompactBinaryReader reader)
{
int length = reader.ReadInt32();
reader.SkipBytes(length);
}
virtual public object Instantiate(CompactBinaryReader reader)
{
return(base.CreateInstance());
}
static void Main()
{
var circle = new Circle
{
Type = Type.Circle,
Radius = 3.14
};
var rectangle = new Rectangle
{
Type = Type.Rectange,
Width = 10,
Height = 5.5
};
var src = new Polymorphic
{
Shapes =
{
new Bonded <Circle>(circle),
new Bonded <Rectangle>(rectangle)
}
};
var output = new OutputBuffer();
var writer = new CompactBinaryWriter <OutputBuffer>(output);
Serialize.To(writer, src);
var input = new InputBuffer(output.Data);
var reader = new CompactBinaryReader <InputBuffer>(input);
var dst = Deserialize <Polymorphic> .From(reader);
var deserializers = new Dictionary <Type, Deserializer <CompactBinaryReader <InputBuffer> > >
{
{ Type.Circle, new Deserializer <CompactBinaryReader <InputBuffer> >(typeof(Circle)) },
{ Type.Rectange, new Deserializer <CompactBinaryReader <InputBuffer> >(typeof(Rectangle)) }
};
foreach (var item in dst.Shapes)
{
// Deserialize item as Shape and extract object type
var type = item.Deserialize().Type;
// Select one of the precreated deserializers based on the item type
var shape = deserializers[type].Deserialize(item);
if (shape.GetType() == typeof(Circle))
{
Debug.Assert(Comparer.Equal(circle, shape as Circle));
}
if (shape.GetType() == typeof(Rectangle))
{
Debug.Assert(Comparer.Equal(rectangle, shape as Rectangle));
}
// Alternatively the generic method IBonded<T>.Deserialize<U> can be used
if (type == Type.Circle)
{
var c = item.Deserialize <Circle>();
Debug.Assert(Comparer.Equal(circle, c));
}
if (type == Type.Rectange)
{
var r = item.Deserialize <Rectangle>();
Debug.Assert(Comparer.Equal(rectangle, r));
}
}
}
public override object Read(CompactBinaryReader reader) /*returns default value*/ return
{
(this);
public static void AllSerializeDeserialize <From, To>(From from, bool noTranscoding = false)
where From : class
where To : class
{
RoundtripMemory <From, To> memoryRoundtrip = (serialize, deserialize) =>
{
var data = serialize(from);
var to = deserialize(data);
Assert.IsTrue(from.IsEqual(to));
};
RoundtripPointer <From, To> pointerRoundtrip = (serialize, deserialize) =>
{
var ptr = RMarshal.AllocHGlobal(UnsafeBufferSize);
var data = serialize(from, ptr, UnsafeBufferSize);
var to = deserialize(data, UnsafeBufferSize);
RMarshal.FreeHGlobal(data);
Assert.IsTrue(from.IsEqual(to));
};
RoundtripMemoryPointer <From, To> memoryPointerRoundtrip = (serialize, deserialize) =>
{
var data = serialize(from);
var pinned = GCHandle.Alloc(data.Array, GCHandleType.Pinned);
var to = deserialize(RMarshal.UnsafeAddrOfPinnedArrayElement(data.Array, data.Offset), data.Count);
pinned.Free();
Assert.IsTrue(from.IsEqual(to));
};
RoundtripStream <From, To> streamRoundtrip = (serialize, deserialize) =>
{
var stream = new MemoryStream();
serialize(from, stream);
stream.Position = 0;
var to = deserialize(stream);
Assert.IsTrue(from.IsEqual(to));
};
MarshalStream <From> streamMarshal = serialize => streamRoundtrip(serialize, stream =>
{
stream.Position = 0;
return(Unmarshal <To> .From(new InputStream(stream)));
});
MarshalStream <From> streamMarshalSchema = serialize => streamRoundtrip(serialize, stream =>
{
stream.Position = 0;
return(Unmarshal.From(new InputStream(stream), Schema <From> .RuntimeSchema).Deserialize <To>());
});
MarshalStream <From> streamMarshalNoSchema = serialize => streamRoundtrip(serialize, stream =>
{
stream.Position = 0;
return(Unmarshal.From(new InputStream(stream)).Deserialize <To>());
});
MarshalMemory <From> memoryMarshal = serialize => memoryRoundtrip(serialize, Unmarshal <To> .From);
TranscodeStream <From, To> streamTranscode = (serialize, transcode, deserialize) =>
streamRoundtrip((obj, stream) =>
{
using (var tmp = new MemoryStream())
{
serialize(obj, tmp);
tmp.Position = 0;
transcode(tmp, stream);
}
}, deserialize);
if (noTranscoding)
{
streamTranscode = (serialize, transcode, deserialize) => { }
}
;
// Compact Binary
streamRoundtrip(SerializeCB, DeserializeCB <To>);
memoryRoundtrip(SerializeUnsafeCB, DeserializeSafeCB <To>);
memoryRoundtrip(SerializeUnsafeCB, DeserializeUnsafeCB <To>);
memoryPointerRoundtrip(SerializeUnsafeCB, DeserializePointerCB <To>);
pointerRoundtrip(SerializePointerCB, DeserializePointerCB <To>);
memoryRoundtrip(SerializeSafeCB, DeserializeSafeCB <To>);
memoryRoundtrip(SerializeSafeCB, DeserializeUnsafeCB <To>);
memoryPointerRoundtrip(SerializeSafeCB, DeserializePointerCB <To>);
streamMarshal(MarshalCB);
streamMarshal(SerializerMarshalCB);
streamMarshalSchema(MarshalCB);
streamMarshalNoSchema(MarshalCB);
memoryMarshal(MarshalCB);
streamTranscode(SerializeCB, TranscodeCBCB, DeserializeCB <To>);
streamTranscode(SerializeCB, TranscodeCBFB, DeserializeFB <To>);
streamRoundtrip(SerializeCB, stream =>
{
var input = new InputStream(stream);
var reader = new CompactBinaryReader <InputStream>(input);
return(DeserializeTagged <To>(reader));
});
// Fast Binary
streamRoundtrip(SerializeFB, DeserializeFB <To>);
memoryRoundtrip(SerializeFB, DeserializeSafeFB <To>);
memoryRoundtrip(SerializeFB, DeserializeUnsafeFB <To>);
memoryPointerRoundtrip(SerializeFB, DeserializePointerFB <To>);
streamMarshal(MarshalFB);
streamMarshal(SerializerMarshalFB);
streamMarshalSchema(MarshalFB);
streamMarshalNoSchema(MarshalFB);
memoryMarshal(MarshalFB);
streamTranscode(SerializeFB, TranscodeFBFB, DeserializeFB <To>);
streamTranscode(SerializeFB, TranscodeFBCB, DeserializeCB <To>);
streamRoundtrip(SerializeFB, stream =>
{
var input = new InputStream(stream);
var reader = new FastBinaryReader <InputStream>(input);
return(DeserializeTagged <To>(reader));
});
// Simple doesn't support omitting fields
if (typeof(From) != typeof(Nothing) && typeof(From) != typeof(GenericsWithNothing))
{
streamRoundtrip(SerializeSP, DeserializeSP <From, To>);
memoryRoundtrip(SerializeSP, DeserializeSafeSP <From, To>);
memoryRoundtrip(SerializeSP, DeserializeUnsafeSP <From, To>);
memoryPointerRoundtrip(SerializeSP, DeserializePointerSP <From, To>);
streamRoundtrip(SerializeSP2, DeserializeSP2 <From, To>);
memoryRoundtrip(SerializeSP2, DeserializeSafeSP2 <From, To>);
memoryRoundtrip(SerializeSP2, DeserializeUnsafeSP2 <From, To>);
streamTranscode(SerializeCB, TranscodeCBSP <From>, DeserializeSP <From, To>);
streamTranscode(SerializeFB, TranscodeFBSP <From>, DeserializeSP <From, To>);
streamTranscode(SerializeSP, TranscodeSPSP <From>, DeserializeSP <From, To>);
streamTranscode(SerializeSP, TranscodeSPCB <From>, DeserializeCB <To>);
streamTranscode(SerializeSP, TranscodeSPFB <From>, DeserializeFB <To>);
streamTranscode(SerializeSP, TranscodeSPXml <From>, DeserializeXml <To>);
// NewtonSoft JSON doesn't support uint64
if (typeof(From) != typeof(MaxUInt64))
{
streamTranscode(SerializeSP, TranscodeSPJson <From>, DeserializeJson <To>);
}
streamRoundtrip(SerializeSP, stream =>
{
var input = new InputStream(stream);
var reader = new SimpleBinaryReader <InputStream>(input);
return(DeserializeUntagged <From, To>(reader));
});
streamMarshalSchema(MarshalSP);
}
streamRoundtrip(SerializeXml, DeserializeXml <To>);
streamTranscode(SerializeCB, TranscodeCBXml <From>, DeserializeXml <To>);
streamTranscode(SerializeFB, TranscodeFBXml <From>, DeserializeXml <To>);
// NewtonSoft JSON doesn't support uint64
if (typeof(From) != typeof(MaxUInt64))
{
streamRoundtrip(SerializeJson, DeserializeJson <To>);
streamTranscode(SerializeCB, TranscodeCBJson <From>, DeserializeJson <To>);
streamTranscode(SerializeFB, TranscodeFBJson <From>, DeserializeJson <To>);
}
}
}
/// <summary>
/// Lê os dados e cria uma instancia preenchida.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public override object Read(CompactBinaryReader reader)
{
return(_formatter.Deserialize(reader.BaseReader.BaseStream));
}
public override void Skip(CompactBinaryReader reader)
{
reader.SkipUInt16();
}
public override object Read(CompactBinaryReader reader)
{
return(reader.ReadDateTime());
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
((ICompactSerializable)graph).Deserialize(reader);
return(graph);
}
public override void Skip(CompactBinaryReader reader)
{
CompactBinaryFormatter.Deserialize(reader, reader.CacheContext, true);
}
/// <summary>
/// Salta os dados do leitor.
/// </summary>
/// <param name="reader"></param>
public override void Skip(CompactBinaryReader reader)
{
Read(reader);
}
public override object Read(CompactBinaryReader reader)
{
return(reader.ReadBoolean());
}
