public SubscribeMessage Deserialize(IBinaryMessageData messageData)
{
using (var ms = new MemoryStream(messageData.Data))
{
ms.Position = 0;
var br = new BinaryReader(ms);
var topicCount = br.ReadInt32();
if (topicCount < 0)
{
throw new ProtocolException("Negative topic number", ProtocolErrorCode.InvalidTopicNumber);
}
if (topicCount > 100)
{
throw new ProtocolException("Too many topics", ProtocolErrorCode.TooManyTopics);
}
var topicList = new List <string>();
for (int i = 0; i < topicCount; i++)
{
var length = br.ReadInt32();
topicList.Add(Encoding.UTF8.GetString(br.ReadBytes(length)));
}
return(new SubscribeMessage(topicList));
}
}
public IMessage Deserialize(IBinaryMessageData messageData)
{
if (messageData.Type != MessageType.EndSession)
{
throw new ArgumentException("Message data has wrong type", nameof(messageData));
}
return(EndSessionMessage.Instance);
}
public IMessage Deserialize(IBinaryMessageData messageData)
{
var bf = new BinaryFormatter();
using (var ms = new MemoryStream(messageData.Data))
{
return((IMessage)bf.Deserialize(ms));
}
}
public IMessage Deserialize(IBinaryMessageData messageData)
{
if (messageData.Type != MessageType.HandshakeRequest)
{
throw new ArgumentException("Message data has wrong type", nameof(messageData));
}
var value = BitConverter.ToUInt16(messageData.Data, 0);
return(new HandshakeRequest(value));
}
public TMessage Deserialize(IBinaryMessageData messageData)
{
if (messageData.Type != MessageType.User)
{
throw new ArgumentException(nameof(messageData));
}
using (var ms = new MemoryStream(messageData.Data))
{
return(Serializer.Deserialize <TMessage>(ms));
}
}
public IMessage Deserialize(IBinaryMessageData messageData)
{
if (messageData.Type != MessageType.User)
{
throw new ArgumentException(nameof(messageData));
}
using (var ms = new MemoryStream(messageData.Data))
{
var result = Serializer.Deserialize(_type, ms);
return((IMessage)result);
}
}
private void WriteBinaryMessage(IBinaryMessageData binaryMessage)
{
try
{
lock (_writeLock)
{
_binaryMessageWriter.Value.Write(binaryMessage);
}
}
catch (IOException ex)
{
ThrowChannelClosedIfNeeded(ex);
CloseInternal();
throw;
}
}
public void Write(IBinaryMessageData message)
{
var type = (ushort)message.Type;
var length = message.Data.Length;
if (!BitConverter.IsLittleEndian)
{
Endianness.Swap(ref type);
Endianness.Swap(ref length);
}
_binaryWriter.Write(type);
_binaryWriter.Write(length);
_binaryWriter.Write(message.Data);
_binaryWriter.Flush();
}
public IMessage Deserialize(IBinaryMessageData messageData)
{
var code = BitConverter.ToUInt16(messageData.Data, 0);
if (!BitConverter.IsLittleEndian)
{
Endianness.Swap(ref code);
}
if (!_serializersByCode.ContainsKey(code))
{
throw new NotSupportedException($"Code {code} is not supported");
}
var buffer = new byte[messageData.Data.Length - sizeof(ushort)];
Buffer.BlockCopy(messageData.Data, sizeof(ushort), buffer, 0, messageData.Data.Length - sizeof(ushort));
var serializer = _serializersByCode[code];
return(serializer.Deserialize(new BinaryMessageData(buffer)));
}
IMessage IMessageSerializer.Deserialize(IBinaryMessageData messageData)
{
return(Deserialize(messageData));
}
TMessage IMessageSerializer <TMessage> .Deserialize(IBinaryMessageData messageData)
{
return((TMessage)((IMessageSerializer)this).Deserialize(messageData));
}
public StringMessage Deserialize(IBinaryMessageData messageData)
{
return(new StringMessage(_encoding.GetString(messageData.Data)));
}
