public object Deserialize(Type expectedType, BinaryTokenStreamReader reader)
{
DeserializeCalled = true;
return(new FakeSerialized {
SomeData = "fake deserialization"
});
}
private static void VerifyUsingFallbackSerializer(object ob)
{
var writer = new BinaryTokenStreamWriter();
SerializationManager.FallbackSerializer(ob, writer, ob.GetType());
var bytes = writer.ToByteArray();
byte[] defaultFormatterBytes;
var formatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
formatter.Serialize(stream, ob);
stream.Flush();
defaultFormatterBytes = stream.ToArray();
}
var reader = new BinaryTokenStreamReader(bytes);
var serToken = reader.ReadToken();
Assert.Equal(SerializationTokenType.Fallback, serToken);
var length = reader.ReadInt();
Assert.Equal(length, defaultFormatterBytes.Length);
var segment = new ArraySegment <byte>(bytes, reader.CurrentPosition, bytes.Length - reader.CurrentPosition);
Assert.True(segment.SequenceEqual(defaultFormatterBytes));
}
internal static object Deserialize(Type unused, BinaryTokenStreamReader stream)
{
var target = stream.ReadString();
var message = MessageEnvelope.Serializer.Deserialize(stream);
return(new RequestEnvelope(target, message));
}
public void UniqueKeySerializationShouldReproduceAnIdenticalObject()
{
{
var expected = UniqueKey.NewKey(Guid.NewGuid());
BinaryTokenStreamWriter writer = new BinaryTokenStreamWriter();
writer.Write(expected);
BinaryTokenStreamReader reader = new BinaryTokenStreamReader(writer.ToBytes());
var actual = reader.ReadUniqueKey();
Assert.Equal(expected, actual); // UniqueKey.Serialize() and UniqueKey.Deserialize() failed to reproduce an identical object (case #1).
}
{
var kx = random.Next().ToString(CultureInfo.InvariantCulture);
var expected = UniqueKey.NewKey(Guid.NewGuid(), category: UniqueKey.Category.KeyExtGrain, keyExt: kx);
BinaryTokenStreamWriter writer = new BinaryTokenStreamWriter();
writer.Write(expected);
BinaryTokenStreamReader reader = new BinaryTokenStreamReader(writer.ToBytes());
var actual = reader.ReadUniqueKey();
Assert.Equal(expected, actual); // UniqueKey.Serialize() and UniqueKey.Deserialize() failed to reproduce an identical object (case #2).
}
{
var kx = random.Next().ToString(CultureInfo.InvariantCulture) + new String('*', 400);
var expected = UniqueKey.NewKey(Guid.NewGuid(), category: UniqueKey.Category.KeyExtGrain, keyExt: kx);
BinaryTokenStreamWriter writer = new BinaryTokenStreamWriter();
writer.Write(expected);
BinaryTokenStreamReader reader = new BinaryTokenStreamReader(writer.ToBytes());
var actual = reader.ReadUniqueKey();
Assert.Equal(expected, actual); // UniqueKey.Serialize() and UniqueKey.Deserialize() failed to reproduce an identical object (case #3).
}
}
object IMessageSerializer.Deserialize(BinaryTokenStreamReader stream)
{
var bytes = (byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream);
var json = Encoding.Default.GetString(bytes);
return(JsonConvert.DeserializeObject(json, settings));
}
public void ILSerializer_AllowCopiedFieldsToDifferFromSerializedFields()
{
var input = new FieldTest
{
One = 1,
Two = 2,
Three = 3
};
var generator = new ILSerializerGenerator();
var serializers = generator.GenerateSerializer(input.GetType(), f => f.Name != "One", f => f.Name != "Three");
var copy = (FieldTest)serializers.DeepCopy(input);
Assert.Equal(1, copy.One);
Assert.Equal(2, copy.Two);
Assert.Equal(0, copy.Three);
var writer = new BinaryTokenStreamWriter();
serializers.Serialize(input, writer, input.GetType());
var reader = new BinaryTokenStreamReader(writer.ToByteArray());
var deserialized = (FieldTest)serializers.Deserialize(input.GetType(), reader);
Assert.Equal(0, deserialized.One);
Assert.Equal(2, deserialized.Two);
Assert.Equal(3, deserialized.Three);
}
protected internal static object DeserializeGrainReference(Type t, BinaryTokenStreamReader stream)
{
GrainId id = stream.ReadGrainId();
SiloAddress silo = null;
GuidId observerId = null;
byte siloAddressPresent = stream.ReadByte();
if (siloAddressPresent != 0)
{
silo = stream.ReadSiloAddress();
}
bool expectObserverId = id.IsClient;
if (expectObserverId)
{
observerId = GuidId.DeserializeFromStream(stream);
}
// store as null, serialize as empty.
var genericArg = stream.ReadString();
if (String.IsNullOrEmpty(genericArg))
{
genericArg = null;
}
if (expectObserverId)
{
return(NewObserverGrainReference(id, observerId));
}
return(FromGrainId(id, genericArg, silo));
}
public void AzureQueueBatchContainerV2_Serialize_IfNotNull()
{
var container = CreateAzureQueueBatchContainer();
var writer = new SerializationContext
{
StreamWriter = new BinaryTokenStreamWriter()
};
AzureQueueBatchContainerV2.Serialize(container, writer, null);
var reader = new DeserializationContext
{
StreamReader = new BinaryTokenStreamReader(writer.StreamWriter.ToByteArray())
};
var deserialized = AzureQueueBatchContainerV2.Deserialize(typeof(AzureQueueBatchContainer), reader) as AzureQueueBatchContainerV2;
ValidateIdenticalQueueBatchContainerButNotSame(container, deserialized);
var streamWriter = new BinaryTokenStreamWriter();
SerializationManager.Serialize(container, streamWriter);
var streamReader = new BinaryTokenStreamReader(streamWriter.ToByteArray());
deserialized = SerializationManager.Deserialize <AzureQueueBatchContainerV2>(streamReader);
ValidateIdenticalQueueBatchContainerButNotSame(container, deserialized);
}
internal static object Deserialize(Type t, BinaryTokenStreamReader stream)
{
var target = (ActorPath)SerializationManager.DeserializeInner(typeof(ActorPath), stream);
var message = MessageEnvelope.Deserializer((byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream));
return(new RequestEnvelope(target, message));
}
/// <summary>
/// Deserializes an event sequence token
/// </summary>
/// <param name="expected">The expected type.</param>
/// <param name="reader">The binary stream to read from.</param>
/// <returns></returns>
public static object Deserialize(Type expected, BinaryTokenStreamReader reader)
{
var result = new EventSequenceTokenV2(reader.ReadLong(), reader.ReadInt());
DeserializationContext.Current.RecordObject(result);
return(result);
}
internal static object DeserializeGrainCancellationToken(Type expected, BinaryTokenStreamReader stream)
{
var cancellationRequested = stream.ReadToken() == SerializationTokenType.True;
var tokenId = stream.ReadGuid();
return(new GrainCancellationToken(tokenId, cancellationRequested));
}
internal static object Deserialize(Type t, BinaryTokenStreamReader stream)
{
var sender = (ActorPath)SerializationManager.DeserializeInner(typeof(ActorPath), stream);
var message = MessageEnvelope.Deserializer((byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream));
return(new NotificationEnvelope(sender, message));
}
public IBatchContainer GetBatchContainer(ref CachedMessage cachedMessage)
{
//Deserialize payload
var stream = new BinaryTokenStreamReader(cachedMessage.Payload);
MemoryEventData eventData = (MemoryEventData)SerializationManager.Deserialize(stream);
return(new MemoryBatchContainer(eventData, cachedMessage.SequenceNumber));
}
public IBatchContainer GetBatchContainer(ref CachedMessage cachedMessage)
{
//Deserialize payload
var stream = new BinaryTokenStreamReader(cachedMessage.Payload);
object payloadObject = SerializationManager.Deserialize(stream);
return new GeneratedBatchContainer(cachedMessage.StreamGuid, cachedMessage.StreamNamespace,
payloadObject, new EventSequenceToken(cachedMessage.SequenceNumber));
}
private static object Deserialize(Type expected, BinaryTokenStreamReader stream)
{
DeserializeCounter++;
var result = new ClassWithCustomSerializer();
result.IntProperty = stream.ReadInt();
result.StringProperty = stream.ReadString();
return(result);
}
public override object Deserialize(BinaryTokenStreamReader stream)
{
var bytes = (byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream);
using (var ms = new MemoryStream(bytes))
{
var formatter = new BinaryFormatter();
return(formatter.Deserialize(ms));
}
}
private GrainReference RoundTripGrainReferenceOrleansSerializer(GrainReference input)
{
BinaryTokenStreamWriter writer = new BinaryTokenStreamWriter();
GrainReference.SerializeGrainReference(input, writer, typeof(GrainReference));
BinaryTokenStreamReader reader = new BinaryTokenStreamReader(writer.ToBytes());
GrainReference output = (GrainReference)GrainReference.DeserializeGrainReference(typeof(GrainReference), reader);
return(output);
}
public IBatchContainer GetBatchContainer(ref CachedMessage cachedMessage)
{
//Deserialize payload
var stream = new BinaryTokenStreamReader(cachedMessage.Payload.ToArray());
//object payloadObject = SerializationManager.Deserialize(stream);
var payloadObject = SerializationManager.Deserialize <List <object> >(stream);
return(new PlainBatchContainer(cachedMessage.StreamGuid, cachedMessage.StreamNamespace,
payloadObject, new SimpleSequenceToken(cachedMessage.SequenceNumber)));
}
public object Deserialize(Type expectedType, BinaryTokenStreamReader reader)
{
var n = reader.ReadInt();
var bytes = reader.ReadBytes(n);
using (var stream = new MemoryStream(bytes))
{
var res = _serializer.Deserialize(stream);
return(res);
}
}
public IBatchContainer GetBatchContainer(ref CachedMessage cachedMessage)
{
//Deserialize payload
int readOffset = 0;
ArraySegment <byte> payload = SegmentBuilder.ReadNextBytes(cachedMessage.Segment, ref readOffset);
var stream = new BinaryTokenStreamReader(payload);
object payloadObject = this.serializationManager.Deserialize(stream);
return(new GeneratedBatchContainer(cachedMessage.StreamId,
payloadObject, new EventSequenceTokenV2(cachedMessage.SequenceNumber)));
}
private static object DeserializeBody(SerializationManager serializationManager, List <ArraySegment <byte> > bytes)
{
if (bytes == null)
{
return(null);
}
var stream = new BinaryTokenStreamReader(bytes);
return(serializationManager.Deserialize(stream));
}
//[Benchmark]
public int OrleansReadEachByte()
{
var sum = 0;
var reader = new BinaryTokenStreamReader(this.orleansBytes);
for (var i = 0; i < this.readBytesLength; i++)
{
sum ^= reader.ReadByte();
}
return(sum);
}
public static void VerifyUsingFallbackSerializer(object ob)
{
var writer = new BinaryTokenStreamWriter();
SerializationManager.FallbackSerializer(ob, writer, ob.GetType());
var bytes = writer.ToByteArray();
var reader = new BinaryTokenStreamReader(bytes);
var serToken = reader.ReadToken();
Assert.Equal(SerializationTokenType.Fallback, serToken);
}
public Message(List <ArraySegment <byte> > header, List <ArraySegment <byte> > body)
{
metadata = new Dictionary <string, object>();
var input = new BinaryTokenStreamReader(header);
headers = SerializationManager.DeserializeMessageHeaders(input);
BufferPool.GlobalPool.Release(header);
bodyBytes = body;
bodyObject = null;
headerBytes = null;
}
/// <summary>
/// Deserializes the container from the data stream.
/// </summary>
/// <param name="expected">The expected type</param>
/// <param name="reader">The stream reader</param>
/// <returns>The deserialized value</returns>
public static object Deserialize(Type expected, BinaryTokenStreamReader reader)
{
var deserialized = new AzureQueueBatchContainerV2();
DeserializationContext.Current.RecordObject(deserialized);
var guid = reader.ReadGuid();
var ns = reader.ReadString();
var eventToken = SerializationManager.DeserializeInner <EventSequenceTokenV2>(reader);
var events = SerializationManager.DeserializeInner <List <object> >(reader);
var context = SerializationManager.DeserializeInner <Dictionary <string, object> >(reader);
deserialized.SetValues(guid, ns, events, context, eventToken);
return(deserialized);
}
public void EventHubSequenceTokenV2_Serialize_IfNotNull()
{
var writer = new BinaryTokenStreamWriter();
var token = new EventHubSequenceTokenV2("name", long.MaxValue, int.MaxValue);
EventHubSequenceTokenV2.Serialize(token, writer, null);
var reader = new BinaryTokenStreamReader(writer.ToByteArray());
var deserialized = EventHubSequenceTokenV2.Deserialize(typeof(EventHubSequenceTokenV2), reader) as EventHubSequenceTokenV2;
Assert.NotNull(deserialized);
Assert.NotSame(token, deserialized);
Assert.Equal(token.EventIndex, deserialized.EventIndex);
Assert.Equal(token.SequenceNumber, deserialized.SequenceNumber);
}
// Initializes body and header but does not take ownership of byte.
// Caller must clean up bytes
public Message(List <ArraySegment <byte> > header, List <ArraySegment <byte> > body, bool deserializeBody = false)
{
var input = new BinaryTokenStreamReader(header);
Headers = SerializationManager.DeserializeMessageHeaders(input);
if (deserializeBody)
{
bodyObject = DeserializeBody(body);
}
else
{
bodyBytes = body;
}
}
public void Serialize_CustomSerializer()
{
var original = new ClassWithCustomSerializer()
{
IntProperty = -3, StringProperty = "Goodbye"
};
var writeStream = new BinaryTokenStreamWriter();
this.fixture.SerializationManager.Serialize(original, writeStream);
Assert.Equal(1, ClassWithCustomSerializer.SerializeCounter); //Custom serializer was not called
var readStream = new BinaryTokenStreamReader(writeStream.ToBytes());
var obj = this.fixture.SerializationManager.Deserialize(readStream);
Assert.Equal(1, ClassWithCustomSerializer.DeserializeCounter); //Custom deserializer was not called
}
internal static object Reserialize(IMessageSerializer serializer, object message)
{
if (serializer == null)
{
return(message);
}
var writer = new BinaryTokenStreamWriter();
serializer.Serialize(message, writer);
var bytes = writer.ToByteArray();
var reader = new BinaryTokenStreamReader(bytes);
return(serializer.Deserialize(reader));
}
public OrleansTransactionAbortedException MustAbort(SerializationManager sm)
{
if (OriginalException != null)
{
var reader = new BinaryTokenStreamReader(OriginalException);
return(sm.Deserialize <OrleansTransactionAbortedException>(reader));
}
else if (PendingCalls != 0)
{
return(new OrleansOrphanCallException(TransactionId.ToString(), PendingCalls));
}
else
{
return(null);
}
}
