protected void BeginTest(string mapName, int playersCount)
{
m_abilities = new Dictionary <int, VoxelAbilities[]>();
m_players = new Guid[playersCount];
for (int i = 0; i < m_players.Length; ++i)
{
m_players[i] = Guid.NewGuid();
m_abilities.Add(i, CreateTemporaryAbilies());
}
string dataPath = Application.streamingAssetsPath + "/Maps/";
string filePath = dataPath + mapName;
m_replay = MatchFactory.CreateReplayRecorder();
Dictionary <int, VoxelAbilities>[] allAbilities = new Dictionary <int, VoxelAbilities> [m_players.Length];
for (int i = 0; i < m_players.Length; ++i)
{
allAbilities[i] = m_abilities[i].ToDictionary(a => a.Type);
}
MapData mapData = m_protobufSerializer.Deserialize <MapData>(File.ReadAllBytes(filePath));
m_map = m_protobufSerializer.Deserialize <MapRoot>(mapData.Bytes);
m_engine = MatchFactory.CreateMatchEngine(m_map, playersCount);
for (int i = 0; i < m_players.Length; ++i)
{
m_engine.RegisterPlayer(m_players[i], i, allAbilities);
}
m_engine.CompletePlayerRegistration();
}
public JiraSettings Get()
{
JiraSettings result = null;
if (_applicationStorageFolder.FileExists(JiraSettingsFileName))
{
byte[] encryptedBytes = _applicationStorageFolder.GetBytes(JiraSettingsFileName);
EncryptedData encryptedData = _binarySerializer.Deserialize <EncryptedData, EncryptedDataProtobufContract>(encryptedBytes);
byte[] decryptedData = _dataEncryptor.Decrypt(encryptedData);
result = _binarySerializer.Deserialize <JiraSettings, JiraSettingsProtobufContract>(decryptedData);
}
return(result);
}
public void ExpreessionInfoCloneTest2()
{
ExpressionInfo canRun = ExpressionInfo.Eq(
ExpressionInfo.PrimitiveVal(CmdResultCode.Success),
ExpressionInfo.Val(new TaskInputInfo()));
Assert.DoesNotThrow(() =>
{
TaskInfo task = new TaskInfo {
Expression = canRun
};
byte[] b = m_protobufSerializer.Serialize(SerializedTask.FromTaskInfo(task));
SerializedTask.ToTaskInfo(m_protobufSerializer.Deserialize <SerializedTask>(b));
});
}
public void Json_Serialize_Deserialize_Test()
{
using (ProtobufSerializer serializer = new ProtobufSerializer())
{
Person person = new Person()
{
Id = 2, Name = "Jerry"
};
byte[] buffer = serializer.Serialize(person);
Person _person = serializer.Deserialize <Person>(buffer);
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
JsonObject json = new JsonObject(typeof(Person).FullName, buffer);
string jsonstr = JsonFormatter.SerializeObject(json);
JsonObject _json = JsonFormatter.DeserializeObject <JsonObject>(jsonstr);
JsonObject <Person> jsont = new JsonObject <Person>(typeof(Person).FullName, person);
string jsontstr = JsonFormatter.SerializeObject(jsont);
JsonObject <Person> _jsont = JsonFormatter.DeserializeObject <JsonObject <Person> >(jsontstr);
}
}
public Header GetHeader()
{
var serializer = new ProtobufSerializer();
var back = serializer.Deserialize <Header>(Header);
return(back);
}
virtual public void respond(proto_header head, byte[] block)
{
if (type != null)
{
ProtobufSerializer serializer = new ProtobufSerializer();
using (MemoryStream temp = new MemoryStream(block, 0, block.Length, true, true))
{
m_rec = serializer.Deserialize(temp, null, type);
}
if (m_rec != null)
{
DkRspMsg item = new DkRspMsg();
item.head = head;
item.body = m_rec;
if (isMsgPushQueue)
{
DkProtoQueue.Instance.push(item);
}
else
{
onRspHandler(item);
}
}
else
{
Debug.LogError("cmd " + head.shMsgID + " deserialize failed, please check !");
}
}
else
{
Debug.LogError("cmd " + head.shMsgID + " deserialize type is null !");
}
}
public static object Decode(byte[] msgbuf)
{
int id = (int)(((int)msgbuf[0] << 8) | ((int)msgbuf[1]));
if (id < 0)
{
LogSystem.Debug("decode error:message id({0}) error !!!", id);
return(null);
}
if (m_DicIDMsg.ContainsKey(id))
{
Type t = m_DicIDMsg[id];
m_Stream.SetLength(0);
m_Stream.Write(msgbuf, 2, msgbuf.Length - 2);
m_Stream.Position = 0;
object msg = m_Serializer.Deserialize(m_Stream, null, t);
if (msg == null)
{
LogSystem.Debug("decode error:can't find id {0} !!!", id);
return(null);
}
return(msg);
}
return(null);
}
private static T ProtobufDeSerialize <T>(Stream src)
{
if (src == null)
{
return(default(T));
}
if (typeof(T) == typeof(DataSet))
{
return((T)Convert.ChangeType(ProtobufDataSetSerializer.ProtoRead(src), typeof(T)));
}
if (typeof(T) == typeof(DataTable))
{
return((T)Convert.ChangeType(ProtobufDataTableSerializer.ProtoRead(src), typeof(T)));
}
T obj = ProtobufSerializer.Deserialize <T>(src);
if (obj == null)
{
return(default(T));
}
return(obj);
}
public void ValidateRequestSerialization()
{
// Arrange
IRequestMessage sent = factory.CreateRequestMessage("cat", "ICalculator", "Add", new object[] { 5, 6 }, true);
// Act
IRequestMessage received = (IRequestMessage)serializer.Deserialize(serializer.Serialize(sent));
(received as IIncomplete).Complete(typeof(ICalculator).GetMethod(nameof(ICalculator.Add)));
// Assert
Assert.AreEqual(sent.IsResponseExpected, received.IsResponseExpected);
CollectionAssert.AreEqual(sent.Args, received.Args);
Assert.AreEqual(sent.MethodName, received.MethodName);
Assert.AreEqual(sent.CorrelationId, received.CorrelationId);
Assert.AreEqual(sent.MessageType, received.MessageType);
}
public void emtpy_or_just_created_header_should_take_zero_bytes_when_serialized()
{
var header = new Header();
var serializer = new ProtobufSerializer();
var bytes = serializer.Serialize(header);
var back = serializer.Deserialize <Header>(bytes);
Assert.That(bytes.Length, Is.EqualTo(0));
}
public static T Deserialize <T> (byte[] data)
{
DebugUtils.Assert(data != null && data.Length > 0);
T dataObject;
using (MemoryStream m = new MemoryStream(data)) {
dataObject = (T)serializer.Deserialize(m, null, typeof(T));
}
return(dataObject);
}
public void Protobuf_Serialize_Deserialize_Test()
{
using (ProtobufSerializer serializer = new ProtobufSerializer())
{
Person person = new Person()
{
Id = 2, Name = "Jerry", Address = new Address()
};
byte[] buffer = serializer.Serialize(person);
Person _person = serializer.Deserialize <Person>(buffer);
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
ProtobufMessagePack <Person> pack = new ProtobufMessagePack <Person>(person);
buffer = serializer.Serialize(pack);
_person = serializer.Deserialize <ProtobufMessagePack <Person> >(buffer)?.Message;
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
Packet packet = new Packet(typeof(Person).FullName, buffer, PacketType.Join, Guid.NewGuid().ToString());
buffer = serializer.Serialize(new ProtobufPacket(packet));
ProtobufPacket _packet = serializer.Deserialize <ProtobufPacket>(buffer);
Assert.Equal(packet.PackType, _packet.PackType);
Assert.Equal(packet.PacketType, _packet.PacketType);
Assert.Equal(packet.FromId, _packet.FromId);
_person = serializer.Deserialize <ProtobufMessagePack <Person> >(_packet.Payload)?.Message;
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
}
}
public void Deserialize_Poco_NotNull()
{
var serializer = new ProtobufSerializer();
var data = new byte[]
{
8, 255, 255, 255, 255, 7, 18, 12, 84, 104,
105, 115, 32, 105, 115, 32, 80, 79, 67, 79
};
var poco = serializer.Deserialize <Poco>(data);
Assert.NotNull(poco);
}
public void simple_test()
{
var header = new Header();
header.Set("Hello", "World");
var serializer = new ProtobufSerializer();
var bytes = serializer.Serialize(header);
var back = serializer.Deserialize <Header>(bytes);
Assert.That(back.GetString("Hello"), Is.EqualTo("World"));
Assert.That(back.GetString("Hello"), Is.EqualTo(header.GetString("Hello")));
}
public void Deserialize_TypePoco_NotNull()
{
var serializer = new ProtobufSerializer();
var data = new byte[]
{
8, 255, 255, 255, 255, 7, 18, 12, 84, 104,
105, 115, 32, 105, 115, 32, 80, 79, 67, 79
};
var poco = serializer.Deserialize(data, typeof(Poco));
Assert.NotNull(poco);
Assert.True(typeof(Poco) == poco.GetType());
}
public void Deserialize_GZip()
{
var model = new Model()
{
Bar = 15, Foo = "foo"
};
IRedisSerializer protobufSerializer = new ProtobufSerializer()
{
CompressionFormat = CompressionFormat.GZip
};
var deserialized = protobufSerializer.Deserialize <Model>(protobufSerializer.Serialize(model));
Assert.Equal(model.Bar, deserialized.Bar);
Assert.Equal(model.Foo, deserialized.Foo);
}
public void ProtobufSerializer_ShouldRoundTrip()
{
var obj = new ClassToSerialize
{
Name = "Bob",
Id = 100
};
var serializer = new ProtobufSerializer();
var serialized = serializer.SerializeToStream(obj);
var deserialized = serializer.Deserialize <ClassToSerialize>(serialized);
deserialized.Name.ShouldEqual(obj.Name);
deserialized.Id.ShouldEqual(obj.Id);
}
public void ShouldSerializeServerToClientMessage()
{
var serializer = new ProtobufSerializer();
for (int i = 0; i < 1000; i++)
{
var s = serializer.Serialize(new ServerToClientMessage {
MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted
});
Assert.IsNotNull(s);
var d = serializer.Deserialize <ServerToClientMessage>(s);
Assert.IsNotNull(d);
}
}
public static T DeserializeProtocol <T>(byte[] kbyte)
{
try
{
T kProtocol = default(T);
using (MemoryStream kStream = new MemoryStream(kbyte))
{
kProtocol = (T)protobufSerializer.Deserialize(kStream, null, typeof(T));
}
return(kProtocol);
}
catch
{
Debug.LogError("Can't Decode PB " + typeof(T).Name);
return(default(T));
}
}
public void DeSerializationPerformanceTest()
{
var sw = new Stopwatch();
var serializer = new ProtobufSerializer();
var instance = new ServerToClientMessage();
var serialized = serializer.Serialize(instance);
sw.Start();
for (int i = 0; i < 5000000; i++)
serializer.Deserialize<ServerToClientMessage>(serialized);
sw.Stop();
var elapsed = sw.ElapsedMilliseconds;
double perItem = (double)elapsed / (double)5000000;
Console.WriteLine("Total ms: " + elapsed);
Console.WriteLine("Per item: " + perItem);
}
void Awake()
{
MemoryStream ms = new MemoryStream();
ActiveCodeReqPROTO ace = new ActiveCodeReqPROTO();
ace.AccountId = 10000000000000001;
ace.ActiveCode = "lyw";
ProtobufSerializer serializer = new ProtobufSerializer(new TypeModelProtobufSerializer());
serializer.Serialize(ms, ace);
MemoryStream memoryStream = new MemoryStream(ms.ToArray());
ActiveCodeReqPROTO activeCodeReq = (ActiveCodeReqPROTO)serializer.Deserialize(memoryStream, typeof(ActiveCodeReqPROTO));
Debug.LogError(string.Format("AccountId = {0}, ActiveCode = {1}", activeCodeReq.AccountId, activeCodeReq.ActiveCode));
}
public void DeserializeAccount()
{
IAElfSerializer serializer = new ProtobufSerializer();
/* Create account and print adress */
ProtoAccount account = new ProtoAccount();
account.PAddress = ByteString.CopyFrom(GetRandomBytes(10));
PrintBytes(account.PAddress.ToByteArray());
/* Serialize and print */
byte[] serializedAccount = serializer.Serialize(account);
PrintBytes(serializedAccount);
/* Deserialize and check address */
ProtoAccount deserializedAcc = serializer.Deserialize <ProtoAccount>(serializedAccount);
PrintBytes(deserializedAcc.PAddress.ToByteArray());
}
public void SerializeDeserializeTest()
{
var serializer = new ProtobufSerializer();
var byteArray = new RingbufferByteArray();
var item = new ServerToClientMessage();
item.Message = "hello";
item.MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted;
byteArray.Set(serializer.Serialize(item));
byte[] target = new byte[512];
byteArray.GetContent(ref target);
var deserialized = serializer.Deserialize<ServerToClientMessage>(target.Take(byteArray.ContentLength).ToArray());
Assert.IsNotNull(deserialized);
Assert.AreEqual("hello", deserialized.Message);
Assert.AreEqual(ServerToClientMessageTypeEnum.LimitOrderAccepted, deserialized.MessageType);
}
public void SerializeDeserializeTest()
{
var serializer = new ProtobufSerializer();
var byteArray = new RingbufferByteArray();
var item = new ServerToClientMessage();
item.Message = "hello";
item.MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted;
byteArray.Set(serializer.Serialize(item));
byte[] target = new byte[512];
byteArray.GetContent(ref target);
var deserialized = serializer.Deserialize <ServerToClientMessage>(target.Take(byteArray.ContentLength).ToArray());
Assert.IsNotNull(deserialized);
Assert.AreEqual("hello", deserialized.Message);
Assert.AreEqual(ServerToClientMessageTypeEnum.LimitOrderAccepted, deserialized.MessageType);
}
public void DeSerializationPerformanceTest()
{
var sw = new Stopwatch();
var serializer = new ProtobufSerializer();
var instance = new ServerToClientMessage();
var serialized = serializer.Serialize(instance);
sw.Start();
for (int i = 0; i < 5000000; i++)
{
serializer.Deserialize <ServerToClientMessage>(serialized);
}
sw.Stop();
var elapsed = sw.ElapsedMilliseconds;
double perItem = (double)elapsed / (double)5000000;
Console.WriteLine("Total ms: " + elapsed);
Console.WriteLine("Per item: " + perItem);
}
public void ProtobufSerializer_ShouldRoundTripCircularReferences()
{
var obj = new SelfReferential
{
ClassToSerialize = new ClassToSerialize
{
Name = "Bob",
Id = 100
}
};
obj.Me = obj;
var serializer = new ProtobufSerializer();
var serialized = serializer.SerializeToStream(obj);
var deserialized = serializer.Deserialize <SelfReferential>(serialized);
deserialized.ClassToSerialize.Name.ShouldEqual(obj.ClassToSerialize.Name);
deserialized.ClassToSerialize.Id.ShouldEqual(obj.ClassToSerialize.Id);
deserialized.Me.ShouldEqual(deserialized);
}
public KeyInfo GetKeyInfo(string key)
{
var keyInfo = new KeyInfo(key);
try
{
byte[] info = ByteArrayHelpers.FromHexString(key);
keyInfo.RedisValue = info;
keyInfo.KeyLength = info.Length;
ProtobufSerializer ps = new ProtobufSerializer();
Key objectKey = ps.Deserialize <Key>(info);
keyInfo.KeyObject = objectKey;
string typeStr = objectKey.Type;
keyInfo.BasicString = typeStr;
int valueLength = 0;
keyInfo.ValueInfo = ConvertKeyValue(objectKey, out valueLength);
keyInfo.ValueLength = valueLength;
if (typeStr == "Hash")
{
var hashType = (HashType)objectKey.HashType;
keyInfo.HashString = hashType.ToString();
}
else
{
keyInfo.HashString = string.Empty;
}
if (!HashList.ContainsKey(typeStr))
{
HashList.Add(typeStr, new List <KeyInfo>());
}
HashList[typeStr].Add(keyInfo);
}
catch (Exception)
{
Logger.WriteError($"Get key info exception: {key}");
}
return(keyInfo);
}
public void Coder_Test()
{
using (ProtobufSerializer serializer = new ProtobufSerializer())
{
Person person = new Person()
{
Id = 2, Name = "Jerry", Address = new Address()
};
byte[] buffer = serializer.Serialize(person);
PacketCoder coder = new PacketCoder();
byte[] _buffer = coder.Encode(buffer);
List <byte> lst = new List <byte>();
lst.AddRange(buffer);
lst.AddRange(_buffer);
lst.AddRange(_buffer);
lst.AddRange(_buffer);
lst.AddRange(buffer);
Queue <byte[]> queue = new Queue <byte[]>();
byte[] _buffer_ = lst?.ToArray();
byte[][] __buffer = coder.Decode(_buffer_, out int _);
foreach (var item in __buffer)
{
Person _person = serializer.Deserialize <Person>(item);
System.Console.WriteLine($"Id:{_person.Id},Name:{_person.Name}");
Assert.Equal(person.Id, _person.Id);
Assert.Equal(person.Name, _person.Name);
}
System.Console.WriteLine(_buffer_?.Length);
}
}
private void Test(IEnumerable <Type> messageTypes, IEnumerable <Type> identityType, params Object[] objects)
{
var map = new Dictionary <Object, byte[]>();
var messageTypeList = messageTypes.ToList();
var identityTypeList = identityType.ToList();
var messageFactory = new MessageFactory(messageTypeList);
var identityFactory = new IdentityFactory(identityTypeList);
var serializer = new ProtobufSerializer();
serializer.RegisterMessages(messageFactory.MessageDefinitions);
serializer.RegisterIdentities(identityFactory.IdentityDefinitions);
foreach (var obj in objects)
{
map[obj] = serializer.Serialize(obj);
}
// reverse order of messages and identities
messageTypeList.Reverse();
identityTypeList.Reverse();
messageFactory = new MessageFactory(messageTypeList);
identityFactory = new IdentityFactory(identityTypeList);
serializer = new ProtobufSerializer();
serializer.RegisterMessages(messageFactory.MessageDefinitions);
serializer.RegisterIdentities(identityFactory.IdentityDefinitions);
foreach (object obj in objects)
{
var back = serializer.Deserialize(map[obj], obj.GetType());
var result = ObjectComparer.AreObjectsEqual(obj, back);
Assert.That(result, Is.True);
}
}
public void ShouldSerializeAndDeserializeSeriesOfItems()
{
var serializer = new ProtobufSerializer();
for (int i = 0; i < 1000; i++)
{
var item = new ServerToClientMessage();
item.Message = i.ToString();
item.MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted;
item.LimitOrder = new LimitOrderDto();
item.LimitOrder.ClientId = i;
item.LimitOrder.ExchangeOrderId = (uint)i;
var serialized = serializer.Serialize(item);
var deserialized = serializer.Deserialize<ServerToClientMessage>(serialized);
Assert.IsNotNull(deserialized);
Assert.AreEqual(i.ToString(), deserialized.Message );
Assert.AreEqual(ServerToClientMessageTypeEnum.LimitOrderAccepted, deserialized.MessageType);
Assert.AreEqual(i, deserialized.LimitOrder.ClientId);
Assert.AreEqual(i, deserialized.LimitOrder.ExchangeOrderId);
}
}
public void ShouldSerializeAndDeserializeSeriesOfItems()
{
var serializer = new ProtobufSerializer();
for (int i = 0; i < 1000; i++)
{
var item = new ServerToClientMessage();
item.Message = i.ToString();
item.MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted;
item.LimitOrder = new LimitOrderDto();
item.LimitOrder.ClientId = i;
item.LimitOrder.ExchangeOrderId = (uint)i;
var serialized = serializer.Serialize(item);
var deserialized = serializer.Deserialize <ServerToClientMessage>(serialized);
Assert.IsNotNull(deserialized);
Assert.AreEqual(i.ToString(), deserialized.Message);
Assert.AreEqual(ServerToClientMessageTypeEnum.LimitOrderAccepted, deserialized.MessageType);
Assert.AreEqual(i, deserialized.LimitOrder.ClientId);
Assert.AreEqual(i, deserialized.LimitOrder.ExchangeOrderId);
}
}
public void ShouldSerializeServerToClientMessage()
{
var serializer = new ProtobufSerializer();
for (int i = 0; i < 1000; i++)
{
var s = serializer.Serialize(new ServerToClientMessage {MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted});
Assert.IsNotNull(s);
var d = serializer.Deserialize<ServerToClientMessage>(s);
Assert.IsNotNull(d);
}
}
private Object ConvertKeyValue(Key key, out int length)
{
string keyStr = key.ToByteArray().ToHex();
byte[] keyValue = RH.GetT <byte[]>(keyStr);
length = keyValue.Length;
ProtobufSerializer ps = new ProtobufSerializer();
string keyType = key.Type;
Object returnObj = new Object();
switch (keyType)
{
case "UInt64Value":
returnObj = ps.Deserialize <UInt64Value>(keyValue);
break;
case "Hash":
returnObj = ps.Deserialize <Hash>(keyValue);
break;
case "BlockBody":
returnObj = ps.Deserialize <BlockBody>(keyValue);
break;
case "BlockHeader":
returnObj = ps.Deserialize <BlockHeader>(keyValue);
break;
case "Chain":
returnObj = ps.Deserialize <Chain>(keyValue);
break;
case "Change":
break;
case "SmartContractRegistration":
returnObj = ps.Deserialize <SmartContractRegistration>(keyValue);
break;
case "TransactionResult":
returnObj = ps.Deserialize <TransactionResult>(keyValue);
break;
case "Transaction":
returnObj = ps.Deserialize <Transaction>(keyValue);
break;
case "FunctionMetadata":
returnObj = ps.Deserialize <FunctionMetadata>(keyValue);
break;
case "SerializedCallGraph":
returnObj = ps.Deserialize <SerializedCallGraph>(keyValue);
break;
case "WorldState":
returnObj = ps.Deserialize <WorldState>(keyValue);
break;
case "Miners":
returnObj = ps.Deserialize <Miners>(keyValue);
break;
case "BlockProducer":
returnObj = ps.Deserialize <BlockProducer>(keyValue);
break;
case "Round":
returnObj = ps.Deserialize <Round>(keyValue);
break;
case "AElfDPoSInformation":
returnObj = ps.Deserialize <AElfDPoSInformation>(keyValue);
break;
case "Int32Value":
returnObj = ps.Deserialize <Int32Value>(keyValue);
break;
case "StringValue":
returnObj = ps.Deserialize <StringValue>(keyValue);
break;
case "Timestamp":
returnObj = ps.Deserialize <Timestamp>(keyValue);
break;
case "SInt32Value":
returnObj = ps.Deserialize <SInt32Value>(keyValue);
break;
default:
break;
}
return(returnObj);
}
private void ReadComplete(IAsyncResult ar)
{
int bytesRead;
try
{
lock (m_stream)
{
bytesRead = m_stream.EndRead(ar);
}
int readIdx = 0;
while (true)
{
Int16 msgLen = BitConverter.ToInt16(GetBuff(m_buff, readIdx, 2), 0);
Int16 msgId = BitConverter.ToInt16(GetBuff(m_buff, readIdx + 2, 2), 0);
if (msgLen + readIdx >= bytesRead)
{
break;
}
string msgKey = NetIDContainer.GetMessageKey(msgId);
if (!msgLogIgnor.Contains(msgKey))
{
Debug.Log("=======接收ID: " + msgId + " key:" + msgKey);
}
MemoryStream msgStream = new MemoryStream();
msgStream.Write(m_buff, readIdx + 4, msgLen - 2);
msgStream.Position = 0;
Type type = Assembly.GetAssembly(typeof(MsgMsgInit)).GetType("Snake3D." + msgKey, true);
if (null == type)
{
Debug.Log("没有类名是： Snake3D." + msgKey + "的类！");
return;
}
ProtobufSerializer serializer = new ProtobufSerializer();
object msg = serializer.Deserialize(msgStream, null, type);
InvokeCallback(msgKey, msg);
if ("MsgError" == msgKey)
{
MsgError err = msg as MsgError;
Debug.Log("========MsgError=======" + err.ErrorIdx);
}
readIdx += msgLen + 2;
if (readIdx == bytesRead)
{
break;
}
}
Array.Clear(m_buff, 0, m_buff.Length); // 清空缓存，避免脏读
lock (m_stream)
{
AsyncCallback callBack = new AsyncCallback(ReadComplete);
m_stream.BeginRead(m_buff, 0, BUFF_SIZE, callBack, null);
}
}
catch (Exception ex)
{
if (m_stream != null)
{
m_stream.Dispose();
}
m_tcpClient.Close();
}
}
public static void ProtobufTest(int seed)
{
ProtobufSerializer serializer = new ProtobufSerializer();
Mall mall = new Mall() { ID = 1, Name = "大悦城", GroupID = 135 };
Stopwatch sw = new Stopwatch();
byte[] data = null;
sw.Restart();
for (var i = 0; i < seed; i++)
{
data = serializer.Serialize(mall);
}
sw.Stop();
Console.WriteLine("ProtobufTest Serialize:{0}ms", sw.ElapsedMilliseconds);
SpinWait.SpinUntil(() => false, 500);
sw.Restart();
for (var i = 0; i < seed; i++)
{
mall = serializer.Deserialize<Mall>(data);
}
sw.Stop();
Console.WriteLine("ProtobufTest Deserialize:{0}ms", sw.ElapsedMilliseconds);
}
