internal FieldLoadInfo(FieldInfo field, SerializeAttribute attr, string yamlName, Func <MiniYaml, object> loader = null) { Field = field; Attribute = attr; YamlName = yamlName; Loader = loader; }
/// <summary> /// Deserializes the given object. /// </summary> /// <param name="stream">Stream containing data.</param> /// <param name="type">The type of the object to create.</param> /// <returns>The deserialized object.</returns> public object Deserialize(Type type, SerializeStream stream) { FieldInfo[] infos = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); object obj = Activator.CreateInstance(type, true); for (int i = 0; i < infos.Length; i++) { FieldInfo info = infos[i]; if (info.IsDefined(typeof(SerializeAttribute), false)) { SerializeAttribute attribute = (SerializeAttribute) info.GetCustomAttributes(typeof(SerializeAttribute), false)[0]; if (attribute.Primitive) { info.SetValue(obj, stream.Read(info.Name, info.FieldType)); } else { info.SetValue(obj, stream.ReadObject(info.Name)); } } } PropertyInfo[] pInfos = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); for (int i = 0; i < pInfos.Length; i++) { PropertyInfo pInfo = pInfos[i]; if (pInfo.IsDefined(typeof(SerializeAttribute), false)) { SerializeAttribute attribute = (SerializeAttribute) pInfo.GetCustomAttributes(typeof(SerializeAttribute), false)[0]; if (pInfo.CanWrite) { if (attribute.Primitive) { pInfo.SetValue(obj, stream.Read(pInfo.Name, pInfo.PropertyType), null); } else { pInfo.SetValue(obj, stream.ReadObject(pInfo.Name), null); } } } } return(obj); }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region ISerializer Members //--------------------------------------------------------------- /// <summary> /// Serializes the given object. /// </summary> /// <param name="obj">The object to serialize.</param> /// <param name="stream">Stream to fill with data.</param> public void Serialize(object obj, SerializeStream stream) { Type type = obj.GetType(); MemberInfo[] infos = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); for (int i = 0; i < infos.Length; i++) { if (infos[i].IsDefined(typeof(SerializeAttribute), false)) { SerializeAttribute attribute = (SerializeAttribute) infos[i].GetCustomAttributes(typeof(SerializeAttribute), false)[0]; FieldInfo info = infos[i] as FieldInfo; PropertyInfo pInfo = infos[i] as PropertyInfo; if (info != null) { if (attribute.Primitive) { stream.Write(info.Name, info.GetValue(obj)); } else { stream.WriteAsObject(info.Name, info.GetValue(obj)); } } else if (pInfo != null && pInfo.CanRead && pInfo.CanWrite) { if (attribute.Primitive) { stream.Write(pInfo.Name, pInfo.GetValue(obj, null)); } else { stream.WriteAsObject(pInfo.Name, pInfo.GetValue(obj, null)); } } else { throw new Exception("Can't get AND set member: " + pInfo.Name); } } } }
public FieldSerializeHelper(FieldInfo info, EntryFieldAttribute fieldInfo, SerializeAttribute serializer) { this.defaultValue = fieldInfo.DefaultValue; this.GetValue = info.GetValue; this.SetValue = info.SetValue; if (serializer != null) { this.Serialize = serializeCustom(this, serializer.Serialize); this.Deserialize = deserializeCustom(this, serializer.Deserialize); this.DeserializeExact = deserializeCustomExact(this, serializer.Deserialize); return; } this.Serialize = serializeDefault(this, fieldInfo.Format); if (info.FieldType.GetTypeInfo().IsEnum) { this.Deserialize = deserializeEnum(this, info.FieldType); this.DeserializeExact = deserializeEnumExact(this, info.FieldType); } else { this.Deserialize = deserializeDefault(this, info.FieldType); this.DeserializeExact = deserializeDefaultExact(this, info.FieldType); } }
public bool Decode(byte[] data) { BinaryReader reader = new BinaryReader(new MemoryStream(data)); reader.ReadInt16(); // skip packet id this.NetworkId = reader.ReadInt32(); ushort bitmask = (ushort) ((this.GetType().GetCustomAttribute(typeof(PacketAttribute)) as PacketAttribute).BitmaskType == typeof(Byte) ? reader.ReadByte() : reader.ReadUInt16()); foreach (var p in this.GetType().GetProperties()) { SerializeAttribute serializeAttr = p.GetCustomAttribute(typeof(SerializeAttribute)) as SerializeAttribute; if (serializeAttr == null) { continue; } object buffer = null; if (p.PropertyType == typeof(Int32) || p.PropertyType == typeof(Int16) || p.PropertyType == typeof(Byte)) { if (serializeAttr.Dict.Length == 8) { var entry = (int)serializeAttr.Dict[bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits)]; if (entry < -1 || entry > 7) { Serializer.Decode(out buffer, p.PropertyType, reader, Operations.GetOperations((uint)entry), serializeAttr.ReverseByteOrder); } else { buffer = entry; } } else if (serializeAttr.Dict.Length == 1) { if (bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 0) { Serializer.Decode(out buffer, p.PropertyType, reader, Operations.GetOperations((uint)serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder); } else { buffer = 0; } } } else if (p.PropertyType == typeof(Vector3)) { if (bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 0) { Serializer.Decode(out buffer, p.PropertyType, reader, Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder); } } else if (p.PropertyType == typeof(Vector2)) { if (bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 0) { Serializer.Decode(out buffer, p.PropertyType, reader, Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder); } } else if (p.PropertyType == typeof(Boolean)) { buffer = bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 1 ? true : false; } p.SetValue(this, Convert.ChangeType(buffer, p.PropertyType)); } return(true); }
public byte[] Encode() { PacketAttribute packetAttr = this.GetType().GetCustomAttribute(typeof(PacketAttribute)) as PacketAttribute; var ms = new MemoryStream(); var writer = new BinaryWriter(ms); ushort bitmask = 0; foreach (var p in this.GetType().GetProperties()) { SerializeAttribute serializeAttr = p.GetCustomAttribute(typeof(SerializeAttribute)) as SerializeAttribute; if (serializeAttr == null) { continue; } if (p.PropertyType == typeof(Int32) || p.PropertyType == typeof(Int16) || p.PropertyType == typeof(Byte)) { var _data = (Int32)(dynamic)p.GetValue(this); if (serializeAttr.Dict.Length == 8) { switch (_data) { case -1: case 0: case 1: case 2: bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, (ushort)serializeAttr.Dict.ToList().IndexOf((uint)_data)); break; default: var cryptOperationHashes = serializeAttr.Dict.Where(x => x > 7 && x != unchecked ((uint)-1)).ToList(); var cryptOperation = cryptOperationHashes[random.Next() % cryptOperationHashes.Count]; bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, (ushort)serializeAttr.Dict.ToList().IndexOf(cryptOperation)); Serializer.Encode(p.GetValue(this), p.PropertyType, writer, Operations.GetOperations(cryptOperation), serializeAttr.ReverseByteOrder); break; } } else if (serializeAttr.Dict.Length == 1) { if (_data == 0) { bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 1); } else { bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 0); Serializer.Encode(p.GetValue(this), p.PropertyType, writer, Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder); } } } else if (p.PropertyType == typeof(Vector3)) { var _data = (Vector3)p.GetValue(this); if (_data.X != 0.0f || _data.Y != 0.0f || _data.Z != 0.0f) { bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 0); Serializer.Encode(_data, p.PropertyType, writer, Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder); } else { bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 1); } } else if (p.PropertyType == typeof(Vector2)) { var _data = (Vector2)p.GetValue(this); if (_data.X != 0.0f || _data.Y != 0.0f) { bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 0); Serializer.Encode(_data, p.PropertyType, writer, Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder); } else { bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 1); } } else if (p.PropertyType == typeof(Boolean)) { bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, (ushort)((bool)p.GetValue(this) == true ? 1 : 0)); } } var packet = new byte[ms.Length + 8]; BitConverter.GetBytes(packetAttr.Id).CopyTo(packet, 0); BitConverter.GetBytes(NetworkId).CopyTo(packet, 2); BitConverter.GetBytes(packetAttr.BitmaskType == typeof(Byte) ? (byte)bitmask : bitmask).CopyTo(packet, 6); Array.Copy(ms.GetBuffer(), 0, packet, packetAttr.BitmaskType == typeof(Byte) ? 7 : 8, ms.Length); return(packet); }
internal FieldLoadInfo(FieldInfo field, SerializeAttribute attr, string yamlName, Func<MiniYaml, object> loader = null) { Field = field; Attribute = attr; YamlName = yamlName; Loader = loader; }
public ScriptInfoSerializeHelper(FieldInfo info, ScriptInfoAttribute fieldInfo, SerializeAttribute serializer) { this.GetValue = info.GetValue; this.SetValue = info.SetValue; this.defaultValue = fieldInfo.DefaultValue; if (serializer != null) { //custom this.Deserialize = deserializeCustom(this, serializer.Deserialize); this.DeserializeExact = deserializeCustomExact(this, serializer.Deserialize); if (fieldInfo.IsOptional) { this.Serialize = serializeOptional(this, serializer.Serialize); } else { this.Serialize = serialize(this, serializer.Serialize); } this.format = fieldInfo.FieldName + ": {0}"; return; } //enum, nullable and others if (fieldInfo.IsOptional) { this.Serialize = serializeOptional(this); } else { this.Serialize = serialize(this); } var fieldType = info.FieldType; this.format = fieldInfo.FieldName + ": {0:" + fieldInfo.Format + "}"; Type nullableInner; if ((nullableInner = Nullable.GetUnderlyingType(fieldType)) != null) { //nullable if (this.defaultValue?.GetType() == nullableInner) { this.defaultValue = Activator.CreateInstance(fieldType, new[] { this.defaultValue }); } this.Deserialize = deserializeNullable(this, fieldType, nullableInner); this.DeserializeExact = deserializeNullableExact(this, fieldType, nullableInner); return; } if (fieldType.GetTypeInfo().IsEnum) { //enum this.Deserialize = deserializeEnum(this, fieldType); this.DeserializeExact = deserializeEnumExact(this, fieldType); return; } //default this.Deserialize = deserializeDefault(this, fieldType); this.DeserializeExact = deserializeDefaultExact(this, fieldType); }