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