/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (serializer != null)
{
serializer.CharStream.Dispose();
serializer.Free();
serializer = null;
}
}
/// <summary>
/// DataReader JSON 序列化
/// </summary>
/// <param name="isSignle">是否单条记录，否则为数组</param>
/// <param name="serializeConfig"></param>
/// <param name="isIgnoreNull">是否忽略 null</param>
public DataReaderJsonSerialize(bool isSignle, SerializeConfig serializeConfig = null, bool isIgnoreNull = true)
{
this.isIgnoreNull = isIgnoreNull;
serializer = Json.Serializer.YieldPool.Default.Pop() ?? new Json.Serializer();
serializer.SetTcpServer();
serializer.Config = serializeConfig ?? Json.Serializer.DefaultConfig;
serializer.CharStream.Reset();
if (!isSignle)
{
serializer.CustomArrayStart();
serializers = NullValue <Action <AutoCSer.Json.Serializer, object> > .Array;
}
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeSByte(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((sbyte)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeByteArray(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((byte[])value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeBool(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((bool)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeGuid(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((Guid)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeDecimal(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((decimal)value);
}
private static void enumToString(Serializer jsonSerializer, valueType value)
{
jsonSerializer.EnumToString(value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeULong(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((ulong)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeDateTime(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((DateTime)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeString(AutoCSer.Json.Serializer serializer, object value)
{
serializer.Serialize((string)value);
}
internal static void Serialize(Serializer jsonSerializer, valueType value)
{
Serialize(jsonSerializer, ref value);
}
static TypeSerializer()
{
Type type = typeof(valueType);
MethodInfo methodInfo = Serializer.GetSerializeMethod(type);
if (methodInfo != null)
{
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
isValueType = true;
return;
}
if (type.IsArray)
{
//if (type.GetArrayRank() == 1) defaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.GetArray(type.GetElementType()));
if (type.GetArrayRank() == 1)
{
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), GenericType.Get(type.GetElementType()).JsonSerializeArrayMethod);
}
else
{
defaultSerializer = arrayManyRank;
}
isValueType = true;
return;
}
if (type.IsEnum)
{
defaultSerializer = enumToString;
isValueType = true;
return;
}
if (type.IsInterface || type.IsPointer || typeof(Delegate).IsAssignableFrom(type))
{
defaultSerializer = toNull;
isValueType = true;
return;
}
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(Dictionary <,>))
{
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), SerializeMethodCache.GetDictionary(type));
isValueType = true;
return;
}
if (genericType == typeof(Nullable <>))
{
//defaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.GetNullable(type));
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), StructGenericType.Get(type.GetGenericArguments()[0]).JsonSerializeNullableMethod);
isValueType = true;
return;
}
if (genericType == typeof(KeyValuePair <,>))
{
//defaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.GetKeyValuePair(type));
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), GenericType2.Get(type.GetGenericArguments()).JsonSerializeKeyValuePairMethod);
isValueType = true;
return;
}
}
if ((methodInfo = SerializeMethodCache.GetCustom(type)) != null)
{
if (type.IsValueType)
{
#if NOJIT
defaultSerializer = new CustomSerializer(methodInfo).Serialize;
#else
DynamicMethod dynamicMethod = new DynamicMethod("CustomJsonSerializer", null, new Type[] { typeof(Serializer), type }, type, true);
ILGenerator generator = dynamicMethod.GetILGenerator();
generator.Emit(OpCodes.Ldarga_S, 1);
generator.Emit(OpCodes.Ldarg_0);
generator.call(methodInfo);
generator.Emit(OpCodes.Ret);
defaultSerializer = (Action <Serializer, valueType>)dynamicMethod.CreateDelegate(typeof(Action <Serializer, valueType>));
#endif
}
else
{
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
}
isValueType = true;
}
else if ((methodInfo = SerializeMethodCache.GetIEnumerable(type)) != null)
{
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
isValueType = true;
}
else
{
Type attributeType;
attribute = type.customAttribute <SerializeAttribute>(out attributeType) ?? (type.Name[0] == '<' ? SerializeAttribute.AnonymousTypeMember : Serializer.AllMemberAttribute);
if (type.IsValueType)
{
isValueType = true;
}
else if (attribute != Serializer.AllMemberAttribute && attributeType != type)
{
for (Type baseType = type.BaseType; baseType != typeof(object); baseType = baseType.BaseType)
{
SerializeAttribute baseAttribute = baseType.customAttribute <SerializeAttribute>();
if (baseAttribute != null)
{
if (baseAttribute.IsBaseType)
{
methodInfo = SerializeMethodCache.BaseSerializeMethod.MakeGenericMethod(baseType, type);
defaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
return;
}
break;
}
}
}
LeftArray <FieldIndex> fields = SerializeMethodCache.GetFields(MemberIndexGroup <valueType> .GetFields(attribute.MemberFilters), attribute);
LeftArray <KeyValue <PropertyIndex, MethodInfo> > properties = SerializeMethodCache.GetProperties(MemberIndexGroup <valueType> .GetProperties(attribute.MemberFilters), attribute);
bool isBox = false;
if (type.IsValueType && fields.Length + properties.Length == 1)
{
BoxSerializeAttribute boxSerialize = AutoCSer.Metadata.TypeAttribute.GetAttribute <BoxSerializeAttribute>(type);
if (boxSerialize != null && boxSerialize.IsJson)
{
isBox = true;
}
}
#if AutoCSer
AutoCSer.WebView.ClientTypeAttribute clientType = isBox ? null : AutoCSer.Metadata.TypeAttribute.GetAttribute <AutoCSer.WebView.ClientTypeAttribute>(type);
if (clientType != null)
{
if (clientType.MemberName == null)
{
viewClientTypeName = "new " + clientType.GetClientName(type) + "({";
}
else
{
viewClientTypeName = clientType.GetClientName(type) + ".Get({";
}
}
#endif
#if NOJIT
if (isBox)
{
defaultSerializer = memberSerializer = new FieldPropertySerializer(ref fields, ref properties).SerializeBox;
}
else
{
memberSerializer = new FieldPropertySerializer(ref fields, ref properties).Serialize;
memberMapSerializer = new MemberMapSerializer(ref fields, ref properties).Serialize;
}
#else
SerializeMemberDynamicMethod dynamicMethod = new SerializeMemberDynamicMethod(type);
SerializeMemberMapDynamicMethod memberMapDynamicMethod = isBox ? default(SerializeMemberMapDynamicMethod) : new SerializeMemberMapDynamicMethod(type);
foreach (FieldIndex member in fields)
{
if (isBox)
{
dynamicMethod.PushBox(member);
}
else
{
dynamicMethod.Push(member);
memberMapDynamicMethod.Push(member);
}
}
foreach (KeyValue <PropertyIndex, MethodInfo> member in properties)
{
if (isBox)
{
dynamicMethod.PushBox(member.Key, member.Value);
}
else
{
dynamicMethod.Push(member.Key, member.Value);
memberMapDynamicMethod.Push(member.Key, member.Value);
}
}
memberSerializer = (Action <Serializer, valueType>)dynamicMethod.Create <Action <Serializer, valueType> >();
if (isBox)
{
defaultSerializer = memberSerializer;
}
else
{
memberMapSerializer = (Action <MemberMap, Serializer, valueType, CharStream>)memberMapDynamicMethod.Create <Action <MemberMap, Serializer, valueType, CharStream> >();
}
#endif
}
}
private static void toNull(Serializer jsonSerializer, valueType value)
{
jsonSerializer.CharStream.WriteJsonNull();
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeShort(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((short)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeUInt(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((uint)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeDouble(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((double)value);
}
/// <summary>
/// 序列化数据值
/// </summary>
/// <param name="serializer"></param>
/// <param name="value"></param>
private static void serializeFloat(AutoCSer.Json.Serializer serializer, object value)
{
serializer.CallSerialize((float)value);
}
private static void arrayManyRank(Serializer jsonSerializer, valueType value)
{
jsonSerializer.CharStream.WriteJsonArray();
}
