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