/// <summary>
/// 将一个IntellectObject数组转换成byte数组的形式
/// </summary>
/// <param name="value">值</param>
/// <exception cref="UnexpectedValueException">结果错误</exception>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public static byte[] BindIntellectObjectArray(IntellectObject[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
MemoryAllotter.Instance.Initialize();
IMemorySegmentProxy proxy = MemorySegmentProxyFactory.Create();
proxy.WriteUInt32((uint)value.Length);
for (int i = 0; i < value.Length; i++)
{
IntellectObject elementObj = value[i];
if (elementObj == null)
{
proxy.WriteUInt16(0);
}
else
{
MemoryPosition currentPostion = proxy.GetPosition();
proxy.Skip(2U);
int length = IntellectObjectEngine.ToBytes(elementObj, proxy);
proxy.WriteBackUInt16(currentPostion, (ushort)length);
}
}
return(proxy.GetBytes());
}
/// <summary>
/// 解析元数据
/// </summary>
/// <param name="data">总BUFF长度</param>
/// <param name="offset">可用偏移量</param>
/// <param name="count">可用长度</param>
/// <returns>
/// 返回能否解析的一个标示
/// </returns>
public override List <T> Parse <T>(byte[] data, int offset, int count)
{
if (data.Length - offset < count)
{
_tracing.Warn("#Cannot parse segment data, remaining count has no enough!");
return(null);
}
int protocolId = data[offset + 5];
int serviceId = data[offset + 6];
int detailsId = data[offset + 7];
Type messageType = GetMessageType(protocolId, serviceId, detailsId);
if (messageType == null)
{
_tracing.Error("#Parse message failed, illegal message protocol. #protocol id={0}, service id={1}, detalis id={2}\r\nTarget protocol stack: {3} ", protocolId, serviceId, detailsId, this);
return(null);
}
try
{
BaseMessage baseMessage = IntellectObjectEngine.GetObject <BaseMessage>(messageType, data, offset, count);
return(baseMessage != null ? new List <T> {
(T)(object)baseMessage
} : null);
}
catch (System.Exception ex)
{
_tracing.Error(ex, "#Parse message failed, illegal message protocol. #protocol id={0}, service id={1}, detalis id={2}\r\nTarget protocol stack: {3} ", protocolId, serviceId, detailsId, this);
return(null);
}
}
/// <summary>
/// 返回一个IntellectObject数组
/// </summary>
/// <param name="intellectObjectArrayValueStored">智能对象数组存储类型</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public static T[] GetAttributeAsIntellectObjectArray <T>(IntellectObjectArrayValueStored intellectObjectArrayValueStored)
where T : IntellectObject
{
if (intellectObjectArrayValueStored == null)
{
throw new ArgumentNullException("intellectObjectArrayValueStored");
}
byte[] intellectObject = intellectObjectArrayValueStored.GetValue <byte[]>();
int arrLen = BitConverter.ToInt32(intellectObject, 0);
if (arrLen == 0)
{
return(null);
}
T[] array = new T[arrLen];
int innerOffset = 4;
ushort size;
for (int i = 0; i < array.Length; i++)
{
size = BitConverter.ToUInt16(intellectObject, innerOffset);
innerOffset += 2;
if (size == 0)
{
array[i] = null;
}
else
{
array[i] = IntellectObjectEngine.GetObject <T>(typeof(T), intellectObject, innerOffset, size);
}
innerOffset += size;
}
return(array);
}
/// <summary>
/// 解析元数据
/// </summary>
/// <param name="data">元数据</param>
/// <returns>
/// 返回能否解析的一个标示
/// </returns>
public override List <T> Parse <T>(byte[] data)
{
int offset = 0;
int totalLength;
List <T> messages = new List <T>();
try
{
while (offset < data.Length)
{
totalLength = BitConverter.ToInt32(data, offset);
if (totalLength > data.Length)
{
_tracing.Error("#Parse message failed, illegal total length. #length: " + totalLength);
return(messages);
}
byte[] messageData = totalLength == data.Length
? data
: ByteArrayHelper.GetReallyData(data, offset, totalLength);
int protocolId = messageData[5];
int serviceId = messageData[6];
int detailsId = messageData[7];
Type messageType = GetMessageType(protocolId, serviceId, detailsId);
if (messageType == null)
{
_tracing.Error("#Parse message failed, illegal message protocol. #protocol id={0}, service id={1}, detalis id={2}\r\nTarget protocol stack: {3} ", protocolId, serviceId, detailsId, this);
return(messages);
}
offset += messageData.Length;
BaseMessage message;
try
{
//使用智能对象引擎进行解析
message = IntellectObjectEngine.GetObject <BaseMessage>(messageType, messageData);
if (message == null)
{
_tracing.Error("#Parse message failed, parse result = null. #protocol id={0}, service id={1}, detalis id={2}: ", protocolId, serviceId, detailsId);
return(messages);
}
}
catch (System.Exception ex)
{
_tracing.Error(ex, "#Parse message failed.");
continue;
}
messages.Add((T)(object)message);
if (data.Length - offset < 4)
{
break;
}
}
return(messages);
}
catch (System.Exception ex)
{
_tracing.Error(ex, "#Parse message failed.");
return(messages);
}
}
/// <summary>
/// 返回一个IntellectObject
/// </summary>
/// <param name="intellectObjectValueStored">智能对象存储类型</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public static T GetAttributeAsIntellectObject <T>(IntellectObjectValueStored intellectObjectValueStored)
where T : IntellectObject
{
if (intellectObjectValueStored == null)
{
throw new ArgumentNullException("intellectObjectValueStored");
}
byte[] intellectObject = intellectObjectValueStored.GetValue <byte[]>();
return(IntellectObjectEngine.GetObject <T>(intellectObject));
}
/// <summary>
/// 绑定到元数据
/// </summary>
/// <exception cref="MethodAccessException">错误的类型权限定义</exception>
public virtual void Bind()
{
try
{
_body = IntellectObjectEngine.ToBytes(this);
_isBind = true;
}
catch (MethodAccessException ex)
{
_isBind = false;
_body = null;
_tracing.Error(ex, null);
//redirect to friendly exception message.
throw new MethodAccessException(string.Format(ExceptionMessage.EX_METHOD_ACCESS, GetType().FullName));
}
catch (System.Exception ex)
{
_isBind = false;
_body = null;
_tracing.Error(ex, null);
}
}
/// <summary>
/// 设置字段实例
/// </summary>
/// <param name="instance">对象实例</param>
/// <param name="analyseResult">字段临时解析结构</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据偏移</param>
/// <param name="length">元数据可用长度</param>
public static void SetInstance(object instance, GetObjectAnalyseResult analyseResult, byte[] data, int offset, int length)
{
GetObjectAnalyseResult analyze = analyseResult;
//热处理判断
if (analyze.HasCacheFinished)
{
analyze.CacheProcess(instance, analyseResult, data, offset, length);
return;
}
#region 普通类型判断
IIntellectTypeProcessor intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(analyze.Attribute.Id) ??
IntellectTypeProcessorMapping.Instance.GetProcessor(analyze.Property.PropertyType);
if (intellectTypeProcessor != null)
{
//添加热缓存
IIntellectTypeProcessor processor = intellectTypeProcessor;
if (intellectTypeProcessor.SupportUnmanagement)
{
analyze.CacheProcess = processor.Process;
}
else
{
analyze.CacheProcess = delegate(object innerInstance, GetObjectAnalyseResult innerAnalyseResult, byte[] parameter, int position, int len) { processor.Process(analyze.Attribute, parameter); }
};
analyze.CacheProcess(instance, analyseResult, data, offset, length);
analyze.HasCacheFinished = true;
return;
}
#endregion
#region 枚举类型判断
//枚举类型
if (analyze.Property.PropertyType.GetTypeInfo().IsEnum)
{
Type enumType = Enum.GetUnderlyingType(analyze.Property.PropertyType);
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(enumType);
if (intellectTypeProcessor == null)
{
throw new System.Exception("Cannot support this enum type! #type: " + analyze.Property.PropertyType);
}
//添加热处理
IIntellectTypeProcessor processor = intellectTypeProcessor;
if (intellectTypeProcessor.SupportUnmanagement)
{
analyze.CacheProcess = processor.Process;
}
else
{
analyze.CacheProcess = delegate(object innerInstance, GetObjectAnalyseResult innerAnalyseResult, byte[] parameter, int position, int len) { processor.Process(analyze.Attribute, parameter); }
};
analyze.CacheProcess(instance, analyseResult, data, offset, length);
analyze.HasCacheFinished = true;
return;
}
#endregion
#region 可空类型判断
Type innerType;
if ((innerType = Nullable.GetUnderlyingType(analyze.Property.PropertyType)) != null)
{
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(innerType);
if (intellectTypeProcessor != null)
{
//添加热缓存
IIntellectTypeProcessor processor = intellectTypeProcessor;
if (intellectTypeProcessor.SupportUnmanagement)
{
analyze.CacheProcess = processor.Process;
}
else
{
analyze.CacheProcess = delegate(object innerInstance, GetObjectAnalyseResult innerAnalyseResult, byte[] parameter, int position, int len) { processor.Process(analyze.Attribute, parameter); }
};
analyze.CacheProcess(instance, analyseResult, data, offset, length);
analyze.HasCacheFinished = true;
return;
}
throw new System.Exception("Cannot find compatible processor, #type: " + analyze.Property.PropertyType);
}
#endregion
#region 智能类型的判断
//智能对象的判断
if (analyze.Property.PropertyType.GetTypeInfo().IsClass&& analyze.Property.PropertyType.GetTypeInfo().GetInterface(Consts.IntellectObjectFullName) != null)
{
//添加热缓存
analyze.CacheProcess = delegate(Object innerInstance, GetObjectAnalyseResult innerAnalyseResult, byte[] parameter, int position, int len)
{
innerAnalyseResult.SetValue(innerInstance, IntellectObjectEngine.GetObject <IntellectObject>(analyze.Property.PropertyType, parameter, position, len));
};
analyze.CacheProcess(instance, analyseResult, data, offset, length);
analyze.HasCacheFinished = true;
return;
}
#endregion
#region 数组的判断
if (analyze.Property.PropertyType.IsArray)
{
Type elementType = analyze.Property.PropertyType.GetElementType();
VT vt = FixedTypeManager.IsVT(elementType);
//VT type.
if (vt != null)
{
#region VT type array processor.
IIntellectTypeProcessor arrayProcessor = ArrayTypeProcessorMapping.Instance.GetProcessor(analyseResult.Property.PropertyType);
//special optimize.
if (arrayProcessor != null)
{
analyze.CacheProcess = arrayProcessor.Process;
analyze.CacheProcess(instance, analyseResult, data, offset, length);
}
//normally process.
else
{
throw new DefineNoMeaningException(string.Format(ExceptionMessage.EX_VT_FIND_NOT_PROCESSOR, analyze.Attribute.Id, analyze.Property.Name, analyze.Property.PropertyType));
}
#endregion
}
else if (elementType.GetTypeInfo().IsSubclassOf(typeof(IntellectObject)))
{
#region IntellectObject type array processor.
//add HOT cache.
analyze.CacheProcess = delegate(Object innerInstance, GetObjectAnalyseResult innerAnalyseResult, byte[] parameter, int position, int len)
{
int innerOffset = position;
int chunkSize = position + len;
int arrLen = BitConverter.ToInt32(parameter, innerOffset);
Func <int, IntellectObject[]> func = IntellectObjectArrayHelper.GetFunc <IntellectObject>(analyze.Property.PropertyType);
if (arrLen == 0)
{
innerAnalyseResult.SetValue(innerInstance, func(0));
return;
}
innerOffset += 4;
IntellectObject[] array = func(arrLen);
int arrIndex = 0;
short size;
do
{
size = BitConverter.ToInt16(parameter, innerOffset);
innerOffset += 2;
if ((parameter.Length - innerOffset) < size)
{
throw new System.Exception("Illegal remaining binary data length!");
}
//use unmanagement method by default.
if (size == 0)
{
array[arrIndex] = null;
}
else
{
array[arrIndex] = IntellectObjectEngine.GetObject <IntellectObject>(elementType, parameter, innerOffset, size);
}
innerOffset += size;
arrIndex++;
} while (innerOffset < parameter.Length && innerOffset < chunkSize);
innerAnalyseResult.SetValue(innerInstance, array);
};
#endregion
}
else if (!(elementType == typeof(string)) && elementType.GetTypeInfo().IsSerializable)
{
throw new NotSupportedException(string.Format(ExceptionMessage.EX_NOT_SUPPORTED_VALUE, analyseResult.Attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
else if (elementType == typeof(string))
{
#region Any types if it can get the processor.
intellectTypeProcessor = ArrayTypeProcessorMapping.Instance.GetProcessor(analyze.Property.PropertyType);
if (intellectTypeProcessor == null)
{
throw new System.Exception("Cannot support this array element type processor! #type: " + elementType);
}
//Add hot cache.
analyze.CacheProcess = intellectTypeProcessor.Process;
#endregion
}
else
{
throw new NotSupportedException(string.Format(ExceptionMessage.EX_NOT_SUPPORTED_VALUE, analyseResult.Attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
analyze.HasCacheFinished = true;
analyze.CacheProcess(instance, analyseResult, data, offset, length);
return;
}
#endregion
throw new System.Exception("Cannot support this data type: " + analyze.Property.PropertyType);
}
#endregion
}
}
/// <summary>
/// 将指定类型的实例序列化为二进制数据
/// </summary>
/// <param name="type">类型</param>
/// <param name="instance">实例对象</param>
/// <param name="proxy">内存段代理器</param>
/// <returns>返回序列化后的二进制数据, 如果instance为null, 则返回null</returns>
/// <exception cref="NotSupportedException">不被支持的类型</exception>
private static void ToBytes(Type type, object instance, IMemorySegmentProxy proxy)
{
Type innerType;
Action <IMemorySegmentProxy, object> cache;
lock (_serLockObj)
{
if (_serializers.TryGetValue(type.FullName, out cache))
{
cache(proxy, instance);
return;
}
IIntellectTypeProcessor intellectTypeProcessor;
#region 普通类型判断
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(type);
if (intellectTypeProcessor != null)
{
//添加热缓存
IIntellectTypeProcessor processor = intellectTypeProcessor;
_serializers.Add(type.FullName, (cache = (innerProxy, innerObj) => processor.Process(innerProxy, innerObj)));
}
#endregion
#region 枚举类型判断
//枚举类型
else if (type.GetTypeInfo().IsEnum)
{
//获取枚举类型
Type enumType = Enum.GetUnderlyingType(type);
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(enumType);
if (intellectTypeProcessor == null)
{
throw new NotSupportedException(string.Format(ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, type));
}
IIntellectTypeProcessor processor = intellectTypeProcessor;
_serializers.Add(type.FullName, (cache = (innerProxy, innerObj) => processor.Process(innerProxy, innerObj)));
}
#endregion
#region 可空类型判断
else if ((innerType = Nullable.GetUnderlyingType(type)) != null)
{
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(innerType);
if (intellectTypeProcessor == null)
{
throw new NotSupportedException(string.Format(ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, innerType));
}
IIntellectTypeProcessor processor = intellectTypeProcessor;
_serializers.Add(type.FullName, (cache = (innerProxy, innerObj) => processor.Process(innerProxy, innerObj)));
}
#endregion
#region 智能对象类型判断
else if (type.GetTypeInfo().IsSubclassOf(typeof(IntellectObject)))
{
_serializers.Add(type.FullName, (cache = (innerProxy, innerObj) => { IntellectObjectEngine.ToBytes((IIntellectObject)innerObj, innerProxy); }));
}
#endregion
#region 数组的判断
else if (type.IsArray)
{
if (!type.HasElementType)
{
throw new NotSupportedException(string.Format(ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, type));
}
Type elementType = type.GetElementType();
VT vt = FixedTypeManager.IsVT(elementType);
IIntellectTypeProcessor arrayProcessor = ArrayTypeProcessorMapping.Instance.GetProcessor(type);
if (arrayProcessor != null)
{
_serializers.Add(type.FullName, (cache = (innerProxy, innerObj) => arrayProcessor.Process(innerProxy, innerObj)));
}
else if (vt != null)
{
throw new NotSupportedException(string.Format(ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, type));
}
else if (elementType.GetTypeInfo().IsSubclassOf(typeof(IntellectObject)))
{
//Add hot cache.
_serializers.Add(type.FullName, (cache = (innerProxy, innerObj) =>
{
IIntellectObject[] array = (IIntellectObject[])innerObj;
if (array == null || array.Length == 0)
{
return;
}
//write array length.
innerProxy.WriteUInt32((uint)array.Length);
for (int i = 0; i < array.Length; i++)
{
if (array[i] == null)
{
innerProxy.WriteUInt16(0);
}
else
{
MemoryPosition innerStartObjPosition = innerProxy.GetPosition();
innerProxy.Skip(Size.UInt16);
IntellectObjectEngine.ToBytes(array[i], innerProxy);
MemoryPosition innerEndObjPosition = innerProxy.GetPosition();
innerProxy.WriteBackUInt16(innerStartObjPosition, (ushort)(MemoryPosition.CalcLength(innerProxy.SegmentCount, innerStartObjPosition, innerEndObjPosition) - 2));
}
}
}));
}
else
{
throw new NotSupportedException(string.Format(ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, type));
}
}
#endregion
cache(proxy, instance);
}
}
/// <summary>
/// 将二进制数据反序列化成指定类型对象
/// </summary>
/// <param name="type">类型</param>
/// <param name="data">二进制数据</param>
/// <returns>返回反序列化后的对象, 如果data为null, 则返回null</returns>
/// <exception cref="ArgumentNullException">type 参数不能为空</exception>
public static object GetObject(Type type, byte[] data)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (data == null)
{
return(null);
}
Type innerType;
Func <byte[], object> cache;
IIntellectTypeProcessor intellectTypeProcessor;
lock (_deserLockObj)
{
if (_deserializers.TryGetValue(type.FullName, out cache))
{
return(cache(data));
}
#region 普通类型判断
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(type);
if (intellectTypeProcessor != null)
{
//添加热缓存
IIntellectTypeProcessor processor = intellectTypeProcessor;
_deserializers.Add(type.FullName,
cache =
parameter =>
{
return(processor.Process(IntellectTypeProcessorMapping.DefaultAttribute, parameter));
});
}
#endregion
#region 枚举类型判断
//枚举类型
else if (type.GetTypeInfo().IsEnum)
{
Type enumType = Enum.GetUnderlyingType(type);
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(enumType);
if (intellectTypeProcessor == null)
{
throw new NotSupportedException(string.Format(
ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, type));
}
IIntellectTypeProcessor processor = intellectTypeProcessor;
_deserializers.Add(type.FullName, cache = parameter => { return(processor.Process(IntellectTypeProcessorMapping.DefaultAttribute, parameter)); });
}
#endregion
#region 可空类型判断
else if ((innerType = Nullable.GetUnderlyingType(type)) != null)
{
intellectTypeProcessor = IntellectTypeProcessorMapping.Instance.GetProcessor(innerType);
if (intellectTypeProcessor == null)
{
throw new NotSupportedException(string.Format(
ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, type));
}
IIntellectTypeProcessor processor = intellectTypeProcessor;
_deserializers.Add(type.FullName, cache = parameter => { return(processor.Process(IntellectTypeProcessorMapping.DefaultAttribute, parameter)); });
}
#endregion
#region 智能类型的判断
//智能对象的判断
else if (type.GetTypeInfo().IsSubclassOf(typeof(IntellectObject)))
{
_deserializers.Add(type.FullName, cache = parameter => { return(IntellectObjectEngine.GetObject <object>(type, parameter)); });
}
#endregion
#region 数组的判断
else if (type.IsArray)
{
Type elementType = type.GetElementType();
IIntellectTypeProcessor arrayProcessor = ArrayTypeProcessorMapping.Instance.GetProcessor(type);
//VT type.
if (arrayProcessor != null)
{
_deserializers.Add(type.FullName, cache = parameter => { return(arrayProcessor.Process(IntellectTypeProcessorMapping.DefaultAttribute, parameter)); });
}
else if (elementType.GetTypeInfo().IsSubclassOf(typeof(IntellectObject)))
{
#region IntellectObject type array processor.
_deserializers.Add(type.FullName, cache = parameter => { Func <int, IntellectObject[]> func = IntellectObjectArrayHelper.GetFunc <IntellectObject>(type);
int arrLen = BitConverter.ToInt32(parameter, 0);
if (arrLen == 0)
{
return(func(0));
}
IntellectObject[] array = func(arrLen);
int innerOffset = 4;
ushort size;
for (int i = 0; i < array.Length; i++)
{
size = BitConverter.ToUInt16(parameter, innerOffset);
innerOffset += 2;
if (size == 0)
{
array[i] = null;
}
else
{
array[i] = IntellectObjectEngine.GetObject <IntellectObject>(elementType, parameter,
innerOffset, size);
}
innerOffset += size;
}
return(array); });
#endregion
}
else
{
throw new NotSupportedException(string.Format(
ExceptionMessage.EX_NOT_SUPPORTED_VALUE_TEMPORARY, type));
}
}
#endregion
return(cache(data));
}
}
