JSONLIB Files

		public class ExamplePerson
		{
			public String Name { get; set; }
			public Int32 Age { get; set; }
			public override String ToString()
			{
				return String.Format("Name: {0}, Age: {1}", Name, Age);
			}
		}

		public class ExamplePhone
		{
			public enum PhoneType { Home = 0, Mobile }
			public PhoneType Type { get; set; }
			public String Number { get; set; }
			public override String ToString()
			{
				return String.Format("Type: {0}, Number: {1}", Type, Number);
			}
		}

		public class ExamplePhoneList : List<ExamplePhone> { }

		public class ExamplePerson2
		{
			public String Name { get; set; }
			public Int32 Age { get; set; }
			public ExamplePhone[] Phone { get; set; }
			public ExamplePhoneList PhoneList { get; set; }
			public override String ToString()
			{
				return String.Format("Name: {0}, Age: {1}", Name, Age);
			}

		}

		static void Main(string[] args)
		{
			// Welcome to this tutorial!

			// I will assume that you are familiar with JSON data format. Here is an example:
			// { "key1": 1, "key2": "two" }, or more complicated:
			// { "key1": "value1", "key2": 123, "key3": [ 1, 2, "3", { "key1": true } ], key4: { "key1": 1 } }
			// As you know, there are two JSON data objects, JSON Object and JSON Array.
			// JSON Object is set of key/value pairs, where keys are Strings.
			// JSON Array is array which holds only values in strict order, accessing them by index.
			// Value can be any of String, Number, Boolean, JSON Object or JSON Array.

			// In this library you will find both JSONObject and JSONArray data type, so that you
			// can easily manipulate JSON, create it, convert it into String and from String back
			// into object, and accessing its data, like with any other native type in C#.
			// But what is much unique in this library is that even value has its own type, named
			// JSONValue, and any type, primitive or complex, can also be represented as this type.
			// But let's move to the examples.

			// Creating JSONObject
			Debug.WriteLine("\r\nCreating JSONObject");

			JSONObject jsonObject = new JSONObject();
			// this will create new key if it does not exists, otherwise it will create a new one.
			jsonObject["key1"] = "value1";
			jsonObject["key2"] = true;
			jsonObject["key3"] = 5;
			Debug.WriteLine(jsonObject); // it will be automatically converted to String before output.
			jsonObject.Remove("key3");
			Debug.WriteLine(jsonObject);
			String jsonString = jsonObject; // this will also create String from JSONObject.
			Debug.WriteLine(jsonObject);


			// More about creating JSONObject
			Debug.WriteLine("\r\nMore about creating JSONObject");

			jsonObject = new JSONObject(new object[,] {
				{ "key1", "1" }, { "key2", 2 }});
			Debug.WriteLine(jsonObject);

			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			dictionary.Add("key1", "value1"); dictionary.Add("key2", DateTime.Now);
			jsonObject = new JSONObject(dictionary);
			jsonObject.Add("key3", 3);
			Debug.WriteLine(jsonObject);


			// Accessing JSONObject values
			Debug.WriteLine("\r\nAccessing JSONObject values");

			jsonObject = new JSONObject(new object[,] {
				{ "key1", "1" },
				{ "key2", -2.5 },
				{ "key3", new JSONObject(new object[,] {
					{ "key1", true }, { "key2", 5 }}) } });
			Decimal value1 = jsonObject["key2"];
			Debug.WriteLine(value1);
			UInt32 value2 = jsonObject["key3"]["key2"];
			Debug.WriteLine(value2);
			jsonObject["key3"]["key1"] = false;
			Debug.WriteLine(jsonObject["key3"]["key1"]);


			// Parsing JSON Object string
			Debug.WriteLine("\r\nParsing JSON Object string");

			jsonObject = JSONObject.Parse("{\"key1\":1,\"key2\":{\"key1\":true,\"key2\":\"2.5\"}}");
			Debug.WriteLine(jsonObject);


			// Creating JSONArray
			Debug.WriteLine("\r\nCreating JSONArray");

			JSONArray jsonArray = new JSONArray();
			jsonArray.Add("value1"); jsonArray.Add(2); jsonArray.Add(true);
			Debug.WriteLine(jsonArray);
			jsonArray.RemoveAt(1);
			jsonArray.Insert("value0", 0);
			Debug.WriteLine(jsonArray);


			// More about creating JSONArray
			Debug.WriteLine("\r\nMore about creating JSONArray");

			jsonArray = new JSONArray(new object[] { true, "value2" });
			Debug.WriteLine(jsonArray);

			List<object> list = new List<object>();
			list.Add(1); list.Add("value2");
			list.Add(new JSONObject(new Object[,] {
				{ "key1", "value1"}, { "key2", true }}));
			jsonArray = new JSONArray(list);
			Debug.WriteLine(jsonArray);


			// Accessing JSONArray values
			Debug.WriteLine("\r\nAccessing JSONArray values");

			jsonArray = new JSONArray(new object[] {
				true, "value2",
				new JSONObject(new object[,] { { "key1", "value1" }, { "key2", 2 } })
			});
			String value3 = jsonArray[1];
			Debug.WriteLine(value3);
			String value4 = jsonArray[2]["key2"];
			Debug.WriteLine(value4);


			// Parsing JSON Array string
			Debug.WriteLine("\r\nParsing JSON Array string");

			jsonArray = JSONArray.Parse("[1,{\"key1\":true,\"key2\":\"2.5\"}]");
			Debug.WriteLine(jsonArray);


			// You have noticed that I'm using nested structures in this example. Parsers
			// can also parse nested objects and create complex nested native objects,
			// so that JSONObject can parse nested JSON Array and JSONArray can parse
			// nested JSON Object.
			// But this two types are even more related because there is a type which
			// encapsulates them (not really encapsulate in C# term, it's just a wrapper)
			// so that it gives them common properties, and that is JSONValue. So every
			// value in that nested structure is, in fact, an object of this type.


			// JSONValue examples
			Debug.WriteLine("\r\nJSONValue examples");

			JSONValue jsonValue = new JSONObject();
			jsonValue["key1"] = "value1";
			Debug.WriteLine(jsonValue);

			jsonValue = JSONValue.Parse("[1,{\"key1\":true,\"key2\":2.5}]");
			Debug.WriteLine(jsonValue);

			JSONValue jsonValue2 = jsonValue[1]["key1"];
			Boolean value5 = jsonValue2;
			Debug.WriteLine(value5);


			// And of course, Null value example
			Debug.WriteLine("\r\nNull value example");

			jsonValue = JSONValue.Parse("[1,{\"key1\":null,\"key2\":\"2.5\"}]");
			Debug.WriteLine(jsonValue[1]["key1"].ToString());


			// More nested example
			Debug.WriteLine("\r\nMore nested example");
			String a = "{\"key1\":\"value1\",\"key2\":{\"key21\":{\"key211\":\"value211\"},\"key22\":{\"key221\":\"value221\"}},\"key3\":{\"key31\":\"value31\"}}";
			JSONObject b = JSONObject.Parse(a);
			Debug.WriteLine(b.ToString());


			// Example with whitespaces (now supported)
			Debug.WriteLine("\r\nExample with whitespaces");

			jsonValue = JSONValue.Parse(" {\"key1\" : {\"key1\" :   \"value1\", \"key2\":\"value2\"} , \"key2\":[1 ,\"2.5\" ]}");
			Debug.WriteLine(jsonValue.ToString());


			// Parsing invalid string
			Debug.WriteLine("\r\nParsing invalid string");

			jsonValue = JSONValue.Parse("");
			Debug.WriteLine(String.Format("jsonValue = {0}", jsonValue == null ? "null" : jsonValue.ToString()));


			// Converting JSONValue to List<JSONValue> and Dictionary<String, JSONValue>
			Debug.WriteLine("\r\nConverting JSONValue to List<JSONValue> and Dictionary<String, JSONValue>");

			jsonValue = JSONArray.Parse("[1,{\"key1\":true,\"key2\":\"2.5\"}]");
			List<JSONValue> list2 = (List<JSONValue>)jsonValue;
			Debug.WriteLine(list2.ToString());

			jsonValue = (JSONValue)list2;
			Debug.WriteLine(jsonValue.ToString());

			jsonValue = JSONValue.Parse("{\"key1\":1,\"key2\":{\"key1\":true,\"key2\":\"2.5\"}}");
			Dictionary<String, JSONValue> dictionary2 = (Dictionary<String, JSONValue>)jsonValue;
			Debug.WriteLine(dictionary2.ToString());

			jsonValue = (JSONValue)dictionary2;
			Debug.WriteLine(jsonValue.ToString());


			// Serialization of a class instance
			Debug.WriteLine("\r\nSerialization of a class instance");
			jsonValue = JSONValue.Serialize(new ExamplePerson() { Name = "John", Age = 31 });
			Debug.WriteLine(jsonValue.ToString());

			ExamplePerson person = jsonValue.Deserialize<ExamplePerson>();
			Debug.WriteLine(person);
			

			// Serialization of a Dictionary<String, Object> instance
			Debug.WriteLine("\r\nSerialization of a Dictionary<String, Object> instance");
			jsonObject = JSONObject.Serialize(new Dictionary<String, Object>() {
				{ "Name", "John" }, { "Age", 31 } });
			Debug.WriteLine(jsonObject.ToString());

			dictionary = jsonObject.Deserialize<Dictionary<String, Object>>();
			Debug.WriteLine(String.Format("Name: {0}, Age: {1}", dictionary["Name"], dictionary["Age"]));


			// Serialization of a Dictionary<String, JSONValue> instance
			Debug.WriteLine("\r\nSerialization of a Dictionary<String, JSONValue> instance");
			jsonObject = JSONObject.Serialize(new Dictionary<String, JSONValue>() {
				{ "Name", new JSONObject() { { "First", "John" }, { "Last", "Lennon" } } },
				{ "Age", 31 }, { "BirthDate", new DateTime(1940, 10, 9) } });
			Debug.WriteLine(jsonObject.ToString());

			dictionary2 = jsonObject.Deserialize<Dictionary<String, JSONValue>>();
			Debug.WriteLine(String.Format("Name: < First: {0}, Last: {1} >, Age: {2}, BirthDate: {3}",
				dictionary2["Name"]["First"], dictionary2["Name"]["Last"], dictionary2["Age"],
				dictionary2["BirthDate"]));


			// Serialization of a List<JSONValue> instance
			Debug.WriteLine("\r\nSerialization of a List<JSONValue> instance");
			List<JSONValue> listJSONValue = new List<JSONValue>() { new JSONValue(1), new JSONValue("dva") };
			jsonArray = JSONArray.Serialize(listJSONValue);
			Debug.WriteLine(jsonArray.ToString());

			listJSONValue = jsonArray.Deserialize<List<JSONValue>>();
			Debug.WriteLine(String.Format("[ {0}, {1} ]", listJSONValue[0].Value, listJSONValue[1].Value));


			// Serialization of a List<Object> instance
			Debug.WriteLine("\r\nSerialization of a List<Object> instance");
			List<Object> listObject = new List<Object>() { 1, "dva" };
			jsonArray = JSONArray.Serialize(listObject);
			Debug.WriteLine(jsonArray.ToString());

			listObject = jsonArray.Deserialize<List<Object>>();
			Debug.WriteLine(String.Format("[ {0}, {1} ]", listObject[0], listObject[1]));


			// Serialization of an array
			Debug.WriteLine("\r\nSerialization of an array");
			int[] array = new int[] { 1, 2 };
			jsonArray = JSONArray.Serialize(array);
			Debug.WriteLine(jsonArray.ToString());

			array = jsonArray.Deserialize<int[]>();
			Debug.WriteLine(jsonArray);


			// Serialization of a complex object
			Debug.WriteLine("\r\nSerialization of a complex object");
			jsonValue = JSONValue.Serialize(new ExamplePerson2() {
				Name = "John",
				Age = 31,
				Phone = new ExamplePhone[] {
					new ExamplePhone() { Type = ExamplePhone.PhoneType.Home, Number = "111" },
					new ExamplePhone() { Type = ExamplePhone.PhoneType.Mobile, Number = "222" }},
				PhoneList = new ExamplePhoneList {
					new ExamplePhone() { Type = ExamplePhone.PhoneType.Home, Number = "111" },
					new ExamplePhone() { Type = ExamplePhone.PhoneType.Mobile, Number = "222" }}});
			jsonValue["Phone"][0]["Type"].TreatEnumAsInt = true;
			Debug.WriteLine(jsonValue.ToString());

			ExamplePerson2 person2 = jsonValue.Deserialize<ExamplePerson2>();
			Debug.WriteLine(JSONValue.Serialize(person2).ToString());


			// Be careful when parsing invalid strings, or when (implicitly or explicitly)
			// typecast values, because exception will be thrown on any invalid operation.

			// Also notice the difference between String typecast and ToString() method.
			// Typecast will simply convert object to String. ToString() methods makes
			// string representation of JSON value, so that String value <value1> becomes
			// <"value1">, as it would be in JSON representation. Also, <null> value becomes
			// <null> string in JSON. Use ToString() method to display JSON string,
			// and typecast to convert values.

			// I hope that you like this approach of making JSON for .NET simple and usable.
			// And that you enjoyed reading this tutorial, too.

			Console.ReadKey(false); return;
		}