How to parse JSON without JSON.NET library?

I'm trying to build a Metro application for Windows 8 on Visual Studio 2011. and while I'm trying to do that, I'm having some issues on how to parse JSON without JSON.NET library (It doesn't support the metro applications yet).

Anyway, I want to parse this:

{
   "name":"Prince Charming",
   "artist":"Metallica",
   "genre":"Rock and Metal",
   "album":"Reload",
   "album_image":"http:\/\/up203.siz.co.il\/up2\/u2zzzw4mjayz.png",
   "link":"http:\/\/f2h.co.il\/7779182246886"
}

You can use the classes found in the System.Json Namespace which were added in .NET 4.5. You need to add a reference to the System.Runtime.Serialization assembly

The JsonValue.Parse() Method parses JSON text and returns a JsonValue:

JsonValue value = JsonValue.Parse(@"{ ""name"":""Prince Charming"", ...");

If you pass a string with a JSON object, you should be able to cast the value to a JsonObject:

using System.Json;


JsonObject result = value as JsonObject;

Console.WriteLine("Name .... {0}", (string)result["name"]);
Console.WriteLine("Artist .. {0}", (string)result["artist"]);
Console.WriteLine("Genre ... {0}", (string)result["genre"]);
Console.WriteLine("Album ... {0}", (string)result["album"]);

The classes are quite similar to those found in the System.Xml.Linq Namespace.

I use this...but have never done any metro app development, so I don't know of any restrictions on libraries available to you. (note, you'll need to mark your classes as with DataContract and DataMember attributes)

public static class JSONSerializer<TType> where TType : class
{
	/// <summary>
	/// Serializes an object to JSON
	/// </summary>
	public static string Serialize(TType instance)
	{
		var serializer = new DataContractJsonSerializer(typeof(TType));
		using (var stream = new MemoryStream())
		{
			serializer.WriteObject(stream, instance);
			return Encoding.Default.GetString(stream.ToArray());
		}
	}

	/// <summary>
	/// DeSerializes an object from JSON
	/// </summary>
	public static TType DeSerialize(string json)
	{
		using (var stream = new MemoryStream(Encoding.Default.GetBytes(json)))
		{
			var serializer = new DataContractJsonSerializer(typeof(TType));
			return serializer.ReadObject(stream) as TType;
		}
	}
}

So, if you had a class like this...

[DataContract]
public class MusicInfo
{
    [DataMember]
    public string Name { get; set; }

    [DataMember]
    public string Artist { get; set; }

    [DataMember]
	public string Genre { get; set; }

    [DataMember]
	public string Album { get; set; }

    [DataMember]
	public string AlbumImage { get; set; }

    [DataMember]
	public string Link { get; set; }

}

Then you would use it like this...

var musicInfo = new MusicInfo
{
     Name = "Prince Charming",
     Artist = "Metallica",
     Genre = "Rock and Metal",
     Album = "Reload",
     AlbumImage = "http://up203.siz.co.il/up2/u2zzzw4mjayz.png",
     Link = "http://f2h.co.il/7779182246886"
};

// This will produce a JSON String
var serialized = JSONSerializer<MusicInfo>.Serialize(musicInfo);

// This will produce a copy of the instance you created earlier
var deserialized = JSONSerializer<MusicInfo>.DeSerialize(serialized);

For those who do not have 4.5, Here is my library function that reads json. It requires a project reference to System.Web.Extensions.

using System.Web.Script.Serialization;

public object DeserializeJson<T>(string Json)
{
	JavaScriptSerializer JavaScriptSerializer = new JavaScriptSerializer();
	return JavaScriptSerializer.Deserialize<T>(Json);
}

Usually, json is written out based on a contract. That contract can and usually will be codified in a class (T). Sometimes you can take a word from the json and search the object browser to find that type.

Example usage:

Given the json

{"logEntries":[],"value":"My Code","text":"My Text","enabled":true,"checkedIndices":[],"checkedItemsTextOverflows":false}

You could parse it into a RadComboBoxClientState object like this:

string ClientStateJson = Page.Request.Form("ReportGrid1_cboReportType_ClientState");
RadComboBoxClientState RadComboBoxClientState = DeserializeJson<RadComboBoxClientState>(ClientStateJson);
return RadComboBoxClientState.Value;

Have you tried using JavaScriptSerializer ? There's also DataContractJsonSerializer

I needed a JSON serializer and deserializer without any 3rd party dependency or nuget, that can support old systems, so you don't have to choose between Newtonsoft.Json, System.Text.Json, DataContractSerializer, JavaScriptSerializer, etc. depending on the target platform.

So I have started this open source (MIT) project here:

https://github.com/smourier/ZeroDepJson

It's just one C# file ZeroDepJson.cs, compatible with .NET Framework 4.x to .NET Core, and .NET 5.

Note it's probably not as good as all the aforementioned libraries (especially in performance area), but it should be reasonably ok and friction-free.

You can use DataContractJsonSerializer. See this link for more details.

using System;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;

namespace OTL
{
    /// <summary>
    /// Before usage: Define your class, sample:
    /// [DataContract]
    ///public class MusicInfo
    ///{
    ///   [DataMember(Name="music_name")]
    ///   public string Name { get; set; }
    ///   [DataMember]
    ///   public string Artist{get; set;}
    ///}
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class OTLJSON<T> where T : class
    {
        /// <summary>
        /// Serializes an object to JSON
        /// Usage: string serialized = OTLJSON&lt;MusicInfo&gt;.Serialize(musicInfo);
        /// </summary>
        /// <param name="instance"></param>
        /// <returns></returns>
        public static string Serialize(T instance)
        {
            var serializer = new DataContractJsonSerializer(typeof(T));
            using (var stream = new MemoryStream())
            {
                serializer.WriteObject(stream, instance);
                return Encoding.Default.GetString(stream.ToArray());
            }
        }

        /// <summary>
        /// DeSerializes an object from JSON
        /// Usage:  MusicInfo deserialized = OTLJSON&lt;MusicInfo&gt;.Deserialize(json);
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public static T Deserialize(string json)
        {
            if (string.IsNullOrEmpty(json))
                throw new Exception("Json can't empty");
            else
                try
                {
                    using (var stream = new MemoryStream(Encoding.Default.GetBytes(json)))
                    {

                        var serializer = new DataContractJsonSerializer(typeof(T));
                        return serializer.ReadObject(stream) as T;
                    }
                }
                catch (Exception e)
                {
                    throw new Exception("Json can't convert to Object because it isn't correct format.");
                }
        }
    }
}

I have written a small function to do that long back, it requiresSystem.Runtime.Serialization.Json namespace.

to use you need to call

JConvert<string,object>(str); //to Parse string to non anonymous <object>
JConvert<object,string>(obj); //to convert <obj> to string

See if that works for you. It will work with small setof data but havent test with big data source.

// Json Serializer without NewtonSoft
public static class JsonHelper
{
	public static R JConvert<P,R>(this P t)
	{		
		if(typeof(P) == typeof(string))
		{
			var return1 =  (R)(JsonDeserializer<R>(t as string));
			return return1;
		}
		else
		{
			var return2 =  (JsonSerializer<P>(t));
			R result = (R)Convert.ChangeType(return2, typeof(R));
			return result;
		}	
	}
	
	private static String JsonSerializer<T>(T t)
	{
		var stream1 = new MemoryStream();
		var ser = new DataContractJsonSerializer(typeof(T));
		ser.WriteObject(stream1, t);
		stream1.Position = 0;
		var sr = new StreamReader(stream1);		
		return (sr.ReadToEnd());
	}
	
	private static T JsonDeserializer<T>(string jsonString)
	{
		T deserializedUser = default(T);
	    var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
	    var ser = new DataContractJsonSerializer(typeof(T));
	    deserializedUser = (T)ser.ReadObject(ms);// as T;
	    ms.Close();
	    return deserializedUser;
	}
}