コード例 #1
0
        public void Set(JiraSettings jiraSettings)
        {
            byte[]        serializedJiraSettings = _binarySerializer.Serialize <JiraSettings, JiraSettingsProtobufContract>(jiraSettings);
            EncryptedData encryptedJiraSettings  = _dataEncryptor.Encrypt(serializedJiraSettings);

            byte[] serializedEncryptedJiraSettings = _binarySerializer.Serialize <EncryptedData, EncryptedDataProtobufContract>(encryptedJiraSettings);

            _applicationStorageFolder.StoreBytes(JiraSettingsFileName, serializedEncryptedJiraSettings);
        }
コード例 #2
0
        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));
            });
        }
コード例 #3
0
        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);
            }
        }
コード例 #4
0
ファイル: NetManager.cs プロジェクト: mengtest/snake-1
    public void SendMessage(string key, object msg)
    {
        if (!connected)
        {
            Debug.LogError("没有连接到服务器!");
            return;
        }

        byte[]       buff   = null;
        MemoryStream stream = new MemoryStream();

        serializer.Serialize(stream, msg);
        buff = stream.ToArray();

        MemoryStream strm = new MemoryStream();

        byte[] msgLenBytes = System.BitConverter.GetBytes((Int16)(buff.Length + 2));
        strm.Write(msgLenBytes, 0, msgLenBytes.Length);
        byte[] msgIdBytes = System.BitConverter.GetBytes(NetIDContainer.GetMessageId(key));
        Debug.Log("=======发送:" + key);
        strm.Write(msgIdBytes, 0, msgIdBytes.Length);
        strm.Write(buff, 0, buff.Length);

        byte[] toSendBytes = strm.ToArray();
        m_stream.Write(toSendBytes, 0, toSendBytes.Length);
    }
コード例 #5
0
ファイル: AppMainTest.cs プロジェクト: tianjiuwan/demo
    private void Start()
    {
        pb.PlayerSnapShootMsg msg = new pb.PlayerSnapShootMsg();
        msg.username = "******";
        msg.playerId = 9000001;
        byte[] data = ProtobufSerializer.Serialize(msg);
        Debug.LogError("data len " + data.Length);
        ByteBuffer buffer = ByteBuffer.Allocate(1024);

        buffer.WriteShort(1001);
        buffer.WriteShort(1002);
        buffer.WriteShort(1003);
        buffer.WriteLong(10055555);
        buffer.WriteBytes(data);

        short s1 = buffer.ReadShort();
        short s2 = buffer.ReadShort();
        short s3 = buffer.ReadShort();
        long  l1 = buffer.ReadLong();

        byte[] readData = new byte[buffer.ReadableBytes()];
        buffer.ReadBytes(readData, 0, buffer.ReadableBytes());
        Debug.LogError("readData len " + readData.Length);
        pb.PlayerSnapShootMsg dmsg = ProtobufSerializer.DeSerialize <pb.PlayerSnapShootMsg>(readData);
        Debug.LogError("user name " + dmsg.username);

        //socket receive bytes
        //
    }
コード例 #6
0
        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);
        }
コード例 #7
0
        public void Serialize_Poco_NotNull()
        {
            var serializer = new ProtobufSerializer();
            var poco       = new Poco();

            var data = serializer.Serialize(poco);

            Assert.NotNull(data);
        }
コード例 #8
0
        /// <summary>
        /// 读写器层协议转换为protoBuf格式
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public static byte[] ReaderCommandToProtobuf(string[] message)
        {
            string  ms = string.Empty;
            Message ob = StringToModel.StrToModel(message);

            //   ms = ProtobufSerializer.Serialize<Message>(ob);
            ms = ProtobufSerializer.Serialize <Message>(ob);
            return(System.Text.Encoding.Unicode.GetBytes(ms));
            //   return ms;
        }
コード例 #9
0
        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));
        }
コード例 #10
0
        public void Save(Action <byte[]> done)
        {
            if (m_isBusy)
            {
                throw new InvalidOperationException("m_isBusy");
            }

            m_isBusy = true;
            m_progressIndicator.IsVisible = true;
            m_progressIndicator.SetText("Saving...");

            m_job.Submit(
                () =>
            {
                ProtobufSerializer serializer = null;
                byte[] bytes = null;
                try
                {
                    var pool = Dependencies.Serializer;
                    if (pool != null)
                    {
                        serializer = pool.Acquire();
                        bytes      = serializer.Serialize(Map);
                    }
                }
                finally
                {
                    if (serializer != null)
                    {
                        var pool = Dependencies.Serializer;
                        if (pool != null)
                        {
                            pool.Release(serializer);
                        }
                    }
                }

                return(bytes);
            },
                result =>
            {
                m_isBusy = false;
                m_progressIndicator.IsVisible = false;

                if (Saved != null)
                {
                    Saved(this, EventArgs.Empty);
                }

                if (done != null)
                {
                    done((byte[])result);
                }
            });
        }
コード例 #11
0
        virtual public void request()
        {
            ProtobufSerializer serializer = new ProtobufSerializer();

            //using (MemoryStream temp = new MemoryStream())

            serializer.Serialize(m_bytes, req);
            //m_bytes.Position = 0;

            CNetWorkGlobal.Instance.SendProto(this);
        }
コード例 #12
0
        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);
            }
        }
コード例 #13
0
        /*
         * public string RootPath
         * {
         *      get{
         #if UNITY_EDITOR
         *              string rootPath = Application.dataPath ;
         #else
         *              string rootPath = Application.persistentDataPath;
         #endif
         *              string folder = rootPath + protoPath;
         *              return folder;
         *      }
         * }
         *
         * public T LoadProtoData<T> (string name)
         * {
         *      //string md5Name = CommonUtils.GenerateMD5 (Encoding.UTF8.GetBytes (name));
         *
         *      string path = RootPath + name + ".bytes";
         *
         *      Debug.Assert(File.Exists(path),"No file at path :" + path);
         *
         *      DebugUtils.Log (DebugUtils.Type.Data, "load proto file " + name + ", path = " + path);
         *      byte[] data = File.ReadAllBytes (path);
         *      return Deserialize<T> (data);
         * }
         *
         * public void SavaProtoData (byte[] data, string fileName)
         * {
         *      Stream sw;
         *
         *      //string md5Name = CommonUtils.GenerateMD5 (Encoding.UTF8.GetBytes (fileName));
         *
         *      string folder = RootPath ;
         *      if(!Directory.Exists(folder)){
         *              Directory.CreateDirectory(folder);
         *      }
         *
         *      string path = folder + fileName + ".bytes";
         *      DebugUtils.Log (DebugUtils.Type.Data, "path: " + path + " originName : " + fileName);
         *      FileInfo f = new FileInfo (path);
         *      if (f.Exists) {
         *              f.Delete ();
         *              f = new FileInfo (path);
         *              sw = f.Create ();
         *      } else {
         *              sw = f.Create ();
         *      }
         *      sw.Write (data, 0, data.Length);
         *      sw.Close ();
         *      sw.Dispose ();
         * }
         */

        /*
         * public static byte[] Serialize<T>( T dataObject )
         * {
         *      DebugUtils.Assert( dataObject != null );
         *      byte[] buffer = null;
         *  using( MemoryStream m = new MemoryStream() ) // use a cached memory stream instead?
         *  {
         *                      Serializer.Serialize<T>( m, dataObject );
         *              m.Position = 0;
         *              int length = (int)m.Length;
         *              buffer = new byte[length];
         *              m.Read( buffer, 0, length );
         *      }
         *      return buffer;
         * }
         *
         * public static T Deserialize<T>( byte[] data )
         * {
         *      DebugUtils.Assert( data != null && data.Length > 0 );
         *      T dataObject;
         *      using( MemoryStream m = new MemoryStream( data ) )
         *  {
         *                      dataObject = Serializer.Deserialize<T>( m );
         *      }
         *      return dataObject;
         * }
         */

        public static byte[] Serialize(object dataObject)
        {
            DebugUtils.Assert(dataObject != null);
            byte[] buffer = null;
            using (MemoryStream m = new MemoryStream()) {  // use a cached memory stream instead?
                serializer.Serialize(m, dataObject);
                m.Position = 0;
                int length = (int)m.Length;
                buffer = new byte[length];
                m.Read(buffer, 0, length);
            }
            return(buffer);
        }
コード例 #14
0
        public void Serialize_Default()
        {
            var model = new Model()
            {
                Bar = 15, Foo = "foo"
            };
            IRedisSerializer protobufSerializer = new ProtobufSerializer()
            {
                CompressionFormat = CompressionFormat.None
            };
            var redisValue = protobufSerializer.Serialize(model);

            Assert.True(redisValue.HasValue);
        }
コード例 #15
0
        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")));
        }
コード例 #16
0
ファイル: Util.cs プロジェクト: SingleShadowBlade/LOE
    public static byte[] SerializeProtocol <T>(T kPB)
    {
        MemoryStream kStream = new MemoryStream();

        try
        {
            protobufSerializer.Serialize(kStream, kPB);
            return(kStream.ToArray());
        }
        catch
        {
            Debug.LogError("Can't Encode PB " + typeof(T).Name);
            return(null);
        }
    }
コード例 #17
0
        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);
        }
コード例 #18
0
        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);
            }
        }
コード例 #19
0
        public void SerializationPerformanceTest()
        {
            var sw = new Stopwatch();
            var serializer = new ProtobufSerializer();
            var instance = new ServerToClientMessage();

            sw.Start();
            for (int i = 0; i < 5000000; i++)
                serializer.Serialize(instance);

            sw.Stop();
            var elapsed = sw.ElapsedMilliseconds;

            double perItem = (double)elapsed/(double)5000000;
            Console.WriteLine("Total ms: " + elapsed);
            Console.WriteLine("Per item: " + perItem);
        }
コード例 #20
0
    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));
    }
コード例 #21
0
 public static byte[] Encode(object msg)
 {
     if (m_DicIDName.ContainsKey(msg.GetType()))
     {
         m_Stream.SetLength(0);
         m_Serializer.Serialize(m_Stream, msg);
         byte[] ret = new byte[2 + m_Stream.Length];
         int    id  = m_DicIDName[msg.GetType()];
         ret[0]            = (byte)(id >> 8);
         ret[1]            = (byte)(id);
         m_Stream.Position = 0;
         m_Stream.Read(ret, 2, ret.Length - 2);
         return(ret);
     }
     else
     {
         return(null);
     }
 }
コード例 #22
0
        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);
        }
コード例 #23
0
        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());
        }
コード例 #24
0
        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);
        }
コード例 #25
0
ファイル: Serializer.cs プロジェクト: radtek/work-1
        private static void ProtobufSerialize(object obj, Stream stream)
        {
            if (obj == null)
            {
                return;
            }

            if (obj is DataSet)
            {
                ProtobufDataSetSerializer.ProtoWrite(obj as DataSet, stream);
            }
            else if (obj is DataTable)
            {
                ProtobufDataTableSerializer.ProtoWrite(obj as DataTable, stream);
            }
            else
            {
                ProtobufSerializer.Serialize <object>(stream, obj);
            }
        }
コード例 #26
0
        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);
        }
コード例 #27
0
ファイル: UnitTest1.cs プロジェクト: kellybirr/kafka-proto
        public void Test_Untyped()
        {
            var rnd    = new Random();
            var record = new TestRecord
            {
                Id              = Guid.NewGuid().ToString(),
                Integer         = DateTime.UtcNow.Millisecond,
                Floating        = rnd.NextDouble(),
                EnumeratedValue = MyEnum.Val2,
                TextValues      =
                {
                    rnd.Next().ToString(),
                    rnd.Next().ToString(),
                    rnd.Next().ToString(),
                    rnd.Next().ToString()
                }
            };

            byte[] bytes;   // serialize to bytes
            var    ser = new ProtobufSerializer();

            bytes = ser.Serialize(record, default);

            TestRecord testing; // back to object
            var        deSer = new ProtobufDeserializer <TestRecord>();

            testing = deSer.Deserialize(bytes, false, default);

            Assert.AreEqual(record.Id, testing.Id);
            Assert.AreEqual(record.Integer, testing.Integer);
            Assert.AreEqual(record.Floating, testing.Floating);
            Assert.AreEqual(record.EnumeratedValue, testing.EnumeratedValue);

            Assert.AreEqual(record.TextValues.Count, testing.TextValues.Count);
            for (int i = 0; i < record.TextValues.Count; i++)
            {
                Assert.AreEqual(record.TextValues[i], testing.TextValues[i]);
            }
        }
コード例 #28
0
        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);
            }
        }
コード例 #29
0
        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);
            }
        }
コード例 #30
0
ファイル: AppMain.cs プロジェクト: tianjiuwan/demo
    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.V))
        {
            int   HEAD_LEN = 18;//包头长度
            short HEAD_FIX = 0x71ab;

            pb.PlayerSnapShootMsg msg = new pb.PlayerSnapShootMsg();
            msg.playerId = 80000060;
            msg.username = "******";
            byte[]     data   = ProtobufSerializer.Serialize <pb.PlayerSnapShootMsg>(msg);
            int        len    = data.Length;
            ByteBuffer buffer = ByteBuffer.Allocate(len + HEAD_LEN);
            buffer.WriteShort(HEAD_FIX);
            buffer.WriteShort((short)(HEAD_LEN + len));
            buffer.WriteShort(12001);
            buffer.WriteLong(90000001001);
            buffer.WriteInt(0);
            buffer.WriteBytes(data);
            GameSocket.Instance.Send(buffer);
            Debug.LogError("发送一条消息给服务器1");
        }
    }
コード例 #31
0
        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);
            }
        }
コード例 #32
0
        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);
            }
        }
コード例 #33
0
        public override void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
        {
            ISerializer serializer = new ProtobufSerializer();

            serializer.Serialize(value, writeStream);
        }
コード例 #34
0
ファイル: Program.cs プロジェクト: Indifer/Raven.Serializer
        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);
        }
コード例 #35
0
        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);
            }
        }