C# implementation code for parsing json files

C# Parsing json

JSON (full name is JavaScript Object Notation) is a lightweight data exchange format. It is based on a subset of the JavaScript syntax standard. JSON is a completely language-independent text format that can be easily transferred across various networks, platforms, and programs. The syntax of JSON is very simple, easy for humans to read and write, and easy for machines to parse and generate.

Comparison between JSON and XML

◆Readability
Comparing the readability of JSON and XML, XML provides auxiliary tags and is more suitable for human reading and understanding.
◆File size and transmission
XML allows the use of convenient tags, so the file size is larger than JSON. Moreover, JSON originates from Javascript, so its natural main battlefield is Javascript and the Internet. Here, JSON has advantages that XML cannot catch up with.

JSON syntax

1. JSON syntax is a subset of JavaScript object notation syntax.

•Data is in name/value pairs: name is a string, expressed using double quotes. Values ​​can be: numbers (integer or floating point), strings (in double quotes), arrays (in square brackets), objects (in curly brackets), true/false/null.
• Data is separated by commas:
• Curly braces hold objects: Objects can contain a variety of data, including arrays.
• Square brackets hold arrays: numbers can contain objects.

For example:

{
    "employees": [
        {
            "firstName": "Bill",
            "lastName": "Gates"
        },
        {
            "firstName": "George",
            "lastName": "Bush"
        }
    ]
}

2. If JSON contains escape characters, they need to be escaped. For example, you need to use "\\" instead of "\" in the file path. For example: { "file":"C:\\a.txt"}.

.NET operates JSON

When JSON files are read into memory, they are strings. .NET operates JSON by generating and parsing JSON strings. There are usually several ways to operate JSON:

1. Original method: Write code to directly operate JSON strings according to the JSON syntax format. Unless necessary, very few people would take this path and start all over again.

2. General method [★★★★★]:

This method uses the open source class library Newtonsoft.Json (download address http://json.codeplex.com/) . After downloading, you can use it by adding it to the project. Usually it can be processed using JObject, JsonReader, JsonWriter. This method is the most versatile and flexible, and you can modify any uncomfortable areas at any time.
(1) Use JsonReader to read Json string:

string jsonText = @"{""input"" : ""value"", ""output"" : ""result""}";
JsonReader reader = new JsonTextReader(new StringReader(jsonText));
while (reader.Read())
{
    Console.WriteLine(reader.TokenType + "\t\t" + reader.ValueType + "\t\t" + reader.Value);
}

(2) Use JsonWriter to write string:

StringWriter sw = new StringWriter();
JsonWriter writer = new JsonTextWriter(sw);
writer.WriteStartObject();
writer.WritePropertyName("input");
writer.WriteValue("value");
writer.WritePropertyName("output");
writer.WriteValue("result");
writer.WriteEndObject();
writer.Flush();
string jsonText = sw.GetStringBuilder().ToString();
Console.WriteLine(jsonText);

(3) Use JObject to read and write string:

JObject jo = JObject.Parse(jsonText);
string[] values = jo.Properties().Select(item => item.Value.ToString()).ToArray();

(4) Use JsonSerializer to read and write objects (based on JsonWriter and JsonReader):

Array data

string jsonArrayText1 = "[{'a':'a1','b':'b1'},{'a':'a2','b':'b2'}]";
JArray ja = (JArray)JsonConvert.DeserializeObject(jsonArrayText1);
string ja1a = ja[1]["a"].ToString();
//或者
JObject o = (JObject)ja[1];
string oa = o["a"].ToString();

Nested format

string jsonText = "{\"beijing\":{\"zone\":\"海淀\",\"zone_en\":\"haidian\"}}";
JObject jo = (JObject)JsonConvert.DeserializeObject(jsonText);
string zone = jo["beijing"]["zone"].ToString();
string zone_en = jo["beijing"]["zone_en"].ToString();

Custom class Project

Project p = new Project() { Input = "stone", Output = "gold" };
JsonSerializer serializer = new JsonSerializer();
StringWriter sw = new StringWriter();
serializer.Serialize(new JsonTextWriter(sw), p);
Console.WriteLine(sw.GetStringBuilder().ToString());
StringReader sr = new StringReader(@"{""Input"":""stone"", ""Output"":""gold""}");
Project p1 = (Project)serializer.Deserialize(new JsonTextReader(sr), typeof(Project));
Console.WriteLine(p1.Input + "=>" + p1.Output);

The above code is based on the following Project class definition:

class Project
{
    public string Input { get; set; }
    public string Output { get; set; }
}

In addition, if the JsonTextReader and other classes above cannot be compiled, it means that they are classes that we have modified and replace them with your own. Relevant classes are enough, and it does not affect use.

3. Built-in method: Use the JavaScriptSerializer class under the System.Web.Script.Serialization namespace provided in .NET Framework 3.5/4.0 to serialize and deserialize objects, which is very straightforward.

Project p = new Project() { Input = "stone", Output = "gold" };
 JavaScriptSerializer serializer = new JavaScriptSerializer();
 var json = serializer.Serialize(p);
 Console.WriteLine(json);
 var p1 = serializer.Deserialize<Project>(json);
 Console.WriteLine(p1.Input + "=>" + p1.Output);
 Console.WriteLine(ReferenceEquals(p,p1));

Note: If you are using VS2010, the Target Framework of the current project is required to be changed to .Net Framework 4, and Client Profile cannot be used. Of course, this System.Web.Extensions.dll is mainly used by the Web. It feels like a waste of resources to use it directly in the Console project.

In addition, as you can see from the last sentence, serialization and deserialization are a typical implementation method of deep copy.

4. Contract method: Use the DataContractJsonSerializer or JsonReaderWriterFactory provided by System.Runtime.Serialization.dll.

Project p = new Project() { Input = "stone", Output = "gold" };
DataContractJsonSerializer serializer = new DataContractJsonSerializer(p.GetType());
string jsonText;
using (MemoryStream stream = new MemoryStream())
{
    serializer.WriteObject(stream, p);
    jsonText = Encoding.UTF8.GetString(stream.ToArray());
    Console.WriteLine(jsonText);
}
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonText)))
{
    DataContractJsonSerializer serializer1 = new DataContractJsonSerializer(typeof(Project));
    Project p1 = (Project)serializer1.ReadObject(ms);
    Console.WriteLine(p1.Input + "=>" + p1.Output);
}

It should be noted here that the Project class and members here need to add relevant Attributes:

[DataContract]
class Project
{
    [DataMember]
    public string Input { get; set; }
    [DataMember]
    public string Output { get; set; }
}

For more articles related to the implementation code of C# parsing json files, please pay attention to the PHP Chinese website!