Convert JSON To Strongly Typed Object Using DataContract In C#

Introduction

Handling JSON with C# is difficult some times. Most software developers work with Web APIs to exchange the data. JSON (JavaScript Object Notation) is one of the best way to exchange data over the HTTP protocol. JSON is simply a string, which contains the data or some important information about the receiving data. It’s a lightweight technology to pass the desired data. We simply request in the URL and API (other Sources) to pass the data in the form of JSON. Hence, in this article, I am showing how to map JSON with C# classes to access the data in the form of class and fields.

Example

I am working with a weather app. Therefore, I am taking this example; i.e., the website www.openweathermap.org/current, which provides the API, and gives the complete information about the weather.

• Go to Web and sign up
• Go to pricing and select the free package
• Generate the API key.
• We have a series of links of how to pass the information to API in the form of latitude or longitude of either zip or of either country
• Once the request is passed to the API, the weather information is passed in the form of JSON.
  
  
  
• I want to access the weather information of Pakistan, so the call is http://api.openweathermap.org/data/2.5/weather?q=Pakistan&appid={API Key}
  
• Hence, it returns the data in the form of JSON, which is shown below:
  
  
  
  
• Our aim is to convert that JSON into the C# classes and fields
  
• Type www.Json2csharp.com,
  
  
  
  
• Paste that JSON into the box and click Generate that web site followed by converting that JSON into C# classes and fields.
  
  
  
  
• When we click, the classes generate, which will look as follows:
  
  
  
  
  
• Click copy and then open the Visual Studio, and make the console project that you can use in every project like Windows form, WPF, UWP etc.
  
• Here, we verify it, using the console Application.
  
• As we see, Json2chsrp makes individual classes and the one class called Root Object contains the references of the sub classes
  
• RootObject class is most important, when we want to use data receiving in the form of JSON.

DataContract and DataMember Attribute

• Next step is to decorate each class with the DataContract attribute and each field of every class with the DataMemeber Attribute just like it is done in every class, as shown below:
  
  
  
• Afterwards, we make a function, which requests the API to async and accept the request, as shown below:
  
  
  
• Make a method which calls the GetRequest() Method, as shown below:
  
  
  
  
• Finally, the complete code will be:
  
  
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Net.Http;
  5. using System.Runtime.Serialization;
  6. using System.Runtime.Serialization.Json;
  7. using System.Text;
  8. using System.Threading.Tasks;
  10. namespace ConsoleApplication1
  11. {
  12. class Program
  13. {
  14. static void Main(string[] args)
  15. {
  16. Program program = new Program();
  17. program.Disaply();
  18. Console.ReadKey();
  19. }
  21. public async void Disaply()
  22. {
  23. RootObject rootObject = await this.GetRequest();
  24. Console.WriteLine("City name is" + rootObject.name);
  25. Console.WriteLine("Temprature in K is" + rootObject.main.temp);
  26. }
  27. public async Task < RootObject > GetRequest()
  28. {
  29. HttpClient httpClient = new HttpClient();
  30. String url =
  31. string.Format(
  32. "http://api.openweathermap.org/data/2.5/weather?q=Pakistan&appid=84e30cdb8f3823239ed2d77f0fd013b6");
  33. var respose = await httpClient.GetAsync(new Uri(url));
  34. var result = await respose.Content.ReadAsStringAsync();
  35. var serializer = new DataContractJsonSerializer(typeof(RootObject));
  36. var MemoryStream = new MemoryStream(Encoding.UTF8.GetBytes(result));
  37. var FinalData = serializer.ReadObject(MemoryStream) as RootObject;
  38. return FinalData;
  40. }
  42. }
  44. [DataContract]
  45. public class Coord
  46. {
  47. [DataMember]
  48. public double lon
  49. {
  50. get;
  51. set;
  52. }
  53. [DataMember]
  54. public double lat
  55. {
  56. get;
  57. set;
  58. }
  59. }
  60. [DataContract]
  61. public class Weather
  62. {
  63. [DataMember]
  64. public int id
  65. {
  66. get;
  67. set;
  68. }
  69. [DataMember]
  70. public string main
  71. {
  72. get;
  73. set;
  74. }
  75. [DataMember]
  76. public string description
  77. {
  78. get;
  79. set;
  80. }
  81. [DataMember]
  82. public string icon
  83. {
  84. get;
  85. set;
  86. }
  87. }
  88. [DataContract]
  89. public class Main
  90. {
  91. [DataMember]
  92. public double temp
  93. {
  94. get;
  95. set;
  96. }
  97. [DataMember]
  98. public int pressure
  99. {
  100. get;
  101. set;
  102. }
  103. [DataMember]
  104. public int humidity
  105. {
  106. get;
  107. set;
  108. }
  109. [DataMember]
  110. public double temp_min
  111. {
  112. get;
  113. set;
  114. }
  115. [DataMember]
  116. public double temp_max
  117. {
  118. get;
  119. set;
  120. }
  121. }
  122. [DataContract]
  123. public class Wind
  124. {
  125. [DataMember]
  126. public double speed
  127. {
  128. get;
  129. set;
  130. }
  132. [DataMember]
  133. public int deg
  134. {
  135. get;
  136. set;
  137. }
  138. }
  139. [DataContract]
  140. public class Clouds
  141. {
  142. [DataMember]
  143. public int all
  144. {
  145. get;
  146. set;
  147. }
  148. }
  149. [DataContract]
  150. public class Sys
  151. {
  152. [DataMember]
  153. public int type
  154. {
  155. get;
  156. set;
  157. }
  158. [DataMember]
  160. public int id
  161. {
  162. get;
  163. set;
  164. }
  165. [DataMember]
  166. public double message
  167. {
  168. get;
  169. set;
  170. }
  171. [DataMember]
  172. public string country
  173. {
  174. get;
  175. set;
  176. }
  177. [DataMember]
  178. public int sunrise
  179. {
  180. get;
  181. set;
  182. }
  183. [DataMember]
  184. public int sunset
  185. {
  186. get;
  187. set;
  188. }
  189. }
  190. [DataContract]
  191. public class RootObject
  192. {
  193. [DataMember]
  194. public Coord coord
  195. {
  196. get;
  197. set;
  198. }
  199. [DataMember]
  200. public List < Weather > weather
  201. {
  202. get;
  203. set;
  204. }
  205. [DataMember]
  206. public string @base
  207. {
  208. get;
  209. set;
  210. }
  211. [DataMember]
  212. public Main main
  213. {
  214. get;
  215. set;
  216. }
  217. [DataMember]
  218. public Wind wind
  219. {
  220. get;
  221. set;
  222. }
  223. [DataMember]
  224. public Clouds clouds
  225. {
  226. get;
  227. set;
  228. }
  229. [DataMember]
  230. public int dt
  231. {
  232. get;
  233. set;
  234. }
  235. [DataMember]
  236. public Sys sys
  237. {
  238. get;
  239. set;
  240. }
  241. [DataMember]
  242. public int id
  243. {
  244. get;
  245. set;
  246. }
  247. [DataMember]
  248. public string name
  249. {
  250. get;
  251. set;
  252. }
  253. [DataMember]
  254. public int cod
  255. {
  256. get;
  257. set;
  258. }
  259. }
  261. }
       
       
• Verify the output, as shown below:
  
  
  

Conclusion

There is a simple mechanism, which is used to develop the strongly typed classes and fields with JSON; using this method, it becomes easy to parse and use JSON across the whole project.