/// <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); }