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); }