/// <summary>
/// Serialize the array to the message
/// </summary>
/// <param name="message"></param>
public void OnSerialize(NetMessage message)
{
if (Items == null || Items.Length == 0)
{
message.Write(0);
return;
}
message.Write(Items.Length);
foreach (var item in Items)
{
if (!IsValueType)
{
if (PreserveIndex)
{
message.Write(item != null);
}
if (item != null)
{
item.OnSerialize(message);
}
}
else
{
item.OnSerialize(message);
}
}
}
/// <summary>
/// serialize the object, via inetserializable, defined serializer, or built-in serializer (in that order)
/// </summary>
/// <exception cref="NotImplementedException">When serialization does not resolve</exception>
/// <param name="o"></param>
/// <param name="msg"></param>
public void Serialize(object o, NetMessage msg)
{
var iser = o as INetSerializable;
if (iser != null)
{
iser.OnSerialize(msg);
return;
}
var aType = o.GetType();
Serializer ser;
if (_serializers.TryGetValue(aType, out ser))
{
ser.Serialize(o, msg);
return;
}
if (_internalSerializers.TryGetValue(aType, out ser))
{
ser.Serialize(o, msg);
return;
}
if (aType.IsEnum)
{
var etype = Enum.GetUnderlyingType(aType);
if (_internalSerializers.TryGetValue(etype, out ser))
{
ser.Serialize(Convert.ChangeType(o, etype), msg);
return;
}
}
var list = o as IEnumerable <INetSerializable>;
if (list != null)
{
msg.Write(list.Count());
foreach (var item in list)
{
item.OnSerialize(msg);
}
return;
}
var arr = o as Array;
if (arr != null)
{
var etype = aType.GetElementType();
if (TypeIsINet(etype))
{
SerializeINetArray(arr, msg);
return;
}
}
throw new NotImplementedException("No serializer defined for " + aType);
}
private static void SerializeINetArray(Array array, NetMessage msg)
{
var count = array.Length;
msg.Write(count);
foreach (var aro in array)
{
if (aro is INetSerializable iser)
{
iser.OnSerialize(msg);
}
}
}
public void OnSerialize(NetMessage message)
{
message.Write(_id);
}
public void OnSerialize(NetMessage message)
{
message.Write(Value.X);
message.Write(Value.Y);
message.Write(Value.Z);
}
public void OnSerialize(NetMessage message)
{
message.Write(Value);
}
/// <summary>
/// read ushort length prefixed messages from the buffer.
/// </summary>
/// <param name="buffer"></param>
/// <param name="readBytes"></param>
/// <param name="bytesReceived"></param>
/// <param name="nextMessage"></param>
/// <param name="lengthBuffer"></param>
/// <param name="bufferSize"></param>
/// <param name="msgAction"></param>
/// <returns>number of messages read from the buffer</returns>
public static int GetMessages(byte[] buffer, int readBytes,
ref int bytesReceived, ref NetMessage nextMessage, ref byte[] lengthBuffer, ref int bufferSize,
Action <NetMessage> msgAction)
{
var i = 0;
var messagesRead = 0;
while (i < readBytes)
{
// Determine how many bytes we want to transfer to the buffer and transfer them
var bytesAvailable = readBytes - i;
if (nextMessage != null)
{
// We're reading into the data buffer
var bytesRequested = readBytes - bytesReceived;
// Copy the incoming bytes into the buffer
var bytesTransferred = Math.Min(bytesRequested, bytesAvailable);
nextMessage.Write(buffer, i, bytesTransferred);
i += bytesTransferred;
bytesReceived += bytesTransferred;
if (bytesReceived < bufferSize)
{
// We haven't gotten all the data buffer yet: just wait for more data to arrive
}
else
{
// We've gotten an entire packet
msgAction(nextMessage);
messagesRead++;
// Start reading the length buffer again
nextMessage = null;
bytesReceived = 0;
bufferSize = 0;
}
}
else
{
// We're reading into the length prefix buffer
var bytesRequested = lengthBuffer.Length - bytesReceived;
// Copy the incoming bytes into the buffer
var bytesTransferred = Math.Min(bytesRequested, bytesAvailable);
Array.Copy(buffer, i, lengthBuffer, bytesReceived, bytesTransferred);
i += bytesTransferred;
bytesReceived += bytesTransferred;
if (bytesReceived != sizeof(ushort))
{
// We haven't gotten all the length buffer yet: just wait for more data to arrive
}
else
{
// We've gotten the length buffer
var length = BitConverter.ToUInt16(lengthBuffer, 0);
// Another sanity check is needed here for very large packets, to prevent denial-of-service attacks
if (length > MaxMessageSize)
{
throw new ProtocolViolationException("Message length " +
length.ToString(
System.Globalization.CultureInfo.InvariantCulture) +
" is larger than maximum message size " +
MaxMessageSize.ToString(
System.Globalization.CultureInfo.InvariantCulture));
}
// Zero-length packets are allowed as keepalives
if (length == 0)
{
bytesReceived = 0;
}
else
{
// Create the data buffer and start reading into it
nextMessage = GetMessage(length);
bufferSize = length;
bytesReceived = 0;
}
}
}
}
return(messagesRead);
}
/// <summary>
/// serialize to the stream
/// </summary>
/// <param name="message"></param>
public override void OnSerialize(NetMessage message)
{
message.Write(Value.Length);
message.Write(Value);
}