CODEWITHSUNDEEP
c#jsonparsinglarge-files
Chris Devine
Chris Devine

Reputation: 4119

Read and parse a Json File in C#

How does one read a very large JSON file into an array in c# to be split up for later processing?

I have managed to get something working that will:

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".

How can one read a JSON file in and only extract the data needed to be put into an array?

Upvotes: 410

Views: 1230129

Answers (13)

mohamad zabiulla
mohamad zabiulla

Reputation: 113

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

Prerequisite:-

and here is the URL -> https://app.quicktype.io/

Steps

1> go to this URL - https://app.quicktype.io/

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
    }
}

Upvotes: 11

Cinchoo
Cinchoo

Reputation: 6332

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: https://dotnetfiddle.net/mo1qvw

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: https://dotnetfiddle.net/fRWu0w

Disclaimer: I'm author of this library.

Upvotes: 0

KC85
KC85

Reputation: 11

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("http://myserver.com/data.json");

GitHub Project Nuget

Upvotes: 1

saad bin sami
saad bin sami

Reputation: 454

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);

Upvotes: 5

MarredCheese
MarredCheese

Reputation: 20881

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);
    }
}

Upvotes: 70

Kanad Mehta
Kanad Mehta

Reputation: 381

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
}

Upvotes: 19

L.B
L.B

Reputation: 116178

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);
    }

Upvotes: 705

Mojtaba Nava
Mojtaba Nava

Reputation: 878

This code can help you:

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

JObject data = JObject.Parse(_filePath );

Upvotes: 1

Adrita Sharma
Adrita Sharma

Reputation: 22203

This can also be done in the following way:

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

Upvotes: 33

SteveCinq
SteveCinq

Reputation: 1963

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.

Upvotes: 16

shailesh gavathe
shailesh gavathe

Reputation: 362

For any of the JSON parse, use the website http://json2csharp.com/ (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.

Upvotes: 10

tmesser
tmesser

Reputation: 7666

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.

Upvotes: 49

kuzdu
kuzdu

Reputation: 7524

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 https://stackoverflow.com/a/32071002/4420355

Upvotes: 5

Related Questions