public override void Invoke(AMFContext context) { AMFSerializer serializer = new AMFSerializer(context.OutputStream); serializer.UseLegacyCollection = _useLegacyCollection; serializer.UseLegacyThrowable = _useLegacyThrowable; serializer.WriteMessage(context.MessageOutput); serializer.Flush(); //Serialization/deserialization debugging //Note: this will not work correctly with optimizers (different ClassDefinitions from server and client) /* MemoryStream ms = new MemoryStream(); AMFSerializer testSerializer = new AMFSerializer(ms); testSerializer.UseLegacyCollection = _useLegacyCollection; testSerializer.UseLegacyThrowable = _useLegacyThrowable; testSerializer.WriteMessage(context.MessageOutput); testSerializer.Flush(); ms.Position = 0; AMFDeserializer testDeserializer = new AMFDeserializer(ms); testDeserializer.UseLegacyCollection = _useLegacyCollection; AMFMessage amfMessageOut = testDeserializer.ReadAMFMessage(); ms.Position = 0; byte[] buffer = ms.ToArray(); context.OutputStream.Write(buffer, 0, buffer.Length); */ }
public byte[] LoadAmfMessageIntoBinMessage(AMFMessage message) { byte[] buffer = null; MemoryStream stream = new MemoryStream(); AMFSerializer amfSerializers = new AMFSerializer(stream); amfSerializers.WriteMessage(message); amfSerializers.Flush(); buffer = new byte[amfSerializers.BaseStream.Length]; stream.Position = 0; stream.Read(buffer, 0, buffer.Length); return buffer; }
//One of the two main entry points into the encoder. Called by WCF to encode a Message into a buffered byte array. public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { MemoryStream memoryStream = new MemoryStream(); AMFMessage amfMessage = message.Properties["amf"] as AMFMessage; AMFSerializer serializer = new AMFSerializer(memoryStream); serializer.WriteMessage(amfMessage); serializer.Flush(); byte[] buffer = memoryStream.ToArray(); ArraySegment<byte> byteArray = new ArraySegment<byte>(buffer); return byteArray; }
/// <summary> /// One of the two main entry points into the encoder. Called by WCF to write a message of less than a specified size to a byte array buffer at the specified offset. /// </summary> /// <param name="message">The <see cref="T:System.ServiceModel.Channels.Message"/> to write to the message buffer.</param> /// <param name="maxMessageSize">The maximum message size that can be written.</param> /// <param name="bufferManager">The <see cref="T:System.ServiceModel.Channels.BufferManager"/> that manages the buffer to which the message is written.</param> /// <param name="messageOffset">The offset of the segment that begins from the start of the byte array that provides the buffer.</param> /// <returns> /// A <see cref="T:System.ArraySegment`1"/> of type byte that provides the buffer to which the message is serialized. /// </returns> public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { MemoryStream memoryStream = new MemoryStream(); AMFMessage amfMessage = message.Properties["amf"] as AMFMessage; AMFSerializer serializer = new AMFSerializer(memoryStream); serializer.WriteMessage(amfMessage); serializer.Flush(); // To avoid a buffer copy, we grab a reference to the stream's internal buffer. // The byte[] we receive may contain extra nulls after the actual data, due to the // buffer management mechanisms of the MemoryStream. Thus, to obtain the message's // length, we need to examine memoryStream.Position rather than messageBytes.Length. byte[] messageBytes = memoryStream.GetBuffer(); int messageLength = (int)memoryStream.Position; memoryStream.Close(); int totalLength = messageLength + messageOffset; byte[] finalBuffer = bufferManager.TakeBuffer(totalLength); Array.Copy(messageBytes, 0, finalBuffer, messageOffset, messageLength); ArraySegment<byte> byteArray = new ArraySegment<byte>(finalBuffer, messageOffset, messageLength); return byteArray; }