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