I have a json object that I need to post to a gateway. It looks as follows.
{
"client_id": "test",
"non_personalized_ads": false,
"events": [
{
"name": "test",
"params": {
"items": [
{
"itemitem1": "itemitem1value",
"itemitem1number": 1
}
],
"stringparm1": "stringValue1",
"intparm1": 1
}
}
]
}
I am trying to create this as a object class in my C# project. The issue is that both the names of these parms are configurable. So none of these are static property names.
"itemitem1": "itemitem1value",
"itemitem1number": 1
"stringparm1": "stringValue1",
"intparm1": 1
So in an attempt to achieve that I went with a Dictionary<string, object> as the value can be a number or a string I went with an Object.
public class EventParameter
{
public Dictionary<string, object> Parameters { get; set; }
public Dictionary<string, object> Items { get; set; }
public EventParameter()
{
Parameters = new Dictionary<string, object>();
Items = new Dictionary<string, object>();
}
public void AddEventParameter(string name, object value)
{
Parameters.Add(name, value);
}
}
unfortunately when I do a json pars on this I get. Which is incorrect as my Parameters should be under parms and not under their own object.
{
"client_id": "test",
"non_personalized_ads": false,
"events": [
{
"name": "hit_event",
"params": {
"Parameters": {
"TestString": "test",
"testInt": 1
},
"Items": {
"test": 1,
"test2": 1,
"test3": "test"
}
}
}
]
}
So how do i get Parameters moved up to parms? It feels like parms needs to be a Dictionary<string, object> but then its going to be missing its items list
"Parameters": {
"TestString": "test",
"testInt": 1
},
Im assuming there's something missing in my model design. I have been looking at this too long i cant come up with the solution. My other idea was could this be done by adding a custom json sterilizer?
Let me know if you want my full model design or the unit test I am using to test with.
unit test
[Fact]
public void Test1()
{
var postData = new Event() { Name = "EventName" };
postData.EventParameters.AddEventParameter("TestString", "test");
postData.EventParameters.AddEventParameter("testInt", 1);
postData.EventParameters.Items = new Dictionary<string, object>()
{
{ "test", 1 },
{ "test2", 1 },
{ "test3", "test" },
};
var data = new EventData()
{
ClientId = "test",
Events = new []
{
postData
}
};
var options = new JsonSerializerOptions { IgnoreNullValues = true };
var hold =JsonSerializer.Serialize(data);
// add breakpoint here
int i = 1;
}
Here's a class that serialises to the first json you showed:
class X
{
public string client_id {get; set;}
public bool non_personalized_ads {get; set;}
public List<EventParameter> events { get;set;}
}
class EventParameter {
public string name {get; set;}
public Dictionary<string, object> #params {get; set;}
}
Test code:
var x = new X
{
client_id = "test",
non_personalized_ads = false,
events = new List<EventParameter>{
new EventParameter
{
name = "test1",
#params = new Dictionary<string, object>{
{ "items", new Dictionary<string, object> {
{"itemitem1", "itemitem1value"},
{"itemitem1number", 1}
}},
{ "stringparm1", "stringValue1"},
{"intparm1", 1}
}
}
}
};
var json = System.Text.Json.JsonSerializer.Serialize(x, options: new System.Text.Json.JsonSerializerOptions{WriteIndented = true});
Console.WriteLine(json);
Related
I have the following minimal example:
class Program
{
static void Main()
{
var plan = new Plan
{
Steps =
{
new Step
{
Contexts =
{
new Context
{
Name = "1"
},
new Context
{
Name = "2"
}
}
}
}
};
var settings = new JsonSerializerSettings
{ PreserveReferencesHandling = PreserveReferencesHandling.Objects, Formatting = Formatting.Indented };
var json = JsonConvert.SerializeObject(plan, settings);
var deserialized = JsonConvert.DeserializeObject<Plan>(json, settings);
}
}
class Plan
{
public IEnumerable AllContexts => Steps.SelectMany(i => i.Contexts);
[JsonProperty(Order = int.MaxValue)]
public ICollection<Step> Steps { get; set; } = new List<Step>();
}
class Step
{
public ICollection<Context> Contexts { get; set; } = new List<Context>();
}
class Context
{
public string Name { get; set; }
}
In this example deserialized has lost its references upon deserialization and deserialized.AllContexts is a collection of 2 null values.
I can get this working by changing [JsonProperty(Order = int.MaxValue)] to [JsonProperty(Order = int.MinValue)] so the Steps are serialized first - but in my scenario I want the actual JSON to have all its properties on the flat AllContexts array and for the Steps to only have $refs like this:
{
"$id": "1",
"AllContexts": [
{
"$id": "2",
"Name": "1"
},
{
"$id": "3",
"Name": "2"
}
],
"Steps": [
{
"$id": "4",
"Contexts": [
{
"$ref": "2"
},
{
"$ref": "3"
}
]
}
]
}
This seems like a bug in JSON .NET - is there a way to work around it?
I am comparing two json objects using JsonDiffPatch.Diff() method and I get the below JSON Structure:
{
"complexity": {
"_t": "a",
"0": {
"phases": {
"_t": "a",
"0": {
"activities": {
"_t": "a",
"_0": [
{
"name": "NAME",
"sortId": 15,
"isCritical": true,
"url": "https://google.com",
"processGroupName": "pgm",
"isDeliverable": "no"
},
0,
0
]
}
}
}
},
"3": {
"phases": {
"_t": "a",
"0": {
"sortId": [
55,
0,
0
]
},
"1": {
"activities": {
"_t": "a",
"_0": [
{
"name": "SName",
"sortId": 12,
"isCritical": false,
"url": "https://google.com",
"processGroupName": "pgm",
"isDeliverable": "Yes"
},
0,
0
]
}
}
}
}
}
}
The result that I want is an object containing List of Phases which contains List of Activities. As per the above JSON I want:
0[Phases and Related Activities]
3[Phases and Related Activities]
I have written the below code:
List<JToken> tokens = diffJson.Children().Children().ToList();
foreach (var token in tokens)
{
//Console.WriteLine(token.ToJson());
var phases = token["0"].Children().Children();
Console.WriteLine(phases.Count());
var activities = phases["0"].Children().Children();
Console.WriteLine();
}
But this will only be for the first set which is for "complexity"["0"]. But how to get the data into an object which contains List.
I have tried the below code also:
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic item = serializer.Deserialize<object>(output);
Could anybody help me out in understanding how to Deserialize this complex JSON into simple objects?
I am thinking I will ignore "_t":"a" object under phases and start reading activities(again ignoring "_t": "a" object). Let me see how successful I will be.
Expected Output will be creating objects of below classes:
using System;
using System.Generic;
public class Difference {
public List<Phase> Phases { get; set; }
}
public class Phase {
//For other properties like sortID
public List<Dictionary<string, string>> Properties { get; set; }
public List<Activity> Activites { get; set; }
}
public class Activity {
public string name { get; set; }
public int sortId { get; set; }
public bool isCritical { get; set; }
public string url { get; set; }
public string processGroupName { get; set; }
public string isDeliverable { get; set; }
}
Below is the code which partially works:
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic item = serializer.Deserialize<object>(output);
foreach (KeyValuePair<string, dynamic> complexity in item["complexity"])
{
if (complexity.Key != "_t")
{
foreach (KeyValuePair<string, dynamic> phases in complexity.Value["phases"])
{
if (phases.Key != "_t")
foreach (KeyValuePair<string, dynamic> activities in phases.Value["activities"])
{
Console.WriteLine(activities.Value);
}
}
}
}
But this loop breaks when simple key value like sortId comes into picture.
Thanks in Advance.
As per what you have mentioned in the comment on #MarcoSalemo's answer i have modified the Sample Json to suit your requirement the Json now consists of 3 sub documents and 2 with 1 activity each sub-document except for the last one which has 2 activities and a properties object as sortId :
Sample JSON:
var jsonString = #"{
'complexity': {
'_t': 'a',
'0': {
'phases': {
'_t': 'a',
'0': {
'activities': {
'_t': 'a',
'_0': [
{
'name': 'NAME',
'sortId': 15,
'isCritical': true,
'url': 'https://google.com',
'processGroupName': 'pgm',
'isDeliverable': 'no'
},
0,
0
]
}
}
}
},
'1': {
'phases': {
'_t': 'a',
'0': {
'activities': {
'_t': 'a',
'_0': [
{
'name': 'NAME1',
'sortId': 155,
'isCritical': true,
'url': 'https://google.com',
'processGroupName': 'pgm',
'isDeliverable': 'no'
},
0,
0
]
}
}
}
},
'3': {
'phases': {
'_t': 'a',
'0': {
'sortId': [
55,
0,
0
]
},
'1': {
'activities': {
'_t': 'a',
'_0': [
{
'name': 'SName',
'sortId': 12,
'isCritical': false,
'url': 'https://google.com',
'processGroupName': 'pgm',
'isDeliverable': 'Yes'
},
0,
0
],
'_1': [
{
'name': 'SName1',
'sortId': 123,
'isCritical': false,
'url': 'https://google.com',
'processGroupName': 'pgm',
'isDeliverable': 'Yes'
},
0,
0
]
}
}
}
}
}
}";
And the deserialization is achieved as:
var jobj = JObject.Parse(jsonString);
List<Phase> Phases = new List<Phase>();
var complexity = jobj.SelectToken("complexity");
var childrens = complexity.Children().ToList();
for (int i = 1; i < childrens.Count; i++)
{
var activities = new List<Activity>();
var _properties = new List<Dictionary<string, string>>();
var child = childrens[i].Children();//getting all the sub-documets in the json
foreach (var subChild in child)
{
var phases = subChild.SelectToken("phases").Children().ToList();//getting JTokens having key "phases"
for (int j = 1; j < phases.Count; j++)
{
var phaseResult = phases[j].Children().ToList(); //getting all the children of the //phases JToken and itterating over them
foreach (var item in phaseResult)
{
if (item["activities"] != null) //producing the "Activity(s)" object
{
var acts = item.SelectToken("activities").Children().ToList();
for (int k = 1; k < acts.Count; k++)
{
var act = acts[k].Children().ToList();
foreach (var entity in act)
{
var jarvalue = JArray.Parse(entity.ToString()).Children().ToArray()[0].ToString();
var objAct = JsonConvert.DeserializeObject<Activity>(jarvalue);
activities.Add(objAct);
}
}
}
else
{
//if not Activity object than producing Properties object
var _props = item.Children<JToken>().ToList();
var nProeprties = new Dictionary<string, string>();
foreach (var content in _props)
{
var _contentProp = ((Newtonsoft.Json.Linq.JProperty)content); //converting the property object of JtokenType to JProperty to get the Name and JValue
nProeprties.Add(_contentProp.Name, _contentProp.Value.ToString());
}
_properties.Add(nProeprties);
}
}
}
}
Phases.Add(new Phase { Activites = activities, Properties = _properties });//appending the extracted output to the mail object "Phases"
}
As per the above sample json, the serialized output would be something like this:
JsonConvert.SerializeObject(Phases);
[
{
"Properties":[
],
"Activites":[
{
"name":"NAME",
"sortId":15,
"isCritical":true,
"url":"https://google.com",
"processGroupName":"pgm",
"isDeliverable":"no"
}
]
},
{
"Properties":[
],
"Activites":[
{
"name":"NAME1",
"sortId":155,
"isCritical":true,
"url":"https://google.com",
"processGroupName":"pgm",
"isDeliverable":"no"
}
]
},
{
"Properties":[
{
"sortId":"[\r\n 55,\r\n 0,\r\n 0\r\n]"
}
],
"Activites":[
{
"name":"SName",
"sortId":12,
"isCritical":false,
"url":"https://google.com",
"processGroupName":"pgm",
"isDeliverable":"Yes"
},
{
"name":"SName1",
"sortId":123,
"isCritical":false,
"url":"https://google.com",
"processGroupName":"pgm",
"isDeliverable":"Yes"
}
]
}
]
Note:
I am using Newtonsoft.Json to serialize/deserialize the json.
This is just a simple approach there can be many(Even better) to achieve what you want. So, please test it out with your data and let me know if it needs a modification.
Use dynamic and deserialize the json with JSON.NET
Is it possible, using Newtonsoft Json.NET, to use one of the properties of a class that is being serialised (via a collection) as the key for that class?
For example, take the following classes in C#
public class MyClass
{
public string UniqueId { get; set; }
public string Value { get; set; }
}
public class MyCollection : List<MyClass>
{ }
If I run the following to serialise the collection...
var col = new MyCollection() {
new MyClass { UniqueId = "First", Value = "This") },
new MyClass { UniqueId = "Second", Value = "That") }
};
string json = JsonConvert.SerializeObject(col);
This will result in the following JSON, with an array containing each MyClass.
[
{
"UniqueId": "First",
"Value": "This"
},
{
"UniqueId": "Second",
"Value": "That"
}
]
Is there any way to force Newtonsoft to create the following instead, where an object (rather than array) is created with each class referenced by the UniqueId property as the key?
{
"First":
{
"Value": "This"
},
"Second":
{
"Value": "That"
}
}
Or if easier...
{
"First":
{
"UniqueId": "First",
"Value": "This"
},
"Second":
{
"UniqueId": "Second",
"Value": "That"
}
}
I'm aware that using a Dictionary<> will result in what I want, by using the same value from the property as the key... however, this is unordered and I need the List<> so it's in order.
An OrderedDictionary can be used to keep the order of the items added, or a SortedDictionary in order to sort the items by key.
Given the following model:
public class MyClass
{
public string UniqueId { get; set; }
public string Value { get; set; }
}
And the following instances:
var first = new MyClass {UniqueId = "First", Value = "This"};
var second = new MyClass {UniqueId = "Second", Value = "That"};
var third = new MyClass {UniqueId = "Third", Value = "Foo"};
var fourth = new MyClass {UniqueId = "Fourth", Value = "Bar"};
Using an OrderedDictionary
var dictionary = new OrderedDictionary()
{
{ first.UniqueId, first },
{ second.UniqueId, second },
{ third.UniqueId, first },
{ fourth.UniqueId, first },
};
string json = JsonConvert.SerializeObject(dictionary, Formatting.Indented);
This will keep the order of the added items. Output json is the following:
{
"First": {
"UniqueId": "First",
"Value": "This"
},
"Second": {
"UniqueId": "Second",
"Value": "That"
},
"Third": {
"UniqueId": "First",
"Value": "This"
},
"Fourth": {
"UniqueId": "First",
"Value": "This"
}
}
Using a SortedDictionary
var first = new MyClass {UniqueId = "First", Value = "This"};
var second = new MyClass {UniqueId = "Second", Value = "That"};
var third = new MyClass {UniqueId = "Third", Value = "Foo"};
var fourth = new MyClass {UniqueId = "Fourth", Value = "Bar"};
var dictionary = new SortedDictionary<string, MyClass>
{
{ first.UniqueId, first },
{ second.UniqueId, second },
{ third.UniqueId, first },
{ fourth.UniqueId, first },
};
string json = JsonConvert.SerializeObject(dictionary, Formatting.Indented);
This will sort the items by key (Fourth is the 2nd item, not the 4th). Output json is the following:
{
"First": {
"UniqueId": "First",
"Value": "This"
},
"Fourth": {
"UniqueId": "First",
"Value": "This"
},
"Second": {
"UniqueId": "Second",
"Value": "That"
},
"Third": {
"UniqueId": "First",
"Value": "This"
}
}
A strongly-typed alternative to OrderedDictionary - use a List<KeyValuePair<key, value>> with a Dictionary.
So, given the following model:
public class MyClass
{
public string UniqueId { get; set; }
public string Value { get; set; }
}
And the following instances:
var first = new MyClass {UniqueId = "First", Value = "This"};
var second = new MyClass {UniqueId = "Second", Value = "That"};
var third = new MyClass {UniqueId = "Third", Value = "Foo"};
var fourth = new MyClass {UniqueId = "Fourth", Value = "Bar"};
Instead of creating and initializing the Dictionary like this:
var dictionary = new Dictionary<string, MyClass>
{
{ first.UniqueId, first },
{ second.UniqueId, second },
{ third.UniqueId, first },
{ fourth.UniqueId, first },
};
We can create and initialize a KeyValuePair list and then create the Dictionary:
var pairs = new List<KeyValuePair<string, MyClass>>
{
new KeyValuePair<string, MyClass>(first.UniqueId, first),
new KeyValuePair<string, MyClass>(second.UniqueId, second),
new KeyValuePair<string, MyClass>(third.UniqueId, third),
new KeyValuePair<string, MyClass>(fourth.UniqueId, fourth),
};
var dictionary = new Dictionary<string, MyClass>(pairs);
This will keep the order of the items added to the KeyValuePair list. Serializing the Dictionary:
string json = JsonConvert.SerializeObject(dictionary, Formatting.Indented);
Output json is the following:
{
"First": {
"UniqueId": "First",
"Value": "This"
},
"Second": {
"UniqueId": "Second",
"Value": "That"
},
"Third": {
"UniqueId": "Third",
"Value": "Foo"
},
"Fourth": {
"UniqueId": "Fourth",
"Value": "Bar"
}
}
I have a weirdly-made JSON that I need to deserialize.
It looks like this:
{
"Properties": [
{ "A": "aaa", "B": "bbb", "C": "ccc" },
{ "X": "xxx", "Y": "yyy" },
{ "many other": "items" }
],
"Products": [
{ "Id": 0, "PropertiesIndexes": [ 0, 1 ] },
{ "Id": 1, "PropertiesIndexes": [ 0, 1, 2 ] }
]
}
The properties array can have objects with any number and name of keys, and each product accesses the properties array through an index.
We need to store these JSON files in MongoDB, and because they can be quite huge (I'm talking several hundred Mb for a file) I need to split them (Mongo has a 16Mb limit). So, each property is a Mongo document, and each product is a Mongo document.
Because I can't just get properties in the order of insertion, we have decided to save all the properties of each product.
Here are the classes used to deserialize this data (using JSON.Net):
public class Entity {
public OrderedDictionary Properties { get; set; }
public IEnumerable<Product> Products { get; set; }
}
public class Product {
[JsonIgnore]
public Entity Entity { get; set; }
publid int Id { get; set; }
public int[] PropertiesIndexes { get; set; }
}
Now, I need to access the actual properties data directly from the product, so that a (hypothetical) resulting JSON would be like this:
{
"Products": [
{ "Id": 0,
"PropertiesData": [
{ "A": "aaa", "B": "bbb", "C": "ccc" },
{ "X": "xxx", "Y": "yyy" }
]
},
{ "Id": 1,
"PropertiesData": [
{ "A": "aaa", "B": "bbb", "C": "ccc" },
{ "X": "xxx", "Y": "yyy" },
{ "many other": "items" }
]
}
]
}
My naïve implementation is this:
// in Product
[JsonIgnore]
public IDictionary<string, object> PropertiesData {
get {
if (this.Entity != null && this.Entity.Properties != null) {
var data = new Dictionary<string, object>();
for (int i = 0; i < this.PropertiesIndexes.Length; i++) {
data.Add(
this.Entity.Properties.Cast<DictionaryEntry>().ElementAt(this.PropertiesIndexes[i]).Key.ToString(),
this.Entity.Properties[this.PropertiesIndexes[i]]);
}
return data;
}
return new Dictionary<string, object>();
}
}
but it's slow (as I said, I have huge amounts of data) and very ugly.
Back when we were using ExpandoObjects I had a nice, fast and memory-efficient yeilding method:
private IEnumerable<ExpandoObject> getPropertiesDataFromEntity() {
for (int i = 0; i < this.PropertiesIndexes.Count; i++) {
yield return this.Entity.Properties[this.PropertiesIndexes[i]];
}
}
but ExpandoObject have problems of their own in the context of our app: they are not always properly saved in Mongo, and they are not serialized by WCF without a custom serializer.
I've written something quite simple to get from your source JSON to your target JSON.
It includes 4 very simple classes.
The first two are designed to be deserialized from your source JSON:
public class Source
{
public Dictionary<string, string>[] Properties { get; set; }
public SourceProduct[] Products { get; set; }
}
public class SourceProduct
{
public int Id { get; set; }
public int[] PropertiesIndexes { get; set; }
}
The third class is the target product:
public class Product
{
private List<Dictionary<string, string>> _propertiesData = new List<Dictionary<string, string>>();
public int Id { get; set; }
public List<Dictionary<string, string>> PropertiesData { get { return _propertiesData; } }
}
And the last class is the final target, where I am translating the data from the source to target:
public class Target
{
private List<Product> _products = new List<Product>();
public IEnumerable<Product> Products { get { return _products; } }
public Target(Source source)
{
foreach(var sourceProduct in source.Products)
{
var product = new Product()
{
Id = sourceProduct.Id
};
foreach(var propertyIndex in sourceProduct.PropertiesIndexes)
{
product.PropertiesData.Add(source.Properties[propertyIndex]);
}
_products.Add(product);
}
}
}
Using these classes your client code simply becomes this:
var targetJson = JsonConvert.SerializeObject
(
new Target(JsonConvert.DeserializeObject<Source>(sourceJson))
);
How can I make Json.NET serializer to serialize instance into array of objects?
Basically I need something like this:
[
{
"name":"Page1.html",
"size":1,
"outlinks":[
"Page2.html",
"Page3.html",
"Page4.html"
]
},
{
"name":"Page2.html",
"size":2,
"outlinks":[
"Page3.html"
]
},
{
"name":"Page3.html",
"size":3,
"outlinks":[
"Page1.html",
"Page2.html",
"Page3.html",
"Page4.html"
]
},
{
"name":"Page4.html",
"size":4,
"outlinks":[]
}
]
with:
Dictionary<string, string[]> UrlsCollection = new Dictionary<string, string[]>();
List<string> OutLinks = new List<string>();
OutLinks.Add("Page2.html");
OutLinks.Add("Page3.html");
OutLinks.Add("Page4.html");
UrlsCollection.Add("Page1.html", OutLinks.ToArray());
OutLinks.Clear();
OutLinks.Add("Page3.html");
UrlsCollection.Add("Page2.html", OutLinks.ToArray());
OutLinks.Clear();
OutLinks.Add("Page1.html");
OutLinks.Add("Page2.html");
OutLinks.Add("Page3.html");
OutLinks.Add("Page4.html");
UrlsCollection.Add("Page3.html", OutLinks.ToArray());
OutLinks.Clear();
UrlsCollection.Add("Page4.html", OutLinks.ToArray());
OutLinks.Clear();
string jsonUrlsCollection = JsonConvert.SerializeObject(UrlsCollection.ToList(), Formatting.Indented);
I get:
[
{
"Key": "Page1.html",
"Value": [
"Page2.html",
"Page3.html",
"Page4.html"
]
},
{
"Key": "Page2.html",
"Value": [
"Page3.html"
]
},
{
"Key": "Page3.html",
"Value": [
"Page1.html",
"Page2.html",
"Page3.html",
"Page4.html"
]
},
{
"Key": "Page4.html",
"Value": []
}
]
There must be a way/something to get a simple JSON Object?
Modifying the solution to reflect Deblaton Jean-Philippe's suggestion in the comments.
public class UrlDef
{
public UrlDef() { outlinks = new List<string>(); }
public string name { get; set; }
public int size { get; set; }
public List<string> outlinks { get; set; }
}
List<UrlDef> UrlsCollection = new List<UrlDef>();
UrlDef urldef;
urldef = new UrlDef();
urldef.name = "Page1.html";
urldef.size = 1;
urldef.outlinks.Add("Page2.html");
urldef.outlinks.Add("Page3.html");
urldef.outlinks.Add("Page4.html");
UrlsCollection.Add(urldef);
urldef = new UrlDef();
urldef.name = "Page2.html";
urldef.size = 2;
urldef.outlinks.Add("Page3.html");
UrlsCollection.Add(urldef);
urldef = new UrlDef();
urldef.name = "Page3.html";
urldef.size = 3;
urldef.outlinks.Add("Page1.html");
urldef.outlinks.Add("Page2.html");
urldef.outlinks.Add("Page3.html");
urldef.outlinks.Add("Page4.html");
UrlsCollection.Add(urldef);
urldef = new UrlDef();
urldef.name = "Page4.html";
urldef.size = 4;
UrlsCollection.Add(urldef);
string jsonUrlsCollection = JsonConvert.SerializeObject(UrlsCollection, Formatting.Indented);
You need to serialize a list of this object
public class Url
{
public string name { get; set; }
public int size { get; set; }
public List<string> outlinks { get; set; }
}
For this answer, I used a website I often use when I know what I expect from JS, but I'm not sure of what I need to feed into the CS : http://json2csharp.com/