public override void Write(CompactBinaryWriter writer, object graph) { Type enumType = Enum.GetUnderlyingType(ActualType); ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForType(enumType,writer.Context.CacheContext); writer.Write(typeSurr.TypeHandle); typeSurr.Write(writer, graph); }
public override void Serialize(object serializable, Stream outputStream) { Initialize(); var output = new OutputStream(outputStream); var writer = new CompactBinaryWriter<OutputStream>(output); _serializerStream.Serialize(serializable, writer); }
public static ArraySegment<byte> Serialize(object obj) { var writer = new CompactBinaryWriter(); Serializer serializer = new Serializer(writer); serializer.SerializeHelper(obj, SirenMachine.GetType(obj.GetType())); return writer.ToBuffer(); }
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)); }
/// <summary> /// Serializes an object into the specified stream. /// </summary> /// <param name="stream">specified stream</param> /// <param name="graph">object</param> static public void Serialize(Stream stream, object graph,string cacheContext) { using(CompactBinaryWriter writer = new CompactBinaryWriter(stream)) { Serialize(writer, graph,cacheContext); } }
public override void WriteDirect(CompactBinaryWriter writer, object graph) { Decimal[] array = (Decimal[])graph; writer.Write(array.Length); for (int i = 0; i < array.Length; i++) CompactBinaryFormatter.Serialize(writer, ((decimal)array[i]).ToString(), writer.CacheContext); }
public override void WriteDirect(CompactBinaryWriter writer, object graph) { object[] array = (object[])graph; writer.Write(array.Length); if (!typeof(object[]).Equals(graph.GetType())) { object obj = null; for (int i = 0; i < array.Length; i++) { if (array[i] != null) { obj = array[i]; break; } } ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(obj, writer.CacheContext); writer.Write(surrogate.TypeHandle); if(surrogate.SubTypeHandle > 0) writer.Write(surrogate.SubTypeHandle); } else { ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(new object(), writer.CacheContext); writer.Write(surrogate.TypeHandle); } for (int i = 0; i < array.Length; i++) writer.WriteObject(array[i]); }
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 void WriteDirect(CompactBinaryWriter writer, object graph) { Int32[] array = (Int32[])graph; writer.Write(array.Length); for (int i = 0; i < array.Length; i++) writer.Write(array[i]); }
public override void WriteDirect(CompactBinaryWriter writer, object graph) { Array array = (Array)graph; writer.Write(array.Length); for (int i = 0; i < array.Length; i++) writer.WriteObject(array.GetValue(i)); }
public override void WriteDirect(CompactBinaryWriter writer, object graph) { IList list = (IList)graph; writer.Write(list.Count); for (int i = 0; i < list.Count; i++) writer.WriteObject(list[i]); }
public override void Write(CompactBinaryWriter writer, object graph) { ISerializationSurrogate decimalSurrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(decimal), null); AverageResult result = (AverageResult)graph; decimalSurrogate.Write(writer, result.Sum); decimalSurrogate.Write(writer, result.Count); }
/// <summary> /// Uses a <see cref="BinaryFormatter"/> to write an object of /// type <see cref="ActualType"/> to the underlying stream /// </summary> /// <param name="writer">stream writer</param> /// <param name="graph">object to be written to the stream reader</param> public override void Write(CompactBinaryWriter writer, object graph) { if (graph != null) { Serializer.AlertLegacySerialization(graph.GetType()); } formatter.Serialize(writer.BaseWriter.BaseStream, graph); }
public override string Serialize(object serializable) { Initialize(); var output = new OutputBuffer(2*1024); var writer = new CompactBinaryWriter<OutputBuffer>(output); _serializer.Serialize(serializable, writer); return Convert.ToBase64String(output.Data.Array, output.Data.Offset, output.Data.Count); }
/// <summary> /// Write an object of type <see cref="INxSerializationSurrogate.ActualType"/> to the stream writer /// </summary> /// <param name="writer">stream writer</param> /// <param name="graph">object to be written to the stream reader</param> public override void WriteDirect(CompactBinaryWriter writer, object graph) { Array array = (Array)graph; writer.Write(array.Length); writer.Write(graph.GetType().GetElementType().AssemblyQualifiedName); for (int i = 0; i < array.Length; i++) writer.WriteObject(array.GetValue(i)); }
/// <summary> /// Serializes a HealthCheck instance into a binary stream. /// </summary> /// <param name="value">HealthCheck instance to serialize.</param> /// <param name="binaryReader">BinaryReader instance to serialize into.</param> public void Write(HealthCheck value, BinaryWriter binaryWriter) { OutputBuffer output = new OutputBuffer(); CompactBinaryWriter <OutputBuffer> writer = new CompactBinaryWriter <OutputBuffer>(output); Serializer.Serialize(value, writer); binaryWriter.Write(output.Data.Count); binaryWriter.Write(output.Data.Array, output.Data.Offset, output.Data.Count); }
public override void WriteDirect(CompactBinaryWriter writer, object graph) { IDictionary dict = (IDictionary)graph; writer.Write(dict.Count); for (IDictionaryEnumerator i = dict.GetEnumerator(); i.MoveNext(); ) { writer.WriteObject(i.Key); writer.WriteObject(i.Value); } }
/// <summary> /// /// </summary> /// <param name="writer"></param> /// <param name="graph"></param> public override void WriteDirect(CompactBinaryWriter writer, object graph) { Array array = (Array)graph; writer.Write(array.Length); for (int i = 0; i < array.Length; i++) { writer.WriteObject(array.GetValue(i)); } }
public override void WriteDirect(CompactBinaryWriter writer, object graph) { IList list = (IList)graph; writer.Write(list.Count); for (int i = 0; i < list.Count; i++) { writer.WriteObject(list[i]); } }
public static ArraySegment <byte> SerializeSafeCB2NoInlining <T>(T obj) { var output = new Bond.IO.Safe.OutputBuffer(new byte[11]); var writer = new CompactBinaryWriter <Bond.IO.Safe.OutputBuffer>(output, 2); var serializer = new Serializer <CompactBinaryWriter <Bond.IO.Safe.OutputBuffer> >(typeof(T), false); serializer.Serialize(obj, writer); return(output.Data); }
/// <summary> /// Serializes a new bond value to an old bond blob /// </summary> /// <typeparam name="T">the type of the value</typeparam> /// <param name="value">the new bond value</param> /// <param name="bufferProvider">the buffer provider which provides buffers used during serialization</param> /// <returns>the old bond blow representing the new bond value</returns> public static Microsoft.Bond.BondBlob ToBlob <T>(T value, IBufferProvider bufferProvider) { OutputBuffer buffer = bufferProvider.GetOutputBuffer(); var startPosition = buffer.Position; CompactBinaryWriter <OutputBuffer> writer = new CompactBinaryWriter <OutputBuffer>(buffer); Serialize.To(writer, value); bufferProvider.ReleaseOutputBuffer(); return(new Microsoft.Bond.BondBlob(buffer.Data.Array, (int)startPosition, (int)(buffer.Position - startPosition))); }
public override void ParallelSerialize(object root, Stream stream) { var output = new OutputStream(stream); var writer = new CompactBinaryWriter <OutputStream>(output); Bond.Serialize.To(writer, root); output.Flush(); //stream.Position = 0; //_serializer.Serialize(root, writer); }
/// <summary> /// Serializes an object into the specified compact binary writer. /// </summary> /// <param name="writer">specified compact binary writer</param> /// <param name="graph">object</param> static internal void Serialize(CompactBinaryWriter writer, object graph) { // Find an appropriate surrogate for the object ISerializationSurrogate surrogate = TypeSurrogateProvider.GetSurrogateForObject(graph); // write type handle writer.Write(surrogate.TypeHandle); surrogate.Write(writer, graph); }
/// <summary> /// Escreve diretamente os dados da instancia no escritor. /// </summary> /// <param name="writer"></param> /// <param name="graph"></param> public override void WriteDirect(CompactBinaryWriter writer, object graph) { Array array = (Array)graph; writer.Write(array.Length); writer.Write(graph.GetType().GetElementType().AssemblyQualifiedName); for (int i = 0; i < array.Length; i++) { writer.WriteObject(array.GetValue(i)); } }
public override void Write(CompactBinaryWriter writer, object graph) { IDictionary dict = (IDictionary)graph; writer.Write(dict.Count); for (IDictionaryEnumerator i = dict.GetEnumerator(); i.MoveNext();) { writer.Write(i.Key); writer.Write(i.Value); } }
/// <summary> /// Serializes an object into the specified compact binary writer. /// </summary> /// <param name="writer">specified compact binary writer</param> /// <param name="graph">object</param> static internal void Serialize(CompactBinaryWriter writer, object graph, string cacheContext) { // Find an appropriate surrogate for the object ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(graph, cacheContext); // write type handle writer.Context.CacheContext = cacheContext; writer.Write(surrogate.TypeHandle); surrogate.Write(writer, graph); }
public override void Write(CompactBinaryWriter writer, object graph) { //Asad In case of Special strings the generated stream length and string length are different //So we should first convert the string to stream and then write stream lenght string str = (string)graph; byte[] stream = UTF8Encoding.UTF8.GetBytes(graph as string); int length = (int) stream.Length; writer.Write(length); writer.Write(stream); }
public static byte[] GetPayloadFromBondObject <T>(this T bondObject) where T : class, new() { bondObject.Validate("bondObject"); var output = new OutputBuffer(); var writer = new CompactBinaryWriter <OutputBuffer>(output); Serialize.To(writer, bondObject); return(output.Data.Array); }
public static byte[] Serialize(NCacheSessionData sessionData) { using (var stream = new MemoryStream()) { using (var writer = new CompactBinaryWriter(stream)) { SerializationUtility.SerializeDictionary(sessionData.Items, writer); } return(stream.GetBuffer()); } }
public static void TranscodeCBCB(Stream from, Stream to) { var input = new InputStream(from, 11); var reader = new CompactBinaryReader <InputStream>(input); var output = new OutputStream(to, 19); var writer = new CompactBinaryWriter <OutputStream>(output); Transcode.FromTo(reader, writer); output.Flush(); }
private void Stream_PositionLength_NotAccessedOnWriteStructBeginImplementation() { var stream = new NonSeekableStream(); var output = new OutputStream(stream, bufferLength: 11); var writer = new CompactBinaryWriter <OutputStream>(output, version: 2); var firstPass = writer.GetFirstPassWriter(); firstPass.WriteStructBegin(new Metadata()); firstPass.WriteStructEnd(); writer.WriteStructBegin(new Metadata()); }
internal static Frame MessageToFrame(ulong conversationId, string methodName, PayloadType type, IMessage payload, IBonded layerData) { var frame = new Frame(); { var headers = new EpoxyHeaders { conversation_id = conversationId, payload_type = type, method_name = methodName ?? string.Empty, // method_name is not nullable }; if (payload.IsError) { headers.error_code = payload.Error.Deserialize <Error>().error_code; } else { headers.error_code = (int)ErrorCode.OK; } var outputBuffer = new OutputBuffer(150); var fastWriter = new FastBinaryWriter <OutputBuffer>(outputBuffer); Serialize.To(fastWriter, headers); frame.Add(new Framelet(FrameletType.EpoxyHeaders, outputBuffer.Data)); } if (layerData != null) { var outputBuffer = new OutputBuffer(150); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); // TODO: See TODO below about issues with IBonded Marshal.TO(...) compactWriter.WriteVersion(); layerData.Serialize(compactWriter); frame.Add(new Framelet(FrameletType.LayerData, outputBuffer.Data)); } { var userData = payload.IsError ? (IBonded)payload.Error : (IBonded)payload.RawPayload; var outputBuffer = new OutputBuffer(1024); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); // TODO: marshal dies on IBonded Marshal.To(compactWriter, request) // understand more deeply why and consider fixing compactWriter.WriteVersion(); userData.Serialize(compactWriter); frame.Add(new Framelet(FrameletType.PayloadData, outputBuffer.Data)); } return(frame); }
public byte[] BondUnsafeCompactReusedCopied() { var output = new OutputBuffer(); var writer = new CompactBinaryWriter <OutputBuffer>(output); this.compactBondSerializer.Serialize(this.bondObject, writer); var resultArray = new byte[output.Data.Count]; Array.Copy(output.Data.Array, resultArray, output.Data.Count); return(resultArray); }
internal static Frame MessageToFrame( ulong conversationId, string serviceName, string methodName, EpoxyMessageType type, IMessage message, IBonded layerData, Logger logger) { var frame = new Frame(logger); { var headers = new EpoxyHeaders { conversation_id = conversationId, message_type = type, service_name = serviceName ?? string.Empty, // service_name is not nullable method_name = methodName ?? string.Empty // method_name is not nullable }; const int initialHeaderBufferSize = 150; var outputBuffer = new OutputBuffer(initialHeaderBufferSize); var fastWriter = new FastBinaryWriter <OutputBuffer>(outputBuffer); Serialize.To(fastWriter, headers); frame.Add(new Framelet(FrameletType.EpoxyHeaders, outputBuffer.Data)); } if (layerData != null) { const int initialLayerDataBufferSize = 150; var outputBuffer = new OutputBuffer(initialLayerDataBufferSize); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); compactWriter.WriteVersion(); layerData.Serialize(compactWriter); frame.Add(new Framelet(FrameletType.LayerData, outputBuffer.Data)); } { FrameletType frameletType = message.IsError ? FrameletType.ErrorData : FrameletType.PayloadData; IBonded userData = message.IsError ? message.Error : message.RawPayload; const int initialMessageBufferSize = 1024; var outputBuffer = new OutputBuffer(initialMessageBufferSize); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); compactWriter.WriteVersion(); userData.Serialize(compactWriter); frame.Add(new Framelet(frameletType, outputBuffer.Data)); } return(frame); }
IBonded CreateBondedTestData(string value) { var realLayerData = new Dummy { string_value = value }; var outputBuffer = new OutputBuffer(20); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); Marshal.To <CompactBinaryWriter <OutputBuffer>, Dummy>(compactWriter, realLayerData); return(Unmarshal.From(outputBuffer.Data)); }
internal static Frame MessageToFrame(ulong conversationId, string methodName, PayloadType type, IMessage message, IBonded layerData, Logger logger) { var frame = new Frame(logger); { var headers = new EpoxyHeaders { conversation_id = conversationId, payload_type = type, method_name = methodName ?? string.Empty, // method_name is not nullable }; if (message.IsError) { headers.error_code = message.Error.Deserialize <Error>().error_code; } else { headers.error_code = (int)ErrorCode.OK; } const int initialHeaderBufferSize = 150; var outputBuffer = new OutputBuffer(initialHeaderBufferSize); var fastWriter = new FastBinaryWriter <OutputBuffer>(outputBuffer); Serialize.To(fastWriter, headers); frame.Add(new Framelet(FrameletType.EpoxyHeaders, outputBuffer.Data)); } if (layerData != null) { const int initialLayerDataBufferSize = 150; var outputBuffer = new OutputBuffer(initialLayerDataBufferSize); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); compactWriter.WriteVersion(); layerData.Serialize(compactWriter); frame.Add(new Framelet(FrameletType.LayerData, outputBuffer.Data)); } { var userData = message.IsError ? (IBonded)message.Error : (IBonded)message.RawPayload; const int initialPayloadBufferSize = 1024; var outputBuffer = new OutputBuffer(initialPayloadBufferSize); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); compactWriter.WriteVersion(); userData.Serialize(compactWriter); frame.Add(new Framelet(FrameletType.PayloadData, outputBuffer.Data)); } return(frame); }
public override void Write(CompactBinaryWriter writer, object graph) { // In case of Special strings the generated stream length and string length are different //So we should first convert the string to stream and then write stream lenght string str = (string)graph; byte[] stream = UTF8Encoding.UTF8.GetBytes(graph as string); int length = (int)stream.Length; writer.Write(length); writer.Write(stream); }
private static bool ForceCompile <T>() where T : class, new() { var t1 = new T(); var buffer = new OutputBuffer(); var writer = new CompactBinaryWriter <OutputBuffer>(buffer); Bond.Serialize.To(writer, t1); var reader = new CompactBinaryReader <InputBuffer>(new InputBuffer(buffer.Data)); var t2 = Bond.Deserialize <T> .From(reader); return(Comparer.Equal(t1, t2)); }
public static byte[] SerializeBond <T>(T value) { byte[] buffer = bytePool.Rent(128); var outputBuffer = new OutputBuffer(buffer); var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer); Serialize.To(compactWriter, value); var result = new byte[outputBuffer.Data.Count]; Buffer.BlockCopy(buffer, outputBuffer.Data.Offset, result, 0, result.Length); bytePool.Return(buffer); return(result); }
public override void WriteDirect(CompactBinaryWriter writer, object graph) { IDictionary dictionary = (IDictionary)graph; writer.Write(dictionary.Count); IDictionaryEnumerator enumerator = dictionary.GetEnumerator(); while (enumerator.MoveNext()) { writer.WriteObject(enumerator.Key); writer.WriteObject(enumerator.Value); } }
/// <summary> /// Uses a <see cref="BinaryFormatter"/> to write an object of /// type <see cref="ActualType"/> to the underlying stream /// </summary> /// <param name="writer">stream writer</param> /// <param name="graph">object to be written to the stream reader</param> public override void Write(CompactBinaryWriter writer, object graph) { int cookie = writer.Context.GetCookie(graph); if (cookie != SerializationContext.INVALID_COOKIE) { writer.Write(cookie); return; } cookie = writer.Context.RememberObject(graph,true); writer.Write(cookie); ((SessionStateItemCollection)graph).Serialize(writer.BaseWriter); }
public void Stream_PositionLength_AsExpected() { 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 = MakeInputStream(stream.ToArray()); var reader = new CompactBinaryReader <TInputStream>(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 BondCompactBinaryWriter(bool preferCompactBinaryV1OverV2) { var type = typeof(T); if (!type.IsBondStruct()) { throw new NotSupportedException(); } this.manifestId = type.GetTypeIdentifier(); this.serializer = new Serializer <CompactBinaryWriter <OutputBuffer> >(type); this.writer = new CompactBinaryWriter <OutputBuffer>(this.outputBuffer); this.protocol = preferCompactBinaryV1OverV2 ? Protocol.CompactBinaryV1 : Protocol.CompactBinaryV2; }
/// <summary> /// Uses a <see cref="BinaryFormatter"/> to write an object of /// type <see cref="ActualType"/> to the underlying stream /// </summary> /// <param name="writer">stream writer</param> /// <param name="graph">object to be written to the stream reader</param> public override void Write(CompactBinaryWriter writer, object graph) { int cookie = writer.Context.GetCookie(graph); if (cookie != SerializationContext.INVALID_COOKIE) { writer.Write(cookie); return; } cookie = writer.Context.RememberObject(graph, true); writer.Write(cookie); ((HttpStaticObjectsCollection)graph).Serialize(writer.BaseWriter); }
public static void SerializeCB2Multiple <T>(T obj, Stream stream, uint times) { var output = new OutputStream(stream, 11); var writer = new CompactBinaryWriter <OutputStream>(output, 2); for (uint i = 0; i < times; i++) { Serialize.To(writer, obj); // Verify that CBv2 writer has an active FirstPassWriter before the next top-level serialization Assert.NotNull(writer.GetFirstPassWriter()); } output.Flush(); }
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); }
/// <summary> /// Converts a list of <see cref="RelayMessage"/> into a <see cref="MemoryStream"/> /// </summary> /// <param name="messageList">The list to convert.</param> /// <param name="stream">The stream to write <paramref name="messageList"/> into.</param> public static void WriteRelayMessageList(IList <RelayMessage> messageList, Stream stream) { BinaryWriter writeStream = new BinaryWriter(stream); CompactBinaryWriter writer = new CompactBinaryWriter(writeStream); writer.Write(messageList.Count); for (int i = 0; i < messageList.Count; i++) { writer.Write <RelayMessage>(messageList[i], false); } //this seek can't happen on methods passed to async socket client, because everything breaks and then you're confused and sad //TODO make async socket client not reliant on stream position and/or roll async functionality into regular socket client. //stream.Seek(0, SeekOrigin.Begin); }
/// <summary> /// Converts a list of <see cref="RelayMessage"/> into a <see cref="MemoryStream"/> /// </summary> /// <param name="messageList">The list to convert.</param> /// <returns>The <see cref="MemoryStream"/> that represents the list.</returns> public static MemoryStream WriteRelayMessageList(IList<RelayMessage> messageList) { MemoryStream ms = new MemoryStream(); BinaryWriter writeStream = new BinaryWriter(ms); CompactBinaryWriter writer = new CompactBinaryWriter(writeStream); writer.Write(messageList.Count); for (int i = 0; i < messageList.Count; i++) { writer.Write<RelayMessage>(messageList[i], false); } ms.Seek(0, SeekOrigin.Begin); return ms; }
/// <summary> /// Uses a <see cref="BinaryFormatter"/> to write an object of /// type <see cref="ActualType"/> to the underlying stream /// </summary> /// <param name="writer">stream writer</param> /// <param name="graph">object to be written to the stream reader</param> public override void Write(CompactBinaryWriter writer, object graph) { int cookie = writer.Context.GetCookie(graph); if (cookie != SerializationContext.INVALID_COOKIE) { writer.Write(cookie); return; } cookie = writer.Context.RememberObject(graph, true); writer.Write(cookie); //BigClustered: Using new instance of binary fomatter instead of static which may cause exception when shared by multiple threads. BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(writer.BaseWriter.BaseStream, graph); }
/// <summary> /// Salva os dados do objeto no escritor informado. /// </summary> /// <param name="writer"></param> /// <param name="graph">Instancia que serĂ¡ registrada no escritor.</param> public sealed override void Write(CompactBinaryWriter writer, object graph) { int cookie = writer.Context.GetCookie(graph); if (cookie != -1) { writer.Write(cookie); } else { cookie = writer.Context.RememberObject(graph); writer.Write(cookie); this.WriteDirect(writer, graph); } }
public override void Write(CompactBinaryWriter writer, object graph) { string text1 = (string)graph; if (text1 == null) { writer.Write(-1); return; } byte[] bytes = Encoding.UTF8.GetBytes(graph as string); int length = bytes.Length; writer.Write(length); writer.Write(bytes); }
static void Main() { var src = new Example { id = new Guid("{DC37ECC5-9E39-49C9-931B-51138D648262}") }; 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(dst.id == src.id); }
static void Main() { var src = new Example { Name = "FooBar", Constants = { 3.14, 6.28 } }; 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 void WriteDirect(CompactBinaryWriter writer, object graph) { String[] array = (String[])graph; writer.Write(array.Length); for (int i = 0; i < array.Length; i++) { if (array[i] != null) { writer.Write((short)1); byte[] stream = UTF8Encoding.UTF8.GetBytes(array[i] as string); writer.Write(stream.Length); writer.Write(stream); } else { writer.Write((short)0); } } }
static void Main() { var src = new Example { Price = 9999999999999999999999999999M, Numbers = { 79228162514264337593543950335M } }; 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)); }
static void Main() { var src = new Example { Now = DateTime.Now, Dates = { new DateTime(2017, 1, 29) } }; 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)); }
static void Main() { var src = new Example { Name = "foo", Constants = { 3.14, 6.28 } }; var output = new OutputBuffer(); var writer = new CompactBinaryWriter<OutputBuffer>(output); Marshal.To(writer, src); var input = new InputBuffer(output.Data); // We don't need to specify protocol for unmarshaling, // it is determined from information stored in the payload. var dst = Unmarshal<Example>.From(input); Debug.Assert(Comparer.Equal(src, dst)); }
static void Main() { var src = new Message { Header = new Header { Origin = "contoso.com", Destination = "fabrikam.com" }, Priority = Priority.Normal, MessagePayload = 42 }; 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<Message>.From(reader); Debug.Assert(Comparer.Equal(src, dst)); }
static void Main() { var src = new Example { id_str = new Guid("{DC37ECC5-9E39-49C9-931B-51138D648262}"), id_bin = new Guid("{0F5F6768-1608-4D5C-A11D-B176D0D792B5}"), }; 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(dst.id_str == src.id_str); Debug.Assert(dst.id_bin == src.id_bin); }
static void Main() { var output = new OutputBuffer(); var writer = new CompactBinaryWriter<OutputBuffer>(output); // Get runtime schema for type Example and serialize SchemaDef Serialize.To(writer, Schema<Example>.RuntimeSchema.SchemaDef); var input = new InputBuffer(output.Data); var reader = new CompactBinaryReader<InputBuffer>(input); var schemaDef = Deserialize<SchemaDef>.From(reader); var schema = new RuntimeSchema(schemaDef); Debug.Assert(schema.IsStruct); Debug.Assert(schema.StructDef.metadata.qualified_name == "Examples.Example"); Debug.Assert(schema.StructDef.metadata.attributes["StructAttribute"] == "Value of the attribute"); Debug.Assert(schema.StructDef.fields[0].metadata.attributes["FieldAttribute"] == "Value of the attribute"); Debug.Assert(schema.StructDef.fields[0].type.key.id == BondDataType.BT_UINT32); Debug.Assert(schema.SchemaDef.structs[1].fields[0].metadata.default_value.string_value == "this is a string"); }