/// <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)
{
sbyte value;
if (!isNullable)
{
value = analyseResult.GetValue <sbyte>(target);
}
else
{
sbyte?nullableValue = analyseResult.GetValue <sbyte?>(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 = (sbyte)nullableValue;
}
if (attribute.AllowDefaultNull && value.Equals(DefaultValue.SByte) && !isArrayElement)
{
return;
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteSByte(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)
{
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)
{
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="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="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)
{
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>
/// 从第三方客户数据转换为元数据
/// <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)
{
sbyte[] array = (sbyte[])target;
if (array == null || array.Length == 0)
{
return;
}
if (array.Length > 10)
fixed(sbyte *pByte = array) proxy.WriteMemory(pByte, (uint)array.Length * Size.SByte);
else
{
for (int i = 0; i < array.Length; i++)
{
proxy.WriteSByte(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)
{
sbyte value;
if (!isNullable)
{
value = (sbyte)target;
}
else
{
if (target == null)
{
return;
}
value = (sbyte)target;
}
proxy.WriteSByte(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>
/// 从第三方客户数据转换为元数据
/// </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)
{
sbyte[] value = analyseResult.GetValue <sbyte[]>(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(sbyte *pByte = value) proxy.WriteMemory(pByte, (uint)value.Length * Size.SByte);
}
}
else
{
for (int i = 0; i < value.Length; i++)
{
proxy.WriteSByte(value[i]);
}
}
proxy.WriteBackInt32(position, (int)(value.Length * Size.SByte + 4));
}
/// <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, string> value = analyseResult.GetValue <Dictionary <string, string> >(target);
if (value == null)
{
return;
}
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32((value.Count).ToBigEndian());
foreach (KeyValuePair <string, string> pair in value)
{
byte[] data = Encoding.UTF8.GetBytes(pair.Key);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
data = Encoding.UTF8.GetBytes(pair.Value);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
}
}
