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));
}
}
//[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);
}
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);
}
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);
}
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);
}
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)));
}
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);
}
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);
}
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);
}
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));
}
}
public void CanSerializeSimpleObject()
{
var simple = new SimpleObject {
MyInt = 1000, MyString = "Hello World"
};
var json = NetJSON.Serialize(simple);
var simple2 = NetJSON.Deserialize <SimpleObject>(json);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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;
}
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);
}
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);
}
