EXAMPLE: when you want to return an object in Json, you can create the object like this:
Json(new { NameIWant= myProperty});
But in my dynamic list goes like this...
List<dynamic> list = new List<dynamic>();
var propertyName1 = 1000;
list.Add(number1);
var propertyName2 = 2000;
list.Add(number1);
This only contains the amount but I would like to add a name so my object in position [0] and position 1 are named:
propertyName1 = 1000,
propertyName2 =2000
Right now my list looks like this:
In other words I want to display a Name next to the [0] and 1 so when I call them I don't use their position and I'll use their name instead.
There is quite a few options available. Below some of them:
var propertyName1 = 1000;
var propertyName2 = 2000;
// List of key value pairs
var myList = new List<KeyValuePair<string, int>>();
myList.Add(new KeyValuePair<string, int>(nameof(propertyName1), propertyName1));
myList.Add(new KeyValuePair<string, int>(nameof(propertyName2), propertyName2));
// Dictionary
var myDict = new Dictionary<string, int>();
myDict[nameof(propertyName1)] = propertyName1;
myDict[nameof(propertyName2)] = propertyName2;
// List of tuples
var myTupleList = new List<Tuple<string, int>>();
myTupleList.Add(new Tuple<string, int>(nameof(propertyName1), propertyName1));
myTupleList.Add(new Tuple<string, int>(nameof(propertyName2), propertyName2));
All examples are using strongly typed collections but it will work with dynamic too. Though, unless there is a very good reason I would stay with strongly typed collections.
The solution was as simple as this, I knew it was similar to creating a Json object :)
list.Add( new { NameOfProperty= Value });
I am using a Database to save Json Structure and Values. Using Testdata the Structure as Dictionary would look similar to this:
Dictionary<string, string> input = new Dictionary<string, string>();
input.Add("application.shortName", "TestShortName");
input.Add("application.longName", "TestLongName");
input.Add("application.description", "TestDescription");
input.Add("application.deepNode.evenDeeperNode", "Values so deep, you can see Adelle rolling");
input.Add("common.yes", "YesTest");
input.Add("common.no", "NoTest");
input.Add("common.save", "SaveTest");
input.Add("common.pager.pagesLenghtBefore", "LengthTestDeepNode");
I never know the names that come from the Database so it could be any name for the key and any depth indicated by a dot something like: "key1.key2.keyN".
Now I want to serialize every key and value I get from the database into Json. With the Testdata from above it would look like this:
{
"application": {
"shortName": "TestShortName",
"longName": "TestLongName",
"description": "TestDescription",
"deepNode": {
"evenDeeperNode": "Values so deep, you can see Adelle rolling"
},
"common": {
"yes": "YesTest",
"no": "NoTest",
"save": "SaveTest",
"pager": {
"pagesLengthBefore": "LengthTestDeepNode"
}
}
}
}
I'm using JSON.NET but I barely scratched the surface and don't know if there is a Method for this. I know I can convert Dictionaries to Json but because of the unknown depth of my keys, that isn't directly possible. I tried to come up with a loop that splits the keys and adds values to the last splitted node, though I was never able to actually program something like that.
I hope this doesn't seem like an inappropriate question but I really need help with this. I appreciate any tips in the right direction. Thanks in advance
Instead of Dictionary you can use dynamic object, like:
var input = new {application = new {shortName = "TestShortName",
longName = "TestLongName"
....},
common = new {yes = "YesTest",
..........}
}
Or using ExpandoObject:
dynamic input = new System.Dynamic.ExpandoObject();
input.application = new System.Dynamic.ExpandoObject();
input.application.shortName = "TestShortName"
input.application.longName = "TestLongName"
.
.
.
input.application.deepNode.evenDeeperNode = "Values so deep, you can see Adelle rolling"
If you need to convert dictionary to json, then following snippet will do it for you:
var input = new Dictionary<string, string>();
input.Add("application.shortName", "TestShortName");
input.Add("application.longName", "TestLongName");
input.Add("application.description", "TestDescription");
input.Add("application.deepNode.evenDeeperNode", "Values so deep, you can see Adelle rolling");
input.Add("common.yes", "YesTest");
input.Add("common.no", "NoTest");
input.Add("common.save", "SaveTest");
input.Add("common.pager.pagesLenghtBefore", "LengthTestDeepNode");
var res = new Dictionary<string, Object>();
foreach(var pair in input)
{
var key = pair.Key;
var parts = key.Split('.');
var currentObj = res;
for (int i = 0; i < parts.Length-1; i++)
{
var property = parts[i];
if (!currentObj.Keys.Contains(property))
currentObj[property] = new Dictionary<string, Object>();
currentObj = (new Dictionary<string, Object>())currentObj[property];
}
currentObj[parts[parts.Length - 1]] = pair.Value;
}
var json = JsonConvert.SerializeObject(res, Formatting.Indented);
I need to get currency values list in C# from here:
http://openexchangerates.org/currencies.json
which produces this kind of output:
{
"AED": "United Arab Emirates Dirham",
"AFN": "Afghan Afghani",
"ALL": "Albanian Lek",
"AMD": "Armenian Dram",
"ANG": "Netherlands Antillean Guilder",
"AOA": "Angolan Kwanza"
// and so on
}
I managed to get a string containing values above using C#, but I cannot find a way to deserialize that string into any custom class or anonymous object, so I am wondering how to do that?
Also, I am trying to use Json.NET to do that, but so far couldn't find a solution...
using Json.Net
var dict = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonString);
--EDIT--
You can make it shorter
WebClient w = new WebClient();
string url = "http://openexchangerates.org/currencies.json";
var dict = JsonConvert.DeserializeObject<Dictionary<string, string>>(w.DownloadString(url));
A solution using only .Net 4.0 and no third party libraries:
string url = "http://openexchangerates.org/currencies.json";
var client = new System.Net.WebClient();
string curStr = client.DownloadString(url);
var js = new System.Web.Script.Serialization.JavaScriptSerializer();
var res = (js.DeserializeObject(curStr) as Dictionary<string, object>)
.Select(x => new { CurKey = x.Key, Currency = x.Value.ToString() });
Outputs a list of anonymous objects with the keys and values from the list as properties.
Enjoy :)
How to use fastJSON (or some other JSON lib, possibly) to dump some data into a dictionary format, e.g. {"key1": "valstring", "key2": 1234}?
If I try to dump Dictionary<string, Object> I get something like [{"k":"key1","v":"valstring"},{"k":"key2","v":1234}] instead.
We use Json.NET at our office. We send json objects between python and C#. We ran into the same problem, though ours was just the differences in how the languages naturally serialized it.
The best part about it, if I'm remember correctly, is that it had this behavior right out of the box.
var dict = new Dictionary<string, string>();
dict.Add("key", "val");
dict.Add("key2", "val2");
string json = JsonConvert.SerializeObject(dict);
Json should equal { "key": "val", "key2": "val2" }
You just can use JavaScriptSerializer to create your solution, it's native for .Net.
var dict = new Dictionary<string, string>();
dict.Add("key", "val");
dict.Add("key2", "val2");
var serializer = new JavaScriptSerializer();
string json = serializer.Serialize(dict);
And you'l get result you are expected: {"key1": "valstring", "key2": 1234}
(fastJSON) You need use some parameters parameters:
_jsonParameters = new JSONParameters
{
EnableAnonymousTypes = true,
SerializeToLowerCaseNames = true,
UseFastGuid = false,
KVStyleStringDictionary = false <---- THIS
};
}
JSON.ToJSON(obj, _jsonParameters)
I want to convert my Dictionary<int,List<int>> to JSON string. Does anyone know how to achieve this in C#?
This answer mentions Json.NET but stops short of telling you how you can use Json.NET to serialize a dictionary:
return JsonConvert.SerializeObject( myDictionary );
As opposed to JavaScriptSerializer, myDictionary does not have to be a dictionary of type <string, string> for JsonConvert to work.
Serializing data structures containing only numeric or boolean values is fairly straightforward. If you don't have much to serialize, you can write a method for your specific type.
For a Dictionary<int, List<int>> as you have specified, you can use Linq:
string MyDictionaryToJson(Dictionary<int, List<int>> dict)
{
var entries = dict.Select(d =>
string.Format("\"{0}\": [{1}]", d.Key, string.Join(",", d.Value)));
return "{" + string.Join(",", entries) + "}";
}
But, if you are serializing several different classes, or more complex data structures, or especially if your data contains string values, you would be better off using a reputable JSON library that already knows how to handle things like escape characters and line breaks. Json.NET is a popular option.
Json.NET probably serializes C# dictionaries adequately now, but when the OP originally posted this question, many MVC developers may have been using the JavaScriptSerializer class because that was the default option out of the box.
If you're working on a legacy project (MVC 1 or MVC 2), and you can't use Json.NET, I recommend that you use a List<KeyValuePair<K,V>> instead of a Dictionary<K,V>>. The legacy JavaScriptSerializer class will serialize this type just fine, but it will have problems with a dictionary.
Documentation: Serializing Collections with Json.NET
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Json;
using System.IO;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Dictionary<int, List<int>> foo = new Dictionary<int, List<int>>();
foo.Add(1, new List<int>( new int[] { 1, 2, 3, 4 }));
foo.Add(2, new List<int>(new int[] { 2, 3, 4, 1 }));
foo.Add(3, new List<int>(new int[] { 3, 4, 1, 2 }));
foo.Add(4, new List<int>(new int[] { 4, 1, 2, 3 }));
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Dictionary<int, List<int>>));
using (MemoryStream ms = new MemoryStream())
{
serializer.WriteObject(ms, foo);
Console.WriteLine(Encoding.Default.GetString(ms.ToArray()));
}
}
}
}
This will write to the console:
[{\"Key\":1,\"Value\":[1,2,3,4]},{\"Key\":2,\"Value\":[2,3,4,1]},{\"Key\":3,\"Value\":[3,4,1,2]},{\"Key\":4,\"Value\":[4,1,2,3]}]
Simple One-Line Answer
(using System.Web.Script.Serialization )
This code will convert any Dictionary<Key,Value> to Dictionary<string,string> and then serialize it as a JSON string:
var json = new JavaScriptSerializer().Serialize(yourDictionary.ToDictionary(item => item.Key.ToString(), item => item.Value.ToString()));
It is worthwhile to note that something like Dictionary<int, MyClass> can also be serialized in this way while preserving the complex type/object.
Explanation (breakdown)
var yourDictionary = new Dictionary<Key,Value>(); //This is just to represent your current Dictionary.
You can replace the variable yourDictionary with your actual variable.
var convertedDictionary = yourDictionary.ToDictionary(item => item.Key.ToString(), item => item.Value.ToString()); //This converts your dictionary to have the Key and Value of type string.
We do this, because both the Key and Value has to be of type string, as a requirement for serialization of a Dictionary.
var json = new JavaScriptSerializer().Serialize(convertedDictionary); //You can then serialize the Dictionary, as both the Key and Value is of type string, which is required for serialization.
Sorry if the syntax is the tiniest bit off, but the code I'm getting this from was originally in VB :)
using System.Web.Script.Serialization;
...
Dictionary<int,List<int>> MyObj = new Dictionary<int,List<int>>();
//Populate it here...
string myJsonString = (new JavaScriptSerializer()).Serialize(MyObj);
If your context allows it (technical constraints, etc.), use the JsonConvert.SerializeObject method from Newtonsoft.Json : it will make your life easier.
Dictionary<string, string> localizedWelcomeLabels = new Dictionary<string, string>();
localizedWelcomeLabels.Add("en", "Welcome");
localizedWelcomeLabels.Add("fr", "Bienvenue");
localizedWelcomeLabels.Add("de", "Willkommen");
Console.WriteLine(JsonConvert.SerializeObject(localizedWelcomeLabels));
// Outputs : {"en":"Welcome","fr":"Bienvenue","de":"Willkommen"}
In Asp.net Core use:
using Newtonsoft.Json
var obj = new { MyValue = 1 };
var json = JsonConvert.SerializeObject(obj);
var obj2 = JsonConvert.DeserializeObject(json);
You can use System.Web.Script.Serialization.JavaScriptSerializer:
Dictionary<string, object> dictss = new Dictionary<string, object>(){
{"User", "Mr.Joshua"},
{"Pass", "4324"},
};
string jsonString = (new JavaScriptSerializer()).Serialize((object)dictss);
net core :
System.Text.Json.JsonSerializer.Serialize(dict)
You could use JavaScriptSerializer.
It seems a lot of different libraries and what not have seem to come and go over the previous years. However as of April 2016, this solution worked well for me. Strings easily replaced by ints.
TL/DR; Copy this if that's what you came here for:
//outputfilename will be something like: "C:/MyFolder/MyFile.txt"
void WriteDictionaryAsJson(Dictionary<string, List<string>> myDict, string outputfilename)
{
DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(Dictionary<string, List<string>>));
MemoryStream ms = new MemoryStream();
js.WriteObject(ms, myDict); //Does the serialization.
StreamWriter streamwriter = new StreamWriter(outputfilename);
streamwriter.AutoFlush = true; // Without this, I've run into issues with the stream being "full"...this solves that problem.
ms.Position = 0; //ms contains our data in json format, so let's start from the beginning
StreamReader sr = new StreamReader(ms); //Read all of our memory
streamwriter.WriteLine(sr.ReadToEnd()); // and write it out.
ms.Close(); //Shutdown everything since we're done.
streamwriter.Close();
sr.Close();
}
Two import points. First, be sure to add System.Runtime.Serliazation as a reference in your project inside Visual Studio's Solution Explorer. Second, add this line,
using System.Runtime.Serialization.Json;
at the top of the file with the rest of your usings, so the DataContractJsonSerializer class can be found. This blog post has more information on this method of serialization.
Data Format (Input / Output)
My data is a dictionary with 3 strings, each pointing to a list of strings. The lists of strings have lengths 3, 4, and 1.
The data looks like this:
StringKeyofDictionary1 => ["abc","def","ghi"]
StringKeyofDictionary2 => ["String01","String02","String03","String04"]
Stringkey3 => ["someString"]
The output written to file will be on one line, here is the formatted output:
[{
"Key": "StringKeyofDictionary1",
"Value": ["abc",
"def",
"ghi"]
},
{
"Key": "StringKeyofDictionary2",
"Value": ["String01",
"String02",
"String03",
"String04",
]
},
{
"Key": "Stringkey3",
"Value": ["SomeString"]
}]
Here's how to do it using only standard .Net libraries from Microsoft …
using System.IO;
using System.Runtime.Serialization.Json;
private static string DataToJson<T>(T data)
{
MemoryStream stream = new MemoryStream();
DataContractJsonSerializer serialiser = new DataContractJsonSerializer(
data.GetType(),
new DataContractJsonSerializerSettings()
{
UseSimpleDictionaryFormat = true
});
serialiser.WriteObject(stream, data);
return Encoding.UTF8.GetString(stream.ToArray());
}
This is Similar to what Meritt has posted earlier. just posting the complete code
string sJSON;
Dictionary<string, string> aa1 = new Dictionary<string, string>();
aa1.Add("one", "1"); aa1.Add("two", "2"); aa1.Add("three", "3");
Console.Write("JSON form of Person object: ");
sJSON = WriteFromObject(aa1);
Console.WriteLine(sJSON);
Dictionary<string, string> aaret = new Dictionary<string, string>();
aaret = ReadToObject<Dictionary<string, string>>(sJSON);
public static string WriteFromObject(object obj)
{
byte[] json;
//Create a stream to serialize the object to.
using (MemoryStream ms = new MemoryStream())
{
// Serializer the object to the stream.
DataContractJsonSerializer ser = new DataContractJsonSerializer(obj.GetType());
ser.WriteObject(ms, obj);
json = ms.ToArray();
ms.Close();
}
return Encoding.UTF8.GetString(json, 0, json.Length);
}
// Deserialize a JSON stream to object.
public static T ReadToObject<T>(string json) where T : class, new()
{
T deserializedObject = new T();
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json)))
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(deserializedObject.GetType());
deserializedObject = ser.ReadObject(ms) as T;
ms.Close();
}
return deserializedObject;
}
Just for reference, among all the older solutions: UWP has its own built-in JSON library, Windows.Data.Json.
JsonObject is a map that you can use directly to store your data:
var options = new JsonObject();
options["foo"] = JsonValue.CreateStringValue("bar");
string json = options.ToString();
improved mwjohnson's version:
string WriteDictionaryAsJson_v2(Dictionary<string, List<string>> myDict)
{
string str_json = "";
DataContractJsonSerializerSettings setting =
new DataContractJsonSerializerSettings()
{
UseSimpleDictionaryFormat = true
};
DataContractJsonSerializer js =
new DataContractJsonSerializer(typeof(Dictionary<string, List<string>>), setting);
using (MemoryStream ms = new MemoryStream())
{
// Serializer the object to the stream.
js.WriteObject(ms, myDict);
str_json = Encoding.Default.GetString(ms.ToArray());
}
return str_json;
}