public static WebSession LoadWebSession(this ISession session)
{
var data = session.Get(WebSession.UserSessionKey);
if (data == null)
{
return(null);
}
ulong id;
Guid? empID = null;
TreeNodePath path;
string tag = null;
using (var ms = new MemoryStream(data))
{
var bs = new BinSerializer(ms); //TODO:使用ThreadCache或参照RoutedSessionReader
id = bs.ReadUInt64();
path = (TreeNodePath)bs.Deserialize();
bool isExternal = bs.ReadBoolean();
if (!isExternal)
{
empID = bs.ReadGuid();
}
tag = bs.ReadString();
bs.Clear();
}
return(new WebSession(id, path, empID, tag));
}
public void SerializeTest()
{
var obj = "sys.HelloService.SayHello"; //TestHelper.SysEmploeeModel;
byte[] data = null;
using (var ms = new MemoryStream(1024))
{
BinSerializer cf = new BinSerializer(ms);
try { cf.Serialize(obj); }
catch (Exception) { throw; }
finally { cf.Clear(); }
ms.Close();
data = ms.ToArray();
}
Console.WriteLine($"Data length: {data.Length}");
Console.WriteLine(StringHelper.ToHexString(data));
object result = null;
using (var ms = new MemoryStream(data))
{
BinSerializer cf = new BinSerializer(ms);
try { result = cf.Deserialize(); }
catch (Exception) { throw; }
finally { cf.Clear(); }
}
Console.WriteLine(result);
}
/// <summary>
/// 序列化并发送消息，如果序列化异常标记消息为错误状态仍旧发送,接收端根据消息类型是请求还是响应作不同处理
/// </summary>
public void SendMessage <T>(ref T msg) where T : struct, IMessage
{
//Log.Debug($"[{System.Diagnostics.Process.GetCurrentProcess().ProcessName}]发送:{msg.Type}");
MessageFlag flag = MessageFlag.None;
int msgId = Interlocked.Increment(ref sendMsgIdIndex);
ulong sourceId = 0; //TODO: fix
var mws = MessageWriteStream.ThreadInstance;
mws.Reset(msg.Type, msgId, sourceId, flag, _sendQueue);
BinSerializer bs = BinSerializer.ThreadInstance;
bs.Init(mws);
try
{
bs.Write((byte)msg.PayloadType); //不用bs.Serialize(msg)防止box
msg.WriteObject(bs);
mws.FinishWrite();
}
catch (Exception ex)
{
//发生异常，则通知接收端取消挂起的消息
unsafe
{
SendCancelMessage(mws.CurrentChunk);
}
//重新抛出异常
Log.Warn(ExceptionHelper.GetExceptionDetailInfo(ex));
throw new MessageSerializationException(MessageSerilizationErrorCode.SerializeFail, ex);
}
finally
{
bs.Clear();
}
}
/// <summary>
/// Serializes the model.
/// </summary>
internal static byte[] SerializeModel(object obj)
{
using var ms = new MemoryStream(1024);
BinSerializer cf = new BinSerializer(ms);
try { cf.Serialize(obj); }
catch (Exception) { throw; }
finally { cf.Clear(); }
ms.Close();
return(ms.ToArray());
}
internal static object DeserializeModel(byte[] data)
{
object result = null;
using var ms = new MemoryStream(data);
BinSerializer cf = new BinSerializer(ms);
try { result = cf.Deserialize(); }
catch (Exception) { throw; }
finally { cf.Clear(); }
return(result);
}
private byte[] SerializeExpression(Expressions.Expression exp)
{
byte[] data = null;
using (var ms = new MemoryStream(1024))
{
var cf = new BinSerializer(ms);
try { cf.Serialize(exp); }
catch (Exception) { throw; }
finally { cf.Clear(); }
ms.Close();
data = ms.ToArray();
}
return(data);
}
/// <summary>
/// 反序列化消息 注意：不管是否成功归还缓存块至通道
/// </summary>
/// <exception>只抛出MessageSerializationException</exception>
public unsafe T Deserialize <T>(MessageChunk *first) where T : struct, IMessage
{
if (first == null)
{
throw new MessageSerializationException(MessageSerilizationErrorCode.DeserializeFailByFirstSegmentIsNull, null);
}
//??注意：不能判断first->First == first, 因为AppContainer子进程内收到的路由消息已修改第一包
var mrs = MessageReadStream.ThreadInstance;
mrs.Reset(first);
BinSerializer bs = BinSerializer.ThreadInstance;
bs.Init(mrs);
T res = default;
try
{
var payloadType = bs.ReadByte(); //不用res = bs.Deserialize();避免box
if (payloadType != (byte)res.PayloadType)
{
throw new MessageSerializationException(MessageSerilizationErrorCode.DeserializeFailByMessageType, null);
}
res.ReadObject(bs);
mrs.Close();
}
catch (MessageSerializationException)
{
throw;
}
catch (Exception ex) //TODO:单独捕获解密错误信息
{
//Log.Warn(ex.StackTrace);
throw new MessageSerializationException(MessageSerilizationErrorCode.DeserializeFail, ex);
}
finally
{
ReturnMessageChunks(first);
bs.Clear();
}
return(res);
}
public static void SaveWebSession(this ISession session, WebSession value)
{
byte[] data = null;
using (var ms = new MemoryStream())
{
var bs = new BinSerializer(ms); //TODO:使用ThreadCache或参照RoutedSesseionWriter
bs.Write(value.SessionID);
bs.Serialize(value.TreeNodePath);
bs.Write(value.IsExternal);
if (!value.IsExternal)
{
bs.Write(value.EmploeeID);
}
bs.Write(value.Tag);
bs.Clear();
data = ms.ToArray();
}
session.Set(WebSession.UserSessionKey, data);
}
//TODO: 获取分区对应的RaftGroupId时考虑在Native层缓存
/// <summary>
/// Serializes the model.
/// </summary>
/// <returns>在主进程内返回的是NativeString，在子进程内返回NativeBytes</returns>
internal static unsafe IntPtr SerializeModel(object obj, out int size, int offset = 0)
{
//TODO:暂使用内存Copy
byte[] data = null;
using (MemoryStream ms = new MemoryStream(1024))
{
BinSerializer cf = new BinSerializer(ms);
try { cf.Serialize(obj); }
catch (Exception) { throw; }
finally { cf.Clear(); }
ms.Close();
data = ms.ToArray();
}
size = data.Length + offset;
IntPtr nativeDataPtr = IntPtr.Zero;
byte * dp;
if (Runtime.RuntimeContext.Current.RuntimeId == 0)
{
nativeDataPtr = NativeApi.NewNativeString(size, out dp);
}
else
{
nativeDataPtr = NativeBytes.MakeRaw(size);
dp = (byte *)nativeDataPtr + 4;
}
//Log.Debug($"序列化模型: {obj.GetType().Name} arraySize={size} stringSize={NativeString.GetSize(dataString)}");
fixed(byte *pv = data)
{
for (int i = 0; i < offset; i++)
{
dp[i] = 0;
}
Buffer.MemoryCopy(pv, dp + offset, data.Length, data.Length);
}
return(nativeDataPtr);
}
public void EntityListSerializeTest()
{
var model = TestHelper.EmploeeModel;
var obj = new Entity(model);
var list = new EntityList(model.Id);
list.Add(obj);
byte[] data = null;
using (var ms = new MemoryStream(1024))
{
BinSerializer cf = new BinSerializer(ms);
cf.Serialize(list);
cf.Clear();
ms.Close();
data = ms.ToArray();
}
Assert.True(data.Length > 0);
output.WriteLine($"DataLen = {data.Length}");
}
internal static unsafe object DeserializeModel(IntPtr dataPtr, int dataSize, int offset = 0)
{
byte *dp = (byte *)dataPtr.ToPointer();
object result = null;
var stream = new UnmanagedMemoryStream(dp + offset, dataSize - offset);
BinSerializer cf = new BinSerializer(stream);
try { result = cf.Deserialize(); }
catch (Exception) { throw; }
finally { cf.Clear(); }
stream.Close();
if (result != null && result is ApplicationModel && offset == APP_DATA_OFFSET)
{
var app = (ApplicationModel)result;
app.StoreId = dp[0];
uint *devIdCounterPtr = (uint *)(dp + 1);
//uint* usrIdCounterPtr = (uint*)(dp + 5);
app.DevModelIdSeq = *devIdCounterPtr;
}
return(result);
}
