public void Serialize(object item, BinaryTokenStreamWriter writer, Type expectedType) { if (writer == null) { throw new ArgumentNullException("writer"); } if (item == null) { writer.WriteNull(); return; } var formatter = new BinaryFormatter(); byte[] bytes; using (var memoryStream = new MemoryStream()) { formatter.Serialize(memoryStream, item); memoryStream.Flush(); bytes = memoryStream.ToArray(); } writer.Write(bytes.Length); writer.Write(bytes); }
private static void Serialize(object input, BinaryTokenStreamWriter stream, Type expected) { SerializeCounter++; var obj = input as ClassWithCustomSerializer; stream.Write(obj.IntProperty); stream.Write(obj.StringProperty); }
/// <summary> /// Serialize the event sequence token. /// </summary> /// <param name="untypedInput">The object to serialize.</param> /// <param name="writer">The writer to write the binary stream to.</param> /// <param name="expected">The expected type.</param> public static void Serialize(object untypedInput, BinaryTokenStreamWriter writer, Type expected) { var typed = untypedInput as EventSequenceTokenV2; if (typed == null) { writer.WriteNull(); return; } writer.Write(typed.SequenceNumber); writer.Write(typed.EventIndex); }
internal static void Serialize(object obj, BinaryTokenStreamWriter stream, Type unused) { var envelope = (ResponseEnvelope)obj; if (envelope.Result == null) { stream.Write(ResultToken.Null); return; } stream.Write(ResultToken.Some); MessageEnvelope.Serializer.Serialize(envelope.Result, stream); }
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.AreEqual(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.AreEqual(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.AreEqual(expected, actual, "UniqueKey.Serialize() and UniqueKey.Deserialize() failed to reproduce an identical object (case #3)."); } }
/// <summary> /// Serializes an object to a binary stream /// </summary> /// <param name="item">The object to serialize</param> /// <param name="writer">The <see cref="BinaryTokenStreamWriter"/></param> /// <param name="expectedType">The type the deserializer should expect</param> public void Serialize(object item, BinaryTokenStreamWriter writer, Type expectedType) { if (writer == null) { throw new ArgumentNullException("writer"); } if (item == null) { // Special handling for null value. // Since in this ProtobufSerializer we are usualy writing the data lengh as 4 bytes // we also have to write the Null object as 4 bytes lengh of zero. writer.Write(0); return; } IMessage iMessage = item as IMessage; if (iMessage == null) { throw new ArgumentException("The provided item for serialization in not an instance of " + typeof(IMessage), "item"); } // The way we write the data is potentially in-efficinet, // since we are first writing to ProtoBuff's internal CodedOutputStream // and then take its internal byte[] and write it into out own BinaryTokenStreamWriter. // Writing byte[] to BinaryTokenStreamWriter may sometimes copy the byte[] and sometimes just append ass ArraySegment without copy. // In the former case it will be a secodnd copy. // It would be more effecient to write directly into BinaryTokenStreamWriter // but protobuff does not currently support writing directly into a given arbitary stream // (it does support System.IO.Steam but BinaryTokenStreamWriter is not compatible with System.IO.Steam). // Alternatively, we could force to always append to BinaryTokenStreamWriter, but that could create a lot of small ArraySegments. // The plan is to ask the ProtoBuff team to add support for some "InputStream" interface, like Bond does. byte[] outBytes = iMessage.ToByteArray(); writer.Write(outBytes.Length); writer.Write(outBytes); }
private void WriteType(Type actualType, Type expectedType, BinaryTokenStreamWriter writer) { if (actualType == expectedType) { writer.Write((byte)SerializationTokenType.ExpectedType); } else { writer.Write((byte)SerializationTokenType.NamedType); writer.Write(actualType.AssemblyQualifiedName); } }
/// <summary> /// Serializes an object to a binary stream /// </summary> /// <param name="item">The object to serialize</param> /// <param name="writer">The <see cref="BinaryTokenStreamWriter"/></param> /// <param name="expectedType">The type the deserializer should expect</param> public void Serialize(object item, BinaryTokenStreamWriter writer, Type expectedType) { if (writer == null) { throw new ArgumentNullException("writer"); } if (item == null) { writer.WriteNull(); return; } var str = JsonConvert.SerializeObject(item, expectedType, settings); writer.Write(str); }
/// <summary> /// Serializes an object to a binary stream /// </summary> /// <param name="item">The object to serialize</param> /// <param name="writer">The <see cref="BinaryTokenStreamWriter"/></param> /// <param name="expectedType">The type the deserializer should expect</param> public void Serialize(object item, BinaryTokenStreamWriter writer, Type expectedType) { if (writer == null) { throw new ArgumentNullException("writer"); } if (item == null) { writer.WriteNull(); return; } var str = JsonConvert.SerializeObject(item, expectedType, defaultSettings); writer.Write(str); }
public static void Serializer(object untypedInput, BinaryTokenStreamWriter stream, Type expected) { byte[] buffer = Serialize(untypedInput); stream.Write(buffer.Length); stream.Write(buffer); }
public static void Serializer(System.Object untypedInput, BinaryTokenStreamWriter stream, System.Type expected) { HeadersContainer input = (HeadersContainer)untypedInput; var headers = input.GetHeadersMask(); stream.Write((int)headers); if ((headers & Headers.CACHE_INVALIDATION_HEADER) != Headers.NONE) { var count = input.CacheInvalidationHeader.Count; stream.Write(input.CacheInvalidationHeader.Count); for (int i = 0; i < count; i++) { WriteObj(stream, typeof(ActivationAddress), input.CacheInvalidationHeader[i]); } } if ((headers & Headers.CATEGORY) != Headers.NONE) { stream.Write((byte)input.Category); } if ((headers & Headers.DEBUG_CONTEXT) != Headers.NONE) stream.Write(input.DebugContext); if ((headers & Headers.DIRECTION) != Headers.NONE) stream.Write((byte)input.Direction.Value); if ((headers & Headers.EXPIRATION) != Headers.NONE) stream.Write(input.Expiration.Value); if ((headers & Headers.FORWARD_COUNT) != Headers.NONE) stream.Write(input.ForwardCount); if ((headers & Headers.GENERIC_GRAIN_TYPE) != Headers.NONE) stream.Write(input.GenericGrainType); if ((headers & Headers.CORRELATION_ID) != Headers.NONE) stream.Write(input.Id); if ((headers & Headers.ALWAYS_INTERLEAVE) != Headers.NONE) stream.Write(input.IsAlwaysInterleave); if ((headers & Headers.IS_NEW_PLACEMENT) != Headers.NONE) stream.Write(input.IsNewPlacement); if ((headers & Headers.READ_ONLY) != Headers.NONE) stream.Write(input.IsReadOnly); if ((headers & Headers.IS_UNORDERED) != Headers.NONE) stream.Write(input.IsUnordered); if ((headers & Headers.NEW_GRAIN_TYPE) != Headers.NONE) stream.Write(input.NewGrainType); if ((headers & Headers.REJECTION_INFO) != Headers.NONE) stream.Write(input.RejectionInfo); if ((headers & Headers.REJECTION_TYPE) != Headers.NONE) stream.Write((byte)input.RejectionType); if ((headers & Headers.REQUEST_CONTEXT) != Headers.NONE) { var requestData = input.RequestContextData; var count = requestData.Count; stream.Write(count); foreach (var d in requestData) { stream.Write(d.Key); SerializationManager.SerializeInner(d.Value, stream, typeof(object)); } } if ((headers & Headers.RESEND_COUNT) != Headers.NONE) stream.Write(input.ResendCount); if ((headers & Headers.RESULT) != Headers.NONE) stream.Write((byte)input.Result); if ((headers & Headers.SENDING_ACTIVATION) != Headers.NONE) { stream.Write(input.SendingActivation); } if ((headers & Headers.SENDING_GRAIN) != Headers.NONE) { stream.Write(input.SendingGrain); } if ((headers & Headers.SENDING_SILO) != Headers.NONE) { stream.Write(input.SendingSilo); } if ((headers & Headers.TARGET_ACTIVATION) != Headers.NONE) { stream.Write(input.TargetActivation); } if ((headers & Headers.TARGET_GRAIN) != Headers.NONE) { stream.Write(input.TargetGrain); } if ((headers & Headers.TARGET_OBSERVER) != Headers.NONE) { WriteObj(stream, typeof(GuidId), input.TargetObserverId); } if ((headers & Headers.TARGET_SILO) != Headers.NONE) { stream.Write(input.TargetSilo); } }
internal static void SerializeGrainCancellationToken(object obj, BinaryTokenStreamWriter stream, Type expected) { var ctw = (GrainCancellationToken)obj; var canceled = ctw.CancellationToken.IsCancellationRequested; stream.Write(canceled); stream.Write(ctw.Id); }
internal static void Serialize(object obj, BinaryTokenStreamWriter stream, Type unused) { var envelope = (RequestEnvelope) obj; stream.Write(envelope.Target); MessageEnvelope.Serializer.Serialize(envelope.Message, stream); }
public void Serialize(object item, BinaryTokenStreamWriter writer, Type expectedType) { var typed = (SimpleType)item; writer.Write(typed.Number); }
public static void WriteTypeKey(TypeKey key, BinaryTokenStreamWriter writer) { writer.Write(key.HashCode); writer.Write((ushort)key.TypeName.Length); writer.Write(key.TypeName); }