/// <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>
/// 将一个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="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)
{
ushort value;
if (!isNullable)
{
value = analyseResult.GetValue <ushort>(target);
}
else
{
ushort?nullableValue = analyseResult.GetValue <ushort?>(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 = (ushort)nullableValue;
}
if (attribute.AllowDefaultNull && value.Equals(DefaultValue.UInt16) && !isArrayElement)
{
return;
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteUInt16(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, 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>
/// 从第三方客户数据转换为元数据
/// <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)
{
string[] array = (string[])target;
if (array == null || array.Length == 0)
{
return;
}
proxy.WriteUInt32((uint)array.Length);
for (int i = 0; i < array.Length; i++)
{
string elementValue = array[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);
}
}
}
/// <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)
{
ushort[] array = (ushort[])target;
if (array == null || array.Length == 0)
{
return;
}
if (array.Length > 10)
fixed(ushort *pByte = array) proxy.WriteMemory(pByte, (uint)array.Length * Size.UInt16);
else
{
for (int i = 0; i < array.Length; i++)
{
proxy.WriteUInt16(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)
{
ushort value;
if (!isNullable)
{
value = (ushort)target;
}
else
{
if (target == null)
{
return;
}
value = (ushort)target;
}
proxy.WriteUInt16(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)
{
ushort[] value = analyseResult.GetValue <ushort[]>(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(ushort *pByte = value) proxy.WriteMemory(pByte, (uint)value.Length * Size.UInt16);
}
}
else
{
for (int i = 0; i < value.Length; i++)
{
proxy.WriteUInt16(value[i]);
}
}
proxy.WriteBackInt32(position, (int)(value.Length * Size.UInt16 + 4));
}
