private bool Serialize <T>(T msg, IActorMessage toSerialize, ushort version, byte[] messageBytes, byte[] resultBytes) where T : IActorMessage
        {
            // <verstion-short> (always Zero for this type of serializedMessage)
            // 16byte.message.guid
            // <size.of.type.in.Bytes-ushort>
            // <bytes.of.type.string-bytearray>
            // <size.of.message-uint>
            // <bytes.of.message-bytearray>
            // <size.of.result-uint>
            // <bytes.of.result-bytearray>
            // <status.flags-uint>

            uint serializedByteCount = IActorMessageSerializationActor.MinSizeOfSerializedMessage;

            var messageID = Guid.NewGuid().ToByteArray();

            byte[]       typeBytes  = null;
            uint         sizeOfType = 0;
            IFormatter   formatter  = new MessageTypeFormatter();
            MemoryStream typeMs     = new MemoryStream();

            formatter.Serialize(typeMs, toSerialize.GetType().AssemblyQualifiedName.ToString());
            typeBytes = typeMs.GetBuffer();
            typeMs    = null;
            // typeBytes = Encoding.UTF8.GetBytes(toSerialize.GetType().AssemblyQualifiedName);
            sizeOfType = (uint)typeBytes.Length;

            uint statusFlags = 0; //TODO:

            byte[] serializedMsg = CreateSerializationPackage(version, typeBytes, messageID, messageBytes, resultBytes, statusFlags);

            if (null != msg.Status)
            {
                if (!(msg.GetType() == typeof(SerializeMessage <IActorMessage>)))
                {
                    msg.Status.SetResult(new SerializeMessage <IActorMessage>(toSerialize, serializedMsg));
                }
                else
                {
                    msg.ProcessingResult = serializedMsg;
                    msg.Status.SetResult(msg);
                }
            }
            else
            {
                msg.ProcessingResult = serializedMsg;
            }

            return(true);
        }