예제 #1
0
        private void WarmUpCacheForReading()
        {
            foreach (var item in this.ListForReading)
            {
                string key = item.GetFullKey();

                var hashEntries = new Dictionary <string, string>();
                var plainTexts  = new List <string>();
                foreach (var kvp in item.RemovedEntitiesByReason)
                {
                    //add fields for Reason and RemovedEntityIds
                    hashEntries.Add(kvp.Key, string.Join(",", kvp.Value));
                    // delimited
                    plainTexts.Add($"{kvp.Key}:{string.Join(",", kvp.Value)}");
                }
                this.Cache.SetAddAll(key: $"o4_set:{key}", plainTexts);
                this.Cache.StringSet(key: $"o1_delimited:{key}", string.Join("|", plainTexts));
                this.Cache.HashSet(key: $"o3_hash:{key}", hashEntries);

                //jsons
                this.Cache.JsonSet(key: $"o2_json:{key}", JsonConvert.SerializeObject(item.RemovedEntitiesByReason));
                this.Cache.JsonSet(key: $"o2_jiljson:{key}", Jil.JSON.Serialize(item.RemovedEntitiesByReason));
                this.Cache.JsonSet(key: $"o2_netjson:{key}", NetJSON.Serialize(item.RemovedEntitiesByReason));
            }
        }
예제 #2
0
        //[TestMethod]
        public void NestedGraphDoesNotThrow()
        {
            var o = new GetTopWinsResponse()
            {
                TopWins = new List <TopWinDto>()
                {
                    new TopWinDto()
                    {
                        Amount          = 1,
                        LandBasedCasino = new TopWinLandBasedCasino()
                        {
                            Location    = "Location",
                            MachineName = "Machinename"
                        },
                        Nickname     = "Nickname",
                        OnlineCasino = new TopWinOnlineCasino()
                        {
                            GameId = "GameId"
                        },
                        OnlineSports = new TopWinOnlineSports()
                        {
                            AwayTeam = "AwayTeam"
                        },
                        Timestamp = DateTime.Now,
                        Type      = TopWinType.LandBasedCasinoWin
                    }
                }
            };

            var actual = NetJSON.Serialize(o.GetType(), o);
        }
예제 #3
0
        public void SerializePolyObjects()
        {
            var graph = new Graph {
                name = "my graph"
            };

            graph.nodes = new List <Node>();
            graph.nodes.Add(new NodeA {
                number = 10f
            });
            graph.nodes.Add(new NodeB {
                text = "hello"
            });

            NetJSON.IncludeTypeInformation = true;

            var json = NetJSON.Serialize(graph, new NetJSONSettings {
                IncludeTypeInformation = true
            });
            var jgraph = NetJSON.Deserialize <Graph>(json);

            var nodeA = jgraph.nodes[0] as NodeA;
            var nodeB = jgraph.nodes[1] as NodeB;

            Assert.IsTrue(nodeA != null && nodeA.number == 10, json);
            Assert.IsTrue(nodeB != null && nodeB.text == "hello", json);
        }
예제 #4
0
        public void TestSerializeTuple()
        {
            var tuple = new Tuple <int, string>(100, "Hello World");

            var json   = NetJSON.Serialize(tuple);
            var ttuple = NetJSON.Deserialize <Tuple <int, string> >(json);
        }
예제 #5
0
        public void TestAutoDetectQuotes()
        {
            var dict = new Dictionary <string, string>();

            dict["Test"]  = "Test2";
            dict["Test2"] = "Test3";

            var list = new List <string> {
                "Test",
                "Test2"
            };

            var str = "Test";

            NetJSON.QuoteType = NetJSONQuote.Single;
            var json     = NetJSON.Serialize(dict);
            var jsonList = NetJSON.Serialize(list);
            var jsonStr  = NetJSON.Serialize(str);

            var jsonWithDouble     = json.Replace("'", "\"");
            var jsonListWithDouble = jsonList.Replace("'", "\"");
            var jsonStrWithDouble  = jsonStr.Replace("'", "\"");

            var result  = NetJSON.Deserialize <Dictionary <string, string> >(jsonWithDouble);
            var result2 = NetJSON.Deserialize <List <string> >(jsonListWithDouble);
            var result3 = NetJSON.Deserialize <string>(jsonStrWithDouble);
        }
예제 #6
0
 protected Benchmark(TObj instance)
 {
     obj = instance;
     WriteLine("NetJSON: " + NetJSON.Serialize(instance));
     WriteLine("MS JSON: " + JsonSerializer.Serialize(instance));
     WriteLine("UTFJSON: " + System.Text.Encoding.UTF8.GetString(Utf8Json.JsonSerializer.Serialize(instance)));
 }
예제 #7
0
        public void TestDictionaryWithColon()
        {
            var dict = new Dictionary <string, string>();

            dict["Test:Key"] = "Value";
            var json  = NetJSON.Serialize(dict);
            var ddict = NetJSON.Deserialize <Dictionary <string, string> >(json);
        }
예제 #8
0
 public void TestSerializeDateWithMillisecondDefaultFormatUnSpecified()
 {
     NetJSON.DateFormat     = NetJSONDateFormat.Default;
     NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Unspecified;
     var date  = new DateTime(2010, 12, 05, 1, 1, 30, 100);
     var djson = NetJSON.Serialize(date);
     var ddate = NetJSON.Deserialize <DateTime>(djson);
 }
예제 #9
0
 public void TestSerializeDateWithISOFormatUTC()
 {
     NetJSON.DateFormat     = NetJSONDateFormat.ISO;
     NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Utc;
     var date  = new DateTime(2010, 12, 05, 1, 1, 30, 99);
     var djson = NetJSON.Serialize(date);
     var ddate = NetJSON.Deserialize <DateTime>(djson);
 }
        public string Serialize(T m)
        {
            string s = NetJSON.Serialize(m, new NetJSONSettings {
                UseEnumString = false, SkipDefaultValue = false, DateFormat = NetJSONDateFormat.JsonNetISO
            });

            return(s);
        }
예제 #11
0
 public void SerializeObjectWithQuotes()
 {
     var obj = new APIQuote {
         createDate = DateTime.Now, value = "Hello world"
     };
     var json = NetJSON.Serialize(obj);
     var obj2 = NetJSON.Deserialize <APIQuote>(json);
 }
 public void O2_Set_NetJsonString()
 {
     foreach (var item in this.ListForWriting)
     {
         string key = $"o2_netjson:{item.GetFullKey()}";
         this.Cache.JsonSet <string>(key, NetJSON.Serialize(item.RemovedEntitiesByReason));
     }
 }
예제 #13
0
        public void CanSerializeSimpleObject()
        {
            var simple = new SimpleObject {
                MyInt = 1000, MyString = "Hello World"
            };

            var json    = NetJSON.Serialize(simple);
            var simple2 = NetJSON.Deserialize <SimpleObject>(json);
        }
예제 #14
0
        public void TestSerializeDateNowUtcWithISOFormatUTC()
        {
            NetJSON.DateFormat     = NetJSONDateFormat.ISO;
            NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Utc;
            var date  = DateTime.UtcNow;
            var djson = NetJSON.Serialize(date);
            var ddate = NetJSON.Deserialize <DateTime>(djson);

            Assert.IsTrue(date == ddate);
        }
예제 #15
0
        public void TestSerializeDateWithISOFormatLocal()
        {
            NetJSON.DateFormat     = NetJSONDateFormat.ISO;
            NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Local;
            var date  = DateTime.Now;
            var djson = NetJSON.Serialize(date);
            var ddate = NetJSON.Deserialize <DateTime>(djson);

            Assert.IsTrue(date == ddate);
        }
예제 #16
0
        public void TestSerializeDateWithMillisecondDefaultFormatUnSpecified()
        {
            NetJSON.DateFormat     = NetJSONDateFormat.Default;
            NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Unspecified;
            var date  = DateTime.Now;
            var djson = NetJSON.Serialize(date);
            var ddate = NetJSON.Deserialize <DateTime>(djson);

            Assert.IsTrue(date == ddate);
        }
예제 #17
0
        public void TestSerializeDateWithMillisecondDefaultFormatLocal()
        {
            NetJSON.DateFormat     = NetJSONDateFormat.Default;
            NetJSON.TimeZoneFormat = NetJSONTimeZoneFormat.Local;
            var date  = DateTime.UtcNow;
            var djson = NetJSON.Serialize(date);
            var ddate = NetJSON.Deserialize <DateTime>(djson);

            Assert.IsTrue(date == ddate);
        }
예제 #18
0
        public void CanSerializeTestData()
        {
            var data = new TestClass {
                ID = 1000, Name = "This is a test"
            };
            var json  = NetJSON.Serialize(data);
            var data2 = NetJSON.Deserialize <TestClass>(json);

            Assert.Equal(data.ID, data2.ID);
        }
예제 #19
0
        public void CanDeserialiseNullableTimespan()
        {
            var itm          = new TimeSpan(1500);
            var testObj      = new NullableTestType <TimeSpan>(itm);
            var serialised   = NetJSON.Serialize(testObj);
            var deserialised = NetJSON.Deserialize <NullableTestType <TimeSpan> >(serialised);

            Assert.IsNotNull(deserialised);
            Assert.IsNotNull(deserialised.TestItem);
            Assert.AreEqual(testObj.TestItem.Value, itm);
        }
예제 #20
0
        public void TestNetJSONProperty()
        {
            NetJSON.IncludeFields = true;

            var sample = new SampleSubstitionClass {
                ID = 100, Name = "Test Property", Number = 504
            };

            var json  = NetJSON.Serialize(sample);
            var sData = NetJSON.Deserialize <SampleSubstitionClass>(json);
        }
예제 #21
0
        public void CanDeserialiseNullableDateTime()
        {
            var itm          = new DateTime(2015, 12, 15);
            var testObj      = new NullableTestType <DateTime>(itm);
            var serialised   = NetJSON.Serialize(testObj);
            var deserialised = NetJSON.Deserialize <NullableTestType <DateTime> >(serialised);

            Assert.IsNotNull(deserialised);
            Assert.IsNotNull(deserialised.TestItem);
            Assert.AreEqual(testObj.TestItem.Value, itm);
        }
예제 #22
0
        public void TestEnumInDictionaryObject()
        {
            var dict = new Dictionary <string, object>();

            dict["Test"] = MyEnumTest.Test2;
            dict["Text"] = "Hello World";

            NetJSON.UseEnumString = true;

            var json = NetJSON.Serialize(dict);
        }
예제 #23
0
        public void TestStructWithFields()
        {
            var data = new StructWithFields {
                x = 10, y = 2
            };
            var json  = NetJSON.Serialize(data);
            var data2 = NetJSON.Deserialize <StructWithFields>(json);

            Assert.AreEqual(data.x, data.x);
            Assert.AreEqual(data.y, data.y);
        }
예제 #24
0
        public void TestSerializeComplexTuple()
        {
            var tuple = new Tuple <int, DateTime, string,
                                   Tuple <double, List <string> > >(1, DateTime.Now, "xisbound",
                                                                    new Tuple <double, List <string> >(45.45, new List <string> {
                "hi", "man"
            }));

            var json   = NetJSON.Serialize(tuple);
            var ttuple = NetJSON.Deserialize <Tuple <int, DateTime, string, Tuple <double, List <string> > > >(json);
        }
예제 #25
0
        public void CanDeserialiseNullableGuid()
        {
            var itm          = new Guid("10b5a72b-815f-4e64-90bf-cb250840e989");
            var testObj      = new NullableTestType <Guid>(itm);
            var serialised   = NetJSON.Serialize(testObj);
            var deserialised = NetJSON.Deserialize <NullableTestType <Guid> >(serialised);

            Assert.IsNotNull(deserialised);
            Assert.IsNotNull(deserialised.TestItem);
            Assert.AreEqual(testObj.TestItem.Value, itm);
        }
예제 #26
0
        public void SerializeDateTimeOffSet()
        {
            var settings = new NetJSONSettings {
                TimeZoneFormat = NetJSONTimeZoneFormat.Local, DateFormat = NetJSONDateFormat.ISO
            };
            var dateTimeOffset = new DateTimeOffset(DateTime.Now);
            var json           = NetJSON.Serialize(dateTimeOffset, settings);

            var dateTimeOffset2 = NetJSON.Deserialize <DateTimeOffset>(json, settings);

            Assert.AreEqual(dateTimeOffset, dateTimeOffset2);
        }
예제 #27
0
        public void TestSerializeAlwaysContainsQuotesEvenAfterBeenSerializedInDifferentThreads()
        {
            var api = new APIQuote {
                value = "Test"
            };
            var json  = NetJSON.Serialize(api);
            var json2 = string.Empty;

            Task.Run(() => {
                json2 = NetJSON.Serialize(api);
            }).Wait();
            Assert.IsTrue(json.Equals(json2), json2);
        }
예제 #28
0
        public void CanSerializeMccUserDataObject()
        {
            var obj = new MccUserData()
            {
                arr = new int?[] { 10, null, 20 }
            };

            NetJSON.IncludeFields = true;

            var json = NetJSON.Serialize(obj);
            //var mjson = NetJSON.Deserialize<MccUserData>(json);
            //var r = mjson.arr.Length;
        }
예제 #29
0
        public void TestDateTimeFormat()
        {
            var json  = "{\"DateTimeValue\":\"\\/Date(1447003080000+0200)\\/\"}";
            var json2 = "{\"DateTimeValue\":\"2015-11-08T19:18:00+02:00\"}";

            NetJSON.DateFormat = NetJSONDateFormat.Default;
            var obj  = NetJSON.Deserialize <TestDateTimeFormatting>(json);
            var sobj = NetJSON.Serialize(obj);

            NetJSON.DateFormat = NetJSONDateFormat.JsonNetISO;
            var obj2  = NetJSON.Deserialize <TestDateTimeFormatting>(json2);
            var sobj2 = NetJSON.Serialize(obj2);
        }
예제 #30
0
        public void TestSerializeTypeClass()
        {
            var type  = typeof(String);
            var value = NetJSON.Serialize(type);

            var typeType = NetJSON.Deserialize <Type>(value);

            var typeHolder = new TypeHolder {
                Type = typeof(int)
            };
            var valueHolder = NetJSON.Serialize(typeHolder);

            var typeHolderType = NetJSON.Deserialize <TypeHolder>(valueHolder);
        }