I have spent the best part of two days "faffing" about with code samples and etc., trying to read a very large JSON file into an array in c# so I can later split it up into a 2d array for processing.

The problem I was having was I could not find any examples of people doing what I was trying to do. This meant I was just editing code a little an hoping for the best.

I have managed to get something working that will:

• Read the file Miss out headers and only read values into array.
• Place a certain amount of values on each line of an array. (So I could later split it an put into 2d array)

This was done with the code below but it crashes the program after entering a few lines into the array. This might have to do with the file size.

// If the file extension was a jave file the following // load method will be use else it will move on to the // next else if statement if (fileExtension == ".json") { int count = 0; int count2 = 0; int inOrOut = 0; int nRecords=1; JsonTextReader reader = new JsonTextReader(new StreamReader(txtLoaction.Text)); string[] rawData = new string[5]; while (reader.Read()) { if (reader.Value != null) if (inOrOut == 1) { if (count == 6) { nRecords++; Array.Resize(ref rawData, nRecords); //textBox1.Text += "\r\n"; count = 0; } rawData[count2] += reader.Value + ","; //+"\r\n" inOrOut = 0; count++; if (count2 == 500) { MessageBox.Show(rawData[499]); } } else { inOrOut = 1; } } } 

A snippet of the JSON I am working with is:

[ { "millis": "1000", "stamp": "1273010254", "datetime": "2010/5/4 21:57:34", "light": "333", "temp": "78.32", "vcc": "3.54" }, ] 

I need the values out of this JSON. For example, I need "3.54", but I would not want it to print the "vcc".

I am hoping someone can show me how to read a JSON file in and only extract the data that I need and put it into an array or something that I can use to later put into an array.

13 Answers

How about making everything easier with Json.NET?

 public void LoadJson() { using (StreamReader r = new StreamReader("file.json")) { string json = r.ReadToEnd(); List<Item> items = JsonConvert.DeserializeObject<List<Item>>(json); } } public class Item { public int millis; public string stamp; public DateTime datetime; public string light; public float temp; public float vcc; } 

You can even get the values dynamically without declaring Item class.

 dynamic array = JsonConvert.DeserializeObject(json); foreach(var item in array) { Console.WriteLine("{0} {1}", item.temp, item.vcc); } 

Doing this yourself is an awful idea. Use Json.NET. It has already solved the problem better than most programmers could if they were given months on end to work on it. As for your specific needs, parsing into arrays and such, check the documentation, particularly on JsonTextReader. Basically, Json.NET handles JSON arrays natively and will parse them into strings, ints, or whatever the type happens to be without prompting from you. Here is a direct link to the basic code usages for both the reader and the writer, so you can have that open in a spare window while you're learning to work with this.

This is for the best: Be lazy this time and use a library so you solve this common problem forever.

This can also be done in the following way:

JObject data = JObject.Parse(File.ReadAllText(MyFilePath)); 

Answer for .NET Core

You can just use the built-in System.Text.Json instead of the 3rd-party Json.NET. To promote reuse, the JSON-file-reading functionality belongs in its own class and should be generic rather than hard-coded to a certain type (Item). Here's a full example:

using System; using System.IO; using System.Text.Json; using System.Threading.Tasks; namespace Project { class Program { static async Task Main() { Item item = await JsonFileReader.ReadAsync<Item>(@"C:\myFile.json"); } } public static class JsonFileReader { public static async Task<T> ReadAsync<T>(string filePath) { using FileStream stream = File.OpenRead(filePath); return await JsonSerializer.DeserializeAsync<T>(stream); } } public class Item { public int millis; public string stamp; public DateTime datetime; public string light; public float temp; public float vcc; } } 

Or, if you prefer something simpler/synchronous:

class Program { static void Main() { Item item = JsonFileReader.Read<Item>(@"C:\myFile.json"); } } public static class JsonFileReader { public static T Read<T>(string filePath) { string text = File.ReadAllText(filePath); return JsonSerializer.Deserialize<T>(text); } } 

string jsonFilePath = @"C:\MyFolder\myFile.json"; string json = File.ReadAllText(jsonFilePath); Dictionary<string, object> json_Dictionary = (new JavaScriptSerializer()).Deserialize<Dictionary<string, object>>(json); foreach (var item in json_Dictionary) { // parse here } 

Based on @L.B.'s solution, the (typed as Object rather than Anonymous) VB code is

Dim oJson As Object = JsonConvert.DeserializeObject(File.ReadAllText(MyFilePath)) 

I should mention that this is quick and useful for constructing HTTP call content where the type isn't required. And using Object rather than Anonymous means you can maintain Option Strict On in your Visual Studio environment - I hate turning that off.

For any of the JSON parse, use the website (easiest way) to convert your JSON into C# class to deserialize your JSON into C# object.

 public class JSONClass { public string name { get; set; } public string url { get; set; } public bool visibility { get; set; } public string idField { get; set; } public bool defaultEvents { get; set; } public string type { get; set; } } 

Then use the JavaScriptSerializer (from System.Web.Script.Serialization), in case you don't want any third party DLL like newtonsoft.

using (StreamReader r = new StreamReader("jsonfile.json")) { string json = r.ReadToEnd(); JavaScriptSerializer jss = new JavaScriptSerializer(); var Items = jss.Deserialize<JSONClass>(json); } 

Then you can get your object with Items.name or Items.Url etc.

For finding the right path I'm using

 var pathToJson = Path.Combine("my","path","config","default.Business.Area.json"); var r = new StreamReader(pathToJson); var myJson = r.ReadToEnd(); // my/path/config/default.Business.Area.json [...] do parsing here 

Path.Combine uses the Path.PathSeparator and it checks whether the first path has already a separator at the end so it will not duplicate the separators. Additionally, it checks whether the path elements to combine have invalid chars.

See

There is a faster way of parsing json then Json.Net . If you are using .net core 3.0 or up then you can use the System.Text.Json nuget package to serialize or deserialize.

you need to add:

using System.Text.Json 

And then you can serialize as:

var jsonStr = JsonSerializer.Serialize(model); 

And Deserialize as:

var model = JsonSerializer.Deserialize(jsonStr); 

This code can help you:

string _filePath = Path.GetDirectoryName(System.AppDomain.CurrentDomain.BaseDirectory); JObject data = JObject.Parse(_filePath ); 

There is an easier way to get JSON from file or from the Web: Json.Net.Curl

Install-Package Json.Net.Curl

// get JObject from local file system var json = Json.Net.Curl.Get(@"data\JObjectUnitTest1.json"); var json = await Json.Net.Curl.GetAsync(@"data\JObjectUnitTest1.json") // get JObject from Server var json = await Json.Net.Curl.GetAsync(""); 

GitHub Project Nuget

With Cinchoo ETL, an open source library, parsing of very large JSON file is iterative and simple to use

1. Dynamic Method: - No POCO class required

 string json = @" [ { ""millis"": ""1000"", ""stamp"": ""1273010254"", ""datetime"": ""2010/5/4 21:57:34"", ""light"": ""333"", ""temp"": ""78.32"", ""vcc"": ""3.54"" }, { ""millis"": ""2000"", ""stamp"": ""1273010254"", ""datetime"": ""2010/5/4 21:57:34"", ""light"": ""333"", ""temp"": ""78.32"", ""vcc"": ""3.54"" } ] "; using (var r = ChoJSONReader.LoadText(json)) { foreach (var rec in r) Console.WriteLine(rec.Dump()); } 

Sample fiddle:

2. POCO Method:

Define POCO class matching json attributes

public class Item { public int Millis { get; set; } public string Stamp { get; set; } public DateTime Datetime { get; set; } public string Light { get; set; } public float Temp { get; set; } public float Vcc { get; set; } } 

Then using the parser to load the JSON as below

 string json = @" [ { ""millis"": ""1000"", ""stamp"": ""1273010254"", ""datetime"": ""2010/5/4 21:57:34"", ""light"": ""333"", ""temp"": ""78.32"", ""vcc"": ""3.54"" }, { ""millis"": ""2000"", ""stamp"": ""1273010254"", ""datetime"": ""2010/5/4 21:57:34"", ""light"": ""333"", ""temp"": ""78.32"", ""vcc"": ""3.54"" } ] "; using (var r = ChoJSONReader<Item>.LoadText(json)) { foreach (var rec in r) Console.WriteLine(ChoUtility.Dump(rec)); } 

Sample fiddle:

Disclaimer: I'm author of this library.

Very Easiest way I found on online to work with .JSON file in C#(or any other Programming Language)

Prerequisite:-

• Install Newtonsoft.Json Library into your Project Newtonsoft.Json

and here is the URL ->

Steps

1> go to this URL -

2> Copy and Paste your JSON file structure into Left sidebar

app.quicktype.io

3> Select required Language (here C#) from Options menu

4> Copy generated code and go to your Project and Create a new .cs file with the same name(here "Welcome.cs")

Welcome.cs

5> Paste all generated code into the newly created class.

Welcome.cs pasted Code

6> that's it. :)

Steps to Access value

1> Go to Main Program .cs file or wherever you need to access it.

class Program { static void Main(string[] args) { Console.WriteLine("Access Json values using Keys.>"); String jsonString = new StreamReader("give <.json> file Path here").ReadToEnd(); // use below syntax to access JSON file var jsonFile = Welcome.FromJson(jsonString); string FileName = jsonFile.File; long Lvl = jsonFile.Level; bool isTrue = jsonFile.CSharp; Console.WriteLine(FileName);//JSON Console.WriteLine(Lvl);//1 Console.WriteLine(isTrue);//true } }