object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer) { var array = reader.Read(context.Length, context.IsReverse); var encoding = (context == null || string.IsNullOrWhiteSpace(context.Options)) ? Encoding.UTF8 : Encoding.GetEncoding(context.Options); return(encoding.GetString(array).TrimEnd('\0')); }
public override SerializeMetadata GetMetadataFrom(object value) { var cnx = new SerializeMetadata(); var isDeserialize = value is Type; if (isDeserialize) { cnx.ObjectType = (Type)value; } else { cnx.ObjectType = (value != null ? value.GetType() : null); } if (cnx.ObjectType != null && base.IsRecursive(cnx.ObjectType)) { if (!MetadataCache.ContainsKey(cnx.ObjectType)) { cnx = GetSerializeMetadata(cnx.ObjectType); MetadataCache.TryAdd(cnx.ObjectType, cnx); } else { cnx = MetadataCache[cnx.ObjectType]; } } return(cnx); }
void IBinaryConverter.WriteBinary(IBinaryWriter writer, object value, SerializeMetadata context, IHolySerializer serializer) { var guid = (Guid)value; guid.ToByteArray(); writer.Write(guid.ToByteArray(), context.IsReverse); }
void Cover(SerializeMetadata one, SerializeMetadata newOne) { one.Index = newOne.Index; one.IsReverse = newOne.IsReverse; one.Converter = newOne.Converter; one.Options = newOne.Options; one.Childs = newOne.Childs; if (one.Length == 0) { one.Length = newOne.Length; } }
void IBinaryConverter.WriteBinary(IBinaryWriter writer, object value, SerializeMetadata context, IHolySerializer serializer) { var encoding = (context == null || string.IsNullOrWhiteSpace(context.Options)) ? Encoding.UTF8 : Encoding.GetEncoding(context.Options); var array = value == null?Array.Empty <byte>() : encoding.GetBytes(value.ToString()); if (context.Length > 0 && array.Length != context.Length) { var fillArray = new byte[context.Length]; Array.Copy(array, fillArray, array.Length > fillArray.Length ? fillArray.Length : array.Length); array = fillArray; } writer.Write(array, context.IsReverse); }
private IBinaryConverter CreateConverter(SerializeMetadata context) { IBinaryConverter converter = null; if (!ConverterCache.ContainsKey(context.Converter)) { converter = Activator.CreateInstance(context.Converter) as IBinaryConverter; ConverterCache.TryAdd(context.Converter, converter); } else { converter = ConverterCache[context.Converter]; } return(converter); }
SerializeMetadata ConvertFrom(Type type, BinaryMemberAttribute contract) { var parent = new SerializeMetadata(); parent.ObjectType = type; parent.Converter = contract.Converter; parent.Options = contract.Options; parent.Index = contract.Index; parent.IsReverse = contract.IsReverse; if (contract.Length > 0) { parent.Length = contract.Length; } else { parent.Length = base.SizeOf(parent.ObjectType); } return(parent); }
void IBinaryConverter.WriteBinary(IBinaryWriter writer, object value, SerializeMetadata context, IHolySerializer serializer) { var buffer = new List <byte>(); context.Childs.ForEach(b => { var val = HelperExtension.GetValue(b.Name, value); var childWriter = serializer.WriterCreator.Create(); foreach (var c in serializer.Converters) { if (c.CanConvert(b)) { c.WriteBinary(childWriter, val, b, serializer); break; } } ; buffer.AddRange(childWriter.ToArray()); }); writer.Write(buffer.ToArray(), context.IsReverse); }
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer) { var array = reader.Read(context.Length == 0 ? reader.ReadRemainderLength() : context.Length, context.IsReverse); var value = Activator.CreateInstance(context.ObjectType); var childReader = serializer.ReaderCreator.Create(array); context.Childs.ForEach(b => { foreach (var c in serializer.Converters) { if (c.CanConvert(b)) { var val = c.ReadBinary(childReader, b, serializer); HelperExtension.SetValue(b.Name, value, new object[] { val }); break; } } ; }); return(value); }
SerializeMetadata GetSerializeMetadata(Type type) { SerializeMetadata parent = GetOneSerializeMetadata(type); if (parent == null) { return(null); } var pros = base.GetAvailableProperty(type); pros.ForEach(p => { SerializeMetadata child = GetOneSerializeMetadata(p); if (child == null) { return; } if (IsRecursive(child.ObjectType)) { var newchild = GetSerializeMetadata(p.PropertyType); if (child != null && newchild != null) { Cover(child, newchild); } } child.Name = p.Name; if (parent.Childs == null) { parent.Childs = new List <SerializeMetadata>(); } parent.Childs.Add(child); }); parent.Childs = this.Sort(parent.Childs); //if (parent.Length == 0 && parent.Childs?.Count > 0 && !parent.Childs.Any(c => c.Length == 0)) { parent.Length = parent.Childs.Sum(c => c.Length); } return(parent); }
SerializeMetadata GetOneSerializeMetadata(object p) { BinaryMemberAttribute attr = null; Type type = null; if (p is Type) { type = (Type)p; attr = type.GetCustomAttribute <BinaryMemberAttribute>(true); } else if (p is PropertyInfo) { attr = ((PropertyInfo)p).GetCustomAttribute <BinaryMemberAttribute>(); type = ((PropertyInfo)p).PropertyType; } SerializeMetadata metadata = null; if (attr == null) { if (this.Strict) { return(metadata); } else { metadata = new SerializeMetadata { ObjectType = type }; } } else { metadata = ConvertFrom(type, attr); } return(metadata); }
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer) { var array = reader.Read(context.Length, context.IsReverse); return(array); }
bool IBinaryConverter.CanConvert(SerializeMetadata context) { return(context.ObjectType == typeof(string)); }
bool IBinaryConverter.CanConvert(SerializeMetadata context) { return(context.ObjectType != null && context.ObjectType.IsInherit(typeof(IEnumerable <byte>))); }
void IBinaryConverter.WriteBinary(IBinaryWriter writer, object value, SerializeMetadata context, IHolySerializer serializer) { CreateConverter(context).WriteBinary(writer, value, context, serializer); }
void IBinaryConverter.WriteBinary(IBinaryWriter writer, object value, SerializeMetadata context, IHolySerializer serializer) { byte[] array = null; var typeCode = value == null ? TypeCode.Empty : Type.GetTypeCode(value.GetType()); switch (typeCode) { case TypeCode.Boolean: array = BitConverter.GetBytes((bool)value); break; case TypeCode.Byte: array = new byte[] { (byte)value }; break; case TypeCode.Char: array = BitConverter.GetBytes((char)value); break; case TypeCode.DBNull: break; case TypeCode.DateTime: array = BitConverter.GetBytes(((DateTime)value).Ticks); break; case TypeCode.Decimal: { var bits = decimal.GetBits((decimal)value); var bytes = new List <byte>(); foreach (Int32 i in bits) { bytes.AddRange(BitConverter.GetBytes(i)); } array = bytes.ToArray(); } break; case TypeCode.Double: array = BitConverter.GetBytes((double)value); break; case TypeCode.Empty: break; case TypeCode.Int16: array = BitConverter.GetBytes((short)value); break; case TypeCode.Int32: array = BitConverter.GetBytes((int)value); break; case TypeCode.Int64: array = BitConverter.GetBytes((long)value); break; case TypeCode.SByte: array = new byte[] { (byte)value }; break; case TypeCode.Single: array = BitConverter.GetBytes((float)value); break; case TypeCode.UInt16: array = BitConverter.GetBytes((ushort)value); break; case TypeCode.UInt32: array = BitConverter.GetBytes((uint)value); break; case TypeCode.UInt64: array = BitConverter.GetBytes((ulong)value); break; default: break; } writer.Write(array, context.IsReverse); }
void IBinaryConverter.WriteBinary(IBinaryWriter writer, object value, SerializeMetadata context, IHolySerializer serializer) { writer.Write((value as IEnumerable <byte>).ToArray(), context.IsReverse); }
bool IBinaryConverter.CanConvert(SerializeMetadata context) { return(Type.GetTypeCode(context.ObjectType) == TypeCode.Object); }
bool IBinaryConverter.CanConvert(SerializeMetadata context) { return(context.Converter != null); }
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer) { return(CreateConverter(context).ReadBinary(reader, context, serializer)); }
bool IBinaryConverter.CanConvert(SerializeMetadata context) { return(true); }
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer) { var array = reader.Read(context.Length, context.IsReverse); object value = null; switch (Type.GetTypeCode(context.ObjectType)) { case TypeCode.Boolean: value = BitConverter.ToBoolean(array, 0); break; case TypeCode.Byte: value = array[0]; break; case TypeCode.Char: value = BitConverter.ToChar(array, 0); break; case TypeCode.DBNull: break; case TypeCode.DateTime: value = new DateTime(BitConverter.ToInt64(array, 0)); break; case TypeCode.Decimal: { if (array.Count() != 16) { throw new Exception("A decimal must be created from exactly 16 bytes"); } var bits = new Int32[4]; for (int i = 0; i <= 15; i += 4) { bits[i / 4] = BitConverter.ToInt32(array, i); } value = new decimal(bits); } break; case TypeCode.Double: value = BitConverter.ToDouble(array, 0); break; case TypeCode.Empty: break; case TypeCode.Int16: value = BitConverter.ToInt16(array, 0); break; case TypeCode.Int32: value = BitConverter.ToInt32(array, 0); break; case TypeCode.Int64: value = BitConverter.ToInt64(array, 0); break; case TypeCode.SByte: value = (sbyte)array[0]; break; case TypeCode.Single: value = BitConverter.ToSingle(array, 0); break; case TypeCode.UInt16: value = BitConverter.ToUInt16(array, 0); break; case TypeCode.UInt32: value = BitConverter.ToUInt32(array, 0); break; case TypeCode.UInt64: value = BitConverter.ToUInt64(array, 0); break; default: break; } return(value); }