/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param><param name="data">元数据</param>
/// <returns>
/// 返回转换后的第三方客户数据
/// </returns>
/// <exception cref="N:KJFramework.Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
unsafe
{
fixed(byte *pData = data)
{
IPEndPoint iep = new IPEndPoint(new IPAddress(BitConverter.GetBytes(*(int *)pData)), *(int *)(pData + 4));
return(iep);
}
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
if (attribute == null)
{
throw new System.Exception("非法的智能属性标签。");
}
if (attribute.IsRequire && data == null)
{
throw new System.Exception("无法处理非法的类型值。");
}
return(BitConverter.ToSingle(data, 0));
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
if (attribute == null)
{
throw new System.Exception("非法的智能属性标签。");
}
if (attribute.IsRequire && data == null)
{
throw new System.Exception("无法处理非法的类型值。");
}
long ticks = BitConverter.ToInt64(data, 0);
return(new DateTime(ticks));
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>
/// 返回转换后的第三方客户数据
/// </returns>
/// <exception cref="N:KJFramework.Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
TransactionIdentityTypes identityType = (TransactionIdentityTypes)data[0];
if (identityType == TransactionIdentityTypes.TCP)
{
return(TCPTransactionIdentity.Deserialize(data, 0, data.Length));
}
if (identityType == TransactionIdentityTypes.NamedPipe)
{
return(NamedPipeTransactionIdentity.Deserialize(data, 0, data.Length));
}
throw new NotSupportedException(string.Format("#We were not support current type of Transaction-Identity yet! {0}", identityType));
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
IPEndPoint value = analyseResult.GetValue <IPEndPoint>(target);
if (value == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteIPEndPoint(value);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
if (attribute == null)
{
throw new System.Exception("非法的智能属性标签。");
}
if (attribute.IsRequire && data == null)
{
throw new System.Exception("无法处理非法的类型值。");
}
unsafe
{
fixed(byte *pByte = data) return(*(decimal *)pByte);
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public unsafe override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
TimeSpan[] array = new TimeSpan[data.Length / Size.TimeSpan];
fixed(byte *pByte = data)
{
TimeSpan *pData = (TimeSpan *)pByte;
for (int i = 0; i < array.Length; i++)
{
array[i] = *pData++;
}
}
return(array);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public unsafe override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
ulong[] array = new ulong[data.Length / Size.UInt64];
fixed(byte *pByte = data)
{
ulong *pData = (ulong *)pByte;
for (int i = 0; i < array.Length; i++)
{
array[i] = *pData++;
}
}
return(array);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public unsafe override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
short[] array = new short[data.Length / Size.Int16];
fixed(byte *pByte = data)
{
short *pData = (short *)pByte;
for (int i = 0; i < array.Length; i++)
{
array[i] = *pData++;
}
}
return(array);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
if (attribute == null)
{
throw new ArgumentNullException("attribute");
}
if (attribute.IsRequire && data == null)
{
throw new System.Exception("Cannot process a required value, because current binary data is null! #attr id: " + attribute.Id);
}
if (data == null || data.Length == 0)
{
return(null);
}
return(new Blob(data));
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
Color value = analyseResult.GetValue <Color>(target);
if (value == null || value.Data == null)
{
if (attribute.IsRequire)
{
if (attribute.IsRequire)
{
throw new Exception(string.Format("#Currently property data is required! Id: {0}", attribute.Id));
}
}
return;
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteMemory(value.Data, 0U, (uint)value.Data.Length);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
if (attribute == null)
{
throw new System.Exception("非法的智能属性标签。");
}
if (attribute.IsRequire && data == null)
{
throw new System.Exception("无法处理非法的类型值。");
}
//x86
if (Size.IntPtr == 4)
{
return(new IntPtr(BitConverter.ToInt32(data, 0)));
}
//x64
return(new IntPtr(BitConverter.ToInt64(data, 0)));
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
int offset = 4;
ushort len;
string[] array = new string[BitConverter.ToInt32(data, 0)];
for (int i = 0; i < array.Length; i++)
{
len = BitConverter.ToUInt16(data, offset);
offset += 2;
if (len == 0)
{
continue;
}
array[i] = Encoding.UTF8.GetString(data, offset, len);
offset += len;
}
return(array);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string value = isArrayElement ? (string)target : analyseResult.GetValue <string>(target);
if (value == null)
{
if (!attribute.IsRequire || isArrayElement)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
if (!isArrayElement)
{
proxy.WriteByte((byte)attribute.Id);
proxy.WriteInt32(Encoding.UTF8.GetByteCount(value));
}
proxy.WriteString(value);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
Blob value = analyseResult.GetValue <Blob>(target);
if (value == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
byte[] data = value.Compress();
if (data == null)
{
throw new UnexpectedValueException(string.Format(ExceptionMessage.EX_UNEXPRECTED_VALUE, attribute.Id, analyseResult.Property.Name));
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteInt32(data.Length);
proxy.WriteMemory(data, 0U, (uint)data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
TransactionIdentity identity = analyseResult.GetValue <TransactionIdentity>(target);
if (identity == null)
{
return;
}
if (identity.IdentityType == TransactionIdentityTypes.TCP)
{
TCPTransactionIdentity.Serialize((byte)attribute.Id, IdentitySerializationTypes.IntellectObject, (TCPTransactionIdentity)identity, proxy);
}
else if (identity.IdentityType == TransactionIdentityTypes.NamedPipe)
{
NamedPipeTransactionIdentity.Serialize((byte)attribute.Id, IdentitySerializationTypes.IntellectObject, (NamedPipeTransactionIdentity)identity, proxy);
}
else
{
throw new NotSupportedException(string.Format("#We were not support current type of Transaction-Identity yet! {0}", identity.IdentityType));
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
if (data == null || data.Length == 0)
{
return(null);
}
IPEndPoint[] array = new IPEndPoint[data.Length / Size.IPEndPoint];
unsafe
{
int innerOffset = 0;
fixed(byte *pByte = data)
{
for (int i = 0; i < array.Length; i++)
{
array[i] = new IPEndPoint(new IPAddress(BitConverter.GetBytes(*(int *)(pByte + innerOffset))), *(int *)(pByte + innerOffset + 4));
innerOffset += (int)Size.IPEndPoint;
}
}
}
return(array);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string[] value = analyseResult.GetValue <string[]>(target);
if (value == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
//id(1) + total length(4) + rank(4)
proxy.WriteByte((byte)attribute.Id);
MemoryPosition position = proxy.GetPosition();
proxy.Skip(4U);
proxy.WriteInt32(value.Length);
if (value.Length == 0)
{
proxy.WriteBackInt32(position, 4);
return;
}
for (int i = 0; i < value.Length; i++)
{
string elementValue = value[i];
if (string.IsNullOrEmpty(elementValue))
{
proxy.WriteUInt16(0);
}
else
{
byte[] elementData = Encoding.UTF8.GetBytes(elementValue);
proxy.WriteUInt16((ushort)elementData.Length);
proxy.WriteMemory(elementData, 0U, (uint)elementData.Length);
}
}
MemoryPosition endPosition = proxy.GetPosition();
proxy.WriteBackInt32(position, MemoryPosition.CalcLength(proxy.SegmentCount, position, endPosition) - 4);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
short[] value = analyseResult.GetValue <short[]>(target);
if (value == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
//id(1) + total length(4) + rank(4)
proxy.WriteByte((byte)attribute.Id);
MemoryPosition position = proxy.GetPosition();
proxy.Skip(4U);
proxy.WriteInt32(value.Length);
if (value.Length == 0)
{
proxy.WriteBackInt32(position, 4);
return;
}
if (value.Length > 10)
{
unsafe
{
fixed(short *pByte = value) proxy.WriteMemory(pByte, (uint)(value.Length * Size.Int16));
}
}
else
{
for (int i = 0; i < value.Length; i++)
{
proxy.WriteInt16(value[i]);
}
}
proxy.WriteBackInt32(position, (int)(value.Length * Size.Int16 + 4));
}
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
throw new NotSupportedException("Cannot use this method, because current type doesn't supported.");
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
return(new Guid(data));
}
/// <summary> /// 从第三方客户数据转换为元数据 /// </summary> /// <param name="proxy">内存片段代理器</param> /// <param name="attribute">字段属性</param> /// <param name="analyseResult">分析结果</param> /// <param name="target">目标对象实例</param> /// <param name="isArrayElement">当前写入的值是否为数组元素标示</param> /// <param name="isNullable">是否为可空字段标示</param> public abstract void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false);
/// <summary> /// 从元数据转换为第三方客户数据 /// </summary> /// <param name="attribute">当前字段标注的属性</param> /// <param name="data">元数据</param> /// <returns>返回转换后的第三方客户数据</returns> /// <exception cref="Exception">转换失败</exception> public abstract object Process(IntellectPropertyAttribute attribute, byte[] data);