public static Packet DeserializePacket(IPacketHeader packetHeader, Stream source /*, out object customErrorData*/)
{
ET_CSPacketHeader header = packetHeader as ET_CSPacketHeader;
if (header == null)
{
Debug.LogError("header为空.");
return(null);
}
Packet packet = null;
if (header.IsValid)
{
Type packetType = GetClientToServerPacketType(header.Id);
if (packetType != null && source is MemoryStream)
{
object instance = Activator.CreateInstance(packetType);
packet = (Packet)ProtobufHelper.FromStream(instance, (MemoryStream)source);
}
else
{
Debug.LogError("Can not deserialize packet for packet id '{0}'.", header.Id.ToString());
}
}
else
{
Debug.LogError("Packet header is invalid.");
}
header.Clear();
return(packet);
}
/// <summary>
/// 反序列化消息包。
/// </summary>
/// <param name="packetHeader">消息包头。</param>
/// <param name="source">要反序列化的来源流。</param>
/// <param name="customErrorData">用户自定义错误数据。</param>
/// <returns>反序列化后的消息包。</returns>
public Packet DeserializePacket(IPacketHeader packetHeader, Stream source, out object customErrorData)
{
customErrorData = null;
CTM_SCPacketHeader header = packetHeader as CTM_SCPacketHeader;
if (header == null)
{
Log.Warning("Packet header is invalid.");
return(null);
}
Packet packet = null;
if (header.IsValid)
{
Type packetType = GetServerToClientPacketType(header.Id);
if (packetType != null && source is MemoryStream)
{
packet = (Packet)ProtobufHelper.FromStream(ReferencePool.Acquire(packetType), (MemoryStream)source);
}
else
{
Log.Warning("Can not deserialize packet for packet id '{0}'.", header.Id.ToString());
}
}
else
{
Log.Warning("Packet header is invalid.");
}
ReferencePool.Release(header);
return(packet);
}
public void HandleMessage(MemoryStream memoryStream, Session session)
{
var login = ProtobufHelper.FromStream(typeof(LoginMessage), memoryStream) as LoginMessage;
var conn = DBHelper.Instance.GetConnection();
AccountDAO dao = new AccountDAO();
LoginMessage ms = new LoginMessage();
if (login == null)
{
ms.Message = "N";
}
else
{
Account result = dao.VerifyAccount(conn, login.Email, login.Password, null);
if (result == null)
{
ms.Message = "N";
}
else
{
ms.Message = "Y";
ms.Id = result.Id;
ms.Username = result.UserName;
ms.Password = result.Password;
ms.Email = result.Email;
ms.Phone = result.Phone;
}
}
ResponseMessage(ms, session);
}
public void HandleMessage(MemoryStream msg, Session session)
{
var addFriend = ProtobufHelper.FromStream(typeof(AddFriendMessage), msg) as AddFriendMessage;
AccountDAO accountDAO = new AccountDAO();
var id = accountDAO.GetAccountIdByEmail(DBHelper.Instance.GetConnection(), addFriend.FriendEmail);
FriendDAO friendDAO = new FriendDAO();
ResponseMessage responseMessage = new ResponseMessage();
if (id != -1)
{
var result = friendDAO.InsertFriend(DBHelper.Instance.GetConnection(), addFriend.OwnerId, id);
if (result)
{
responseMessage.Message = "Y";
}
else
{
responseMessage.Message = "N";
}
}
else
{
responseMessage.Message = "N";
}
ResponseMessage(responseMessage, session);
}
public void FromStream(int iteration)
{
#pragma warning disable CS0618
var binaryStream = BinaryHelper.ToStream(_testModel);
#pragma warning restore CS0618
var dataContractStream = DataContractHelper.ToStream(_testModel);
var jilStream = JilHelper.ToStream(_testModel);
var messagePackStream = MessagePackHelper.ToStream(_testModel);
var msgPackStream = MsgPackHelper.ToStream(_testModel);
var newtonsoftJsonStream = NewtonsoftJsonHelper.ToStream(_testModel);
var protobufStream = ProtobufHelper.ToStream(_testModel);
var sharpYamlStream = SharpYamlHelper.ToStream(_testModel);
var systemTextJsonStream = SystemTextJsonHelper.ToStream(_testModel);
var utf8JsonStream = Utf8JsonHelper.ToStream(_testModel);
var xmlStream = XmlHelper.ToStream(_testModel);
var yamlDotNetStream = YamlDotNetHelper.ToStream(_testModel);
var zeroFormatterStream = ZeroFormatterHelper.ToStream(_testModel);
Console.WriteLine("FromStream go!");
Runner.Initialize();
Console.WriteLine(Runner.Time("BinaryHelper FromStream", iteration,
#pragma warning disable CS0618
() => BinaryHelper.FromStream <TestModel>(binaryStream)));
#pragma warning restore CS0618
Console.WriteLine(Runner.Time("DataContractHelper FromStream", iteration,
() => DataContractHelper.FromStream <TestModel>(dataContractStream)));
Console.WriteLine(Runner.Time("JilHelper FromStream", iteration,
() => JilHelper.FromStream <TestModel>(jilStream)));
Console.WriteLine(Runner.Time("MessagePackHelper FromStream", iteration,
() => MessagePackHelper.FromStream <TestModel>(messagePackStream)));
Console.WriteLine(Runner.Time("MsgPackHelper FromStream", iteration,
() => MsgPackHelper.FromStream <TestModel>(msgPackStream)));
Console.WriteLine(Runner.Time("NewtonsoftJsonHelper FromStream", iteration,
() => NewtonsoftJsonHelper.FromStream <TestModel>(newtonsoftJsonStream)));
Console.WriteLine(Runner.Time("ProtobufHelper FromStream", iteration,
() => ProtobufHelper.FromStream <TestModel>(protobufStream)));
Console.WriteLine(Runner.Time("SharpYamlHelper FromStream", iteration,
() => SharpYamlHelper.FromStream <TestModel>(sharpYamlStream)));
Console.WriteLine(Runner.Time("SystemTextJsonHelper FromStream", iteration,
() => SystemTextJsonHelper.FromStream <TestModel>(systemTextJsonStream)));
Console.WriteLine(Runner.Time("Utf8JsonHelper FromStream", iteration,
() => Utf8JsonHelper.FromStream <TestModel>(utf8JsonStream)));
Console.WriteLine(Runner.Time("XmlHelper FromStream", iteration,
() => XmlHelper.FromStream <TestModel>(xmlStream)));
Console.WriteLine(Runner.Time("YamlDotNetHelper FromStream", iteration,
() => YamlDotNetHelper.FromStream <TestModel>(yamlDotNetStream)));
Console.WriteLine(Runner.Time("ZeroFormatterHelper FromStream", iteration,
() => ZeroFormatterHelper.FromStream <TestModel>(zeroFormatterStream)));
Console.WriteLine("\r\nFromStream complete!\r\n");
}
public void Publish(MemoryStream memoryStream)
{
memoryStream.Seek(0, SeekOrigin.Begin);
int opcode = BitConverter.ToInt32(memoryStream.GetBuffer(), Packet.OpcodeIndex);
//long pid =
BitConverter.ToInt64(memoryStream.GetBuffer(), Packet.IdIndex);
memoryStream.Seek(Packet.MessageIndex, SeekOrigin.Begin);
object instance = this.typeMessages[opcode];
object message = ProtobufHelper.FromStream(instance, memoryStream);
this.Publish(opcode, message);
}
public void HandleMessage(MemoryStream msg, Session session)
{
var registMsg = ProtobufHelper.FromStream(typeof(RegisterMessage), msg) as RegisterMessage;
var conn = DBHelper.Instance.GetConnection();
AccountDAO dao = new AccountDAO();
Account account = new Account()
{
Email = registMsg.Email,
Password = registMsg.Password,
Phone = registMsg.Phone,
UserName = registMsg.Username
};
var isResult = dao.ExistAccount(conn, account);
ResponseMessage rm = new ResponseMessage();
if (isResult == ErrorCode.ERR_EXISTEMAIL)
{
rm.Error = ErrorCode.ERR_EXISTEMAIL;
rm.Message = "N";
}
else if (isResult == ErrorCode.ERR_EXISTPHONE)
{
rm.Error = ErrorCode.ERR_EXISTPHONE;
rm.Message = "N";
}
else
{
int res = dao.InsertAccount(DBHelper.Instance.GetConnection(), account);
if (res == 0)
{
rm.Message = "N";
rm.Error = ErrorCode.ERR_UNKNOWN;
}
else
{
rm.Message = "Y";
}
}
ResponseMessage(rm, session);
}
public Packet DeserializePacket(IPacketHeader packetHeader, Stream source, out object customErrorData)
{
customErrorData = null;
ET_SCPacketHeader header = packetHeader as ET_SCPacketHeader;
if (header == null)
{
Log.Warning("Packet header is invalid.");
return(null);
}
Packet packet = null;
if (header.IsValid)
{
Type packetType = GetServerToClientPacketType(header.Id);
//Log.Debug("~~~~~~~~~~~"+packetType.Name);
if (packetType != null && source is MemoryStream)
{
//packet = (Packet)RuntimeTypeModel.Default.DeserializeWithLengthPrefix(source, ReferencePool.Acquire(packetType), packetType, PrefixStyle.Fixed32, 0);
object instance = Activator.CreateInstance(packetType);
//packet = (Packet)ProtobufHelper.FromStream(packetType, (MemoryStream)source);
packet = (Packet)ProtobufHelper.FromStream(instance, (MemoryStream)source);
}
else
{
Log.Warning("Can not deserialize packet for packet id '{0}'.", header.Id.ToString());
}
}
else
{
Log.Warning("Packet header is invalid.");
}
ReferencePool.Release(header);
//DispatchMsg(packet);
return(packet);
}
public void HandleMessage(MemoryStream msg, Session session)
{
var msgs = ProtobufHelper.FromStream(typeof(FriendListMessage), msg) as FriendListMessage;
var conn = DBHelper.Instance.GetConnection();
FriendDAO fDao = new FriendDAO();
var friendList = fDao.GetFriendIdList(conn, msgs.OwnerId);
AccountDAO accountDAO = new AccountDAO();
FriendListMessage message = new FriendListMessage();
foreach (var i in friendList)
{
var connT = DBHelper.Instance.GetConnection();
var friend = accountDAO.GetAccountById(connT, i);
Core.Friend friendObj = new Core.Friend()
{
UserName = friend.UserName,
Phone = friend.Phone,
Email = friend.Email
};
message.Friends.Add(friendObj);
}
ResponseMessage(message, session);
}
public void HandlerMessage(MemoryStream memoryStreamMsg, Session session)
{
var response = ProtobufHelper.FromStream(typeof(ResponseMessage), memoryStreamMsg) as ResponseMessage;
NetworkManager.GetInstance.AddFriendCallBack?.Invoke(response);
}
public void HandlerMessage(MemoryStream memoryStreamMsg, Session session)
{
var friend = ProtobufHelper.FromStream(typeof(FriendListMessage), memoryStreamMsg) as FriendListMessage;
NetworkManager.GetInstance.GetFriendListCallBack?.Invoke(friend);
}
public void HandlerMessage(MemoryStream memoryStream, Session session)
{
var login = ProtobufHelper.FromStream(typeof(LoginMessage), memoryStream) as LoginMessage;
NetworkManager.GetInstance.LoginCallBack?.Invoke(login);
}
public static object?FromStream(this Stream?stream, Type type) => ProtobufHelper.FromStream(type, stream);
public static TValue?FromStream <TValue>(this Stream?stream) => ProtobufHelper.FromStream <TValue>(stream);
