/// <summary>
/// Constructor
/// </summary>
/// <param name="typeArray">Type array</param>
/// <param name="serializer">Serializer</param>
/// <param name="maxLength">Max length</param>
public BinaryArraySerializer(Type typeArray, IBinaryCustomSerializable serializer, int maxLength = ushort.MaxValue)
{
_type = typeArray;
_itemType = typeArray.GetElementType();
_serializer = serializer;
MaxLength = maxLength;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="typeList">Type list</param>
/// <param name="serializer">Serializer</param>
/// <param name="maxLength">Max length</param>
public BinaryListSerializer(Type typeList, IBinaryCustomSerializable serializer, int maxLength = ushort.MaxValue)
{
_type = typeList;
_itemType = typeList.GetElementType();
_serializer = serializer;
MaxLength = maxLength;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="typeList">Type list</param>
/// <param name="serializer">Serializer</param>
/// <param name="maxLength">Max length</param>
public BinaryReadOnlyListSerializer(Type typeList, IBinaryCustomSerializable serializer, int maxLength = ushort.MaxValue)
{
_itemType = typeList.GetGenericArguments().FirstOrDefault();
_type = typeof(List <>).MakeGenericType(_itemType);
_serializer = serializer;
MaxLength = maxLength;
_readOnlyMethod = _type.GetMethod("AsReadOnly");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="typeSet">Type set</param>
/// <param name="serializer">Serializer</param>
/// <param name="maxLength">Max length</param>
public BinaryHashSetSerializer(Type typeSet, IBinaryCustomSerializable serializer, int maxLength = ushort.MaxValue)
{
_type = typeSet;
_itemType = typeSet.GetElementType();
if (_type.IsInterface)
{
// TODO #393: Compose a HashTag<T> type
}
MaxLength = maxLength;
_serializer = serializer;
_addMethod = typeSet.GetMethod("Add");
_countMethod = typeSet.GetProperty("Count");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="type">Type</param>
/// <param name="keyType">Key type</param>
/// <param name="key">Key</param>
/// <param name="valueType">Value type</param>
/// <param name="value">Value</param>
/// <param name="maxLength">Max length</param>
public BinaryDictionarySerializer(Type type, Type keyType, IBinaryCustomSerializable key, Type valueType, IBinaryCustomSerializable value, int maxLength = ushort.MaxValue)
{
_type = type;
if (_type.IsInterface)
{
// TODO #394: Compose a Dictionary<T> type
}
_keyType = keyType;
_valueType = valueType;
_key = key;
_value = value;
MaxLength = maxLength;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="typeArray">Type array</param>
/// <param name="serializer">Serializer</param>
public BinaryEnumSerializer(Type typeEnum, IBinaryCustomSerializable serializer)
{
Type = typeEnum;
Serializer = serializer;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="atr">Attribute</param>
/// <param name="type">Type</param>
/// <param name="member">Member</param>
public BinarySerializerCacheEntry(BinaryPropertyAttribute atr, Type type, MemberInfo member)
{
Type = type;
Name = member.Name ?? null;
var isArray = type.IsArray;
var isList = _iListType.IsAssignableFrom(type);
var isReadOnlyList = type.IsGenericType && _iReadonlyListType.Contains(type.GetGenericTypeDefinition());
var isHashSet = type.IsGenericType && _iHashSetType.Contains(type.GetGenericTypeDefinition());
var isDic = type.IsGenericType && _iDictionaryTypes.Contains(type.GetGenericTypeDefinition());
if (atr == null)
{
Context = null;
MaxLength = Order = 0;
Override = false;
ValueHandlerLogic = ValueHandlerLogicType.Writable;
}
else
{
Override = atr.Override;
Context = atr;
MaxLength = atr.MaxLength;
Order = atr.Order;
ValueHandlerLogic = atr.ValueHandlerLogic;
}
if (type == typeof(byte[]))
{
Serializer = new BinaryByteArraySerializer(MaxLength);
}
else
{
if (isArray || isList)
{
// Extract type of array
type = type.GetElementType();
}
else
{
if (isHashSet || isReadOnlyList)
{
// Extract type of generic type
type = type.GetGenericArguments().FirstOrDefault();
}
else
{
if (isDic)
{
// Is dictionary
var gen = type.GetGenericArguments();
if (!TryRecursive(member, gen[0], out var key, MaxLength) ||
!TryRecursive(member, gen[1], out var value, MaxLength))
{
throw new NotImplementedException();
}
Serializer = new BinaryDictionarySerializer(type, gen[0], key, gen[1], value, MaxLength);
return;
}
}
}
var isEnum = type.IsEnum;
if (isEnum)
{
type = Enum.GetUnderlyingType(type);
}
// Try to extract the BinarySerializer
if (!TryRecursive(member, type, out Serializer, MaxLength))
{
throw new NotImplementedException();
}
if (isArray)
{
Serializer = new BinaryArraySerializer(Type, Serializer, MaxLength);
}
else if (isList)
{
Serializer = new BinaryListSerializer(Type, Serializer, MaxLength);
}
else if (isReadOnlyList)
{
Serializer = new BinaryReadOnlyListSerializer(Type, Serializer, MaxLength);
}
else if (isHashSet)
{
Serializer = new BinaryHashSetSerializer(Type, Serializer, MaxLength);
}
else if (isEnum)
{
Serializer = new BinaryEnumSerializer(Type, Serializer);
}
if (Serializer == null)
{
throw new NotImplementedException();
}
}
}
internal static bool TryRecursive(MemberInfo member, Type type, out IBinaryCustomSerializable serializer, int maxLength)
{
// Default types
var serializerAttr = member?.GetCustomAttribute <BinaryTypeSerializerAttribute>();
if (serializerAttr == null)
{
serializerAttr = type.GetCustomAttribute <BinaryTypeSerializerAttribute>();
}
if (serializerAttr != null)
{
serializer = serializerAttr.Create(); return(true);
}
else if (type == typeof(string))
{
serializer = new BinaryStringSerializer(maxLength);
return(true);
}
else if (type == typeof(long))
{
serializer = new BinaryInt64Serializer();
return(true);
}
else if (type == typeof(ulong))
{
serializer = new BinaryUInt64Serializer();
return(true);
}
else if (type == typeof(int))
{
serializer = new BinaryInt32Serializer();
return(true);
}
else if (type == typeof(uint))
{
serializer = new BinaryUInt32Serializer();
return(true);
}
else if (type == typeof(short))
{
serializer = new BinaryInt16Serializer();
return(true);
}
else if (type == typeof(ushort))
{
serializer = new BinaryUInt16Serializer();
return(true);
}
else if (type == typeof(byte))
{
serializer = new BinaryByteSerializer();
return(true);
}
else if (type == typeof(sbyte))
{
serializer = new BinarySByteSerializer();
return(true);
}
else if (type == typeof(bool))
{
serializer = new BinaryBoolSerializer();
return(true);
}
else if (type == typeof(double))
{
serializer = new BinaryDoubleSerializer();
return(true);
}
// Search in cache
var cache = BinarySerializerCache.InternalRegisterTypes(type);
if (cache == null)
{
serializer = null;
return(false);
}
serializer = new RecursiveCustomSerializer(type);
return(true);
}
