/// <summary>
/// 第三方数据转换成元数据
/// </summary>
/// <param name="proxy">内存段实例</param>
/// <param name="baseValueMessage">存储属性的实例对象</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public void ValueProcessor(IMemorySegmentProxy proxy, BaseValueStored baseValueMessage)
{
if (proxy == null)
{
throw new ArgumentNullException("proxy");
}
if (baseValueMessage == null)
{
throw new ArgumentNullException("baseValueMessage");
}
string[] value = baseValueMessage.GetValue <string[]>();
proxy.WriteInt32(value.Length);
if (value.Length == 0)
{
return;
}
for (int j = 0; j < value.Length; j++)
{
string elementValue = value[j];
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);
}
}
}
/// <summary>
/// 将一个对象字段转换为二进制元数据
/// </summary>
/// <param name="metadata">需要转换成元数据的Value字典</param>
/// <param name="proxy">内存段代理器</param>
internal unsafe static void ToBytes(ResourceBlock metadata, IMemorySegmentProxy proxy)
{
Dictionary <byte, BaseValueStored> valueStoreds = metadata.GetMetaDataDictionary();
uint markRangeLength = (uint)(valueStoreds.Count * 5);
MemoryPosition wrapperStartPosition = proxy.GetPosition();
proxy.Skip(4U);
proxy.WriteUInt16((ushort)(valueStoreds.Count));
MemoryPosition wrapperMarkRangeStartPosition = proxy.GetPosition();
proxy.Skip(markRangeLength);
MemoryPosition wrapperOffsetStartPosition = proxy.GetPosition();
MarkRange * markRange = stackalloc MarkRange[valueStoreds.Count];
int i = 0;
foreach (KeyValuePair <byte, BaseValueStored> valueStored in valueStoreds)
{
//转化成二进制数组的形式
MemoryPosition wrapperCurrentPosition = proxy.GetPosition();
uint currentOffset = (uint)MemoryPosition.CalcLength(proxy.SegmentCount, wrapperOffsetStartPosition, wrapperCurrentPosition);
(markRange + i)->Id = valueStored.Key;
(markRange + i++)->Flag = (uint)((currentOffset << 8) | (int)valueStored.Value.TypeId);
if (valueStored.Value.IsNull)
{
continue;
}
valueStored.Value.ToBytes(proxy);
}
MemoryPosition wrapperEndPosition = proxy.GetPosition();
//回写mark Range
proxy.WriteBackMemory(wrapperMarkRangeStartPosition, markRange, markRangeLength);
//回写4bytes总长
proxy.WriteBackInt32(wrapperStartPosition, MemoryPosition.CalcLength(proxy.SegmentCount, wrapperStartPosition, wrapperEndPosition));
}
/// <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)
{
char value;
if (!isNullable)
{
value = analyseResult.GetValue <char>(target);
}
else
{
char?nullableValue = analyseResult.GetValue <char?>(target);
if (nullableValue == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id,
analyseResult.Property.Name,
analyseResult.Property.PropertyType));
}
value = (char)nullableValue;
}
if (attribute.AllowDefaultNull && value.Equals(DefaultValue.Char) && !isArrayElement)
{
return;
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteChar(value);
}
/// <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="type">类型</param>
/// <param name="instance">实例对象</param>
/// <returns>返回序列化后的二进制数据, 如果instance为null, 则返回null</returns>
/// <exception cref="ArgumentNullException">type 参数不能为空</exception>
/// <exception cref="NotSupportedException">不被支持的类型</exception>
public static byte[] ToBytes(Type type, object instance)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (instance == null)
{
return(null);
}
MemoryAllotter.Instance.Initialize();
IMemorySegmentProxy proxy = null;
try
{
proxy = MemorySegmentProxyFactory.Create();
ToBytes(type, instance, proxy);
return(proxy.GetBytes());
}
catch
{
if (proxy != null)
{
proxy.Dispose();
}
throw;
}
}
/// <summary>
/// 将一个智能对象转换为二进制元数据
/// </summary>
/// <param name="obj">智能对象</param>
/// <returns>返回二进制元数据</returns>
/// <exception cref="PropertyNullValueException">字段相关的Attribute.IsRequire = true, 并且该字段的值为null</exception>
/// <exception cref="UnexpectedValueException">不期待的结果异常，通常因为对Blob类型的取值 = null</exception>
/// <exception cref="NotSupportedException">系统不支持的序列化类型</exception>
/// <exception cref="DefineNoMeaningException">无意义的智能字段Attribute值</exception>
/// <exception cref="MethodAccessException">类型权限定义错误</exception>
/// <exception cref="Exception">内部错误</exception>
public static byte[] ToBytes(IThriftObject obj)
{
if (obj == null)
{
return(null);
}
IMemorySegmentProxy proxy = null;
try
{
proxy = MemorySegmentProxyFactory.Create();
ToBytes(obj, proxy);
//end flag of Thrift protocol object.
proxy.WriteSByte(0x00);
return(proxy.GetBytes());
}
catch (Exception ex)
{
if (proxy != null)
{
proxy.Dispose();
}
throw;
}
}
/// <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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
int value = analyseResult.GetValue<int>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(((short)attribute.Id).ToBigEndian());
proxy.WriteInt32(value.ToBigEndian());
}
/// <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)
{
byte[] value = analyseResult.GetValue <byte[]>(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;
}
unsafe
{
fixed(byte *pByte = value) proxy.WriteMemory(pByte, (uint)value.Length * Size.Byte);
}
proxy.WriteBackInt32(position, (int)(value.Length * Size.Byte + 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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
byte value = analyseResult.GetValue <byte>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(((short)attribute.Id).ToBigEndian());
proxy.WriteByte(value);
}
/// <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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
MessageIdentity value = analyseResult.GetValue<MessageIdentity>(target);
byte[] data = Encoding.UTF8.GetBytes(value.Command);
proxy.WriteInt32(value.Version.ToBigEndian());
proxy.WriteInt32(((int)value.CommandLength).ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
proxy.WriteInt32(((int)value.SequenceId).ToBigEndian());
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
MessageIdentity identity = (MessageIdentity)target;
proxy.WriteByte(identity.ProtocolId);
proxy.WriteByte(identity.ServiceId);
proxy.WriteByte(identity.DetailsId);
proxy.WriteInt16(identity.Tid);
}
/// <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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string value = analyseResult.GetValue<string>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(((short)attribute.Id).ToBigEndian());
byte[] data = Encoding.UTF8.GetBytes(value);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint) data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>
/// * 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)
/// </para>
/// </summary>
/// <param name="proxy">内存片段代理器</param><param name="target">目标对象实例</param><param name="isArrayElement">当前写入的值是否为数组元素标示</param><param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
Color value = (Color)target;
if (value == null)
{
return;
}
proxy.WriteMemory(value.Data, 0U, (uint)value.Data.Length);
}
/// <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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
MessageIdentity value = analyseResult.GetValue <MessageIdentity>(target);
byte[] data = Encoding.UTF8.GetBytes(value.Command);
proxy.WriteInt32(value.Version.ToBigEndian());
proxy.WriteInt32(((int)value.CommandLength).ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
proxy.WriteInt32(((int)value.SequenceId).ToBigEndian());
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
if (string.IsNullOrEmpty((string)target))
{
return;
}
string value = (string)target;
proxy.WriteString(value);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
if (target == null)
{
return;
}
BitFlag value = (BitFlag)target;
proxy.WriteBitFlag(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)
{
MessageIdentity identity = analyseResult.GetValue <MessageIdentity>(target);
proxy.WriteByte((byte)attribute.Id);
proxy.WriteByte(identity.ProtocolId);
proxy.WriteByte(identity.ServiceId);
proxy.WriteByte(identity.DetailsId);
proxy.WriteInt16(identity.Tid);
}
/// <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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
byte[] value = analyseResult.GetValue<byte[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
//proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
proxy.WriteMemory(value, 0, (uint) value.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
if (target == null)
{
return;
}
IPEndPoint value = (IPEndPoint)target;
proxy.WriteIPEndPoint(value);
}
/// <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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string value = analyseResult.GetValue <string>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(((short)attribute.Id).ToBigEndian());
byte[] data = Encoding.UTF8.GetBytes(value);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (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>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
byte[] value = analyseResult.GetValue <byte[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
//proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
proxy.WriteMemory(value, 0, (uint)value.Length);
}
/// <summary>
/// 第三方数据转换成元数据
/// </summary>
/// <param name="proxy">内存段实例</param>
/// <param name="baseValueMessage">存储属性的实例对象</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public unsafe void ValueProcessor(IMemorySegmentProxy proxy, BaseValueStored baseValueMessage)
{
if (proxy == null)
{
throw new ArgumentNullException("proxy");
}
if (baseValueMessage == null)
throw new ArgumentNullException("baseValueMessage");
fixed(IntPtr *pByte = baseValueMessage.GetValue <IntPtr[]>())
proxy.WriteMemory(pByte, (uint)baseValueMessage.GetValue <IntPtr[]>().Length *Size.IntPtr);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
IPEndPoint[] array = (IPEndPoint[])target;
if (array == null || array.Length == 0)
{
return;
}
for (int i = 0; i < array.Length; i++)
{
proxy.WriteIPEndPoint(array[i]);
}
}
/// <summary>
/// 第三方数据转换成元数据
/// </summary>
/// <param name="proxy">内存段实例</param>
/// <param name="baseValueMessage">存储属性的实例对象</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public void ValueProcessor(IMemorySegmentProxy proxy, BaseValueStored baseValueMessage)
{
if (proxy == null)
{
throw new ArgumentNullException("proxy");
}
if (baseValueMessage == null)
{
throw new ArgumentNullException("baseValueMessage");
}
proxy.WriteMemory(baseValueMessage.GetValue <byte[]>(), 0, (uint)baseValueMessage.GetValue <byte[]>().Length);
}
/// <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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string[] value = analyseResult.GetValue<string[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
foreach (string data in value)
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
proxy.WriteInt32(bytes.Length.ToBigEndian());
proxy.WriteMemory(bytes, 0, (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>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string[] value = analyseResult.GetValue <string[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
foreach (string data in value)
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
proxy.WriteInt32(bytes.Length.ToBigEndian());
proxy.WriteMemory(bytes, 0, (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>
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>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
Blob value = (Blob)target;
if (value == null)
{
return;
}
byte[] data = value.Compress();
if (data == null)
{
return;
}
proxy.WriteMemory(data, 0U, (uint)data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public unsafe override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
short[] array = (short[])target;
if (array == null || array.Length == 0)
{
return;
}
if (array.Length > 10)
fixed(short *pByte = array) proxy.WriteMemory(pByte, (uint)array.Length * Size.Int16);
else
{
for (int i = 0; i < array.Length; i++)
{
proxy.WriteInt16(array[i]);
}
}
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
char value;
if (!isNullable)
{
value = (char)target;
}
else
{
if (target == null)
{
return;
}
value = (char)target;
}
proxy.WriteChar(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)
{
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="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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
Dictionary<string, Cell> value = analyseResult.GetValue<Dictionary<string, Cell>>(target);
if (value == null) return;
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteByte((byte)PropertyTypes.Struct);
proxy.WriteInt32((value.Count).ToBigEndian());
foreach (KeyValuePair<string, Cell> pair in value)
{
byte[] data = Encoding.UTF8.GetBytes(pair.Key);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
pair.Value.Bind();
data = pair.Value.Body;
proxy.WriteMemory(data, 0, (uint)data.Length);
}
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
TransactionIdentity identity = (TransactionIdentity)target;
if (identity == null)
{
return;
}
if (identity.IdentityType == TransactionIdentityTypes.TCP)
{
TCPTransactionIdentity.Serialize(0, IdentitySerializationTypes.IntellectObject, (TCPTransactionIdentity)identity, proxy);
}
else if (identity.IdentityType == TransactionIdentityTypes.NamedPipe)
{
NamedPipeTransactionIdentity.Serialize(0, 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="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="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, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false);
