json-serializer-deserializer.cs

// This is the short, one-file version of Json Parser (By JpRichardson, https://github.com/jprichardson/FridayThe13th)
// * Also, this file is with inline references to avoid "using" tags. 

namespace FridayThe13th
{
	public class JsonParser
	{ 
		public string author() { return "https://github.com/jprichardson/FridayThe13th"; }
	
		private int _line = 0;
		private int _column = 0;

		private string _jsonText = "";
		private int _index = 0;
		private System.Text.StringBuilder _sb = new System.Text.StringBuilder();

		public JsonParser() { CamelizeProperties = false; ExceptionOnParsingError = false; }

		public bool CamelizeProperties { get; set; }
		public bool ExceptionOnParsingError { get; set; }

		public int ErrorCount { get { return _errorMessages.Count; } }
		private System.Collections.Generic.List<string> _errorMessages = new System.Collections.Generic.List<string>();
		public System.Collections.Generic.IEnumerable<string> ErrorMessages { get { return _errorMessages; } }

		public dynamic Parse(string json)
		{
			Reset();
			_jsonText = json;
			return ParseValue();
		}

		public void Reset()
		{
			_index = _line = _column = 0;
			_errorMessages.Clear();
			_jsonText = "";
		}

		protected System.Collections.Generic.List<dynamic> ParseArray()
		{
			Read(); //read first [

			var list = new System.Collections.Generic.List<dynamic>();

			var doRead = true;
			while (doRead)
			{
				ReadWhitespace();
				switch (Peek())
				{
					case -1: ParseError("Unterminated array before end of json string."); return list;
					case ',':
						Read();
						break;
					case ']':
						Read();
						doRead = false;
						break;
					default:
						var val = ParseValue();
						list.Add(val);
						break;
				}
			}

			return list;
		}

		protected dynamic ParseObject()
		{
			Read(); //read first {
			ReadWhitespace();

			dynamic obj = new JsonObject();

			var doRead = true;
			while (doRead)
			{
				switch (Peek())
				{
					case -1: ParseError("Unterminated object before end of json string."); return obj;
					case ',':
						Read();
						break;
					case '}':
						Read();
						doRead = false;
						break;
					case '"':
						var key = ParseString();
						if (CamelizeProperties)
						{
							_sb.Clear();
							if (key.Contains("_"))
							{
								var words = key.Split('_');
								foreach (var w in words)
								{
									_sb.Append(w.Substring(0, 1).ToUpper());
									_sb.Append(w.Substring(1, w.Length - 1).ToLower());
								}
							}
							else
							{
								_sb.Append(key.Substring(0, 1).ToUpper());
								_sb.Append(key.Substring(1, key.Length - 1).ToLower());
							}

							key = _sb.ToString();
						}
						ReadWhitespace();
						ReadExpect(':');
						ReadWhitespace();
						var val = ParseValue();
						obj[key] = val;
						break;
					default:
						ReadWhitespace();
						break;
				}
			}

			return obj;
		}

		//not very robust.... yet
		////http://ecma262-5.com/ELS5_HTML.htm#Section_8.5
		protected double ParseNumber()
		{
			_sb.Clear();

			bool doRead = true;
			while (doRead)
			{
				var c = Peek();
				switch (c)
				{
					case '.':
					case '-':
					case '+':
					case 'e':
					case 'E':
						_sb.Append((char)c);
						Read();
						doRead = true;
						break;
					default:
						if (c >= '0' && c <= '9')
						{
							_sb.Append((char)c);
							Read();
							doRead = true;
						}
						else
							doRead = false;
						break;
				}
			}

			double number;
			bool couldParse = System.Double.TryParse(_sb.ToString(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out number);
			if (!couldParse)
			{
				number = System.Double.NaN;
				ParseError(string.Format("Could not parse {0} into a Double.", number));
			}

			return number;
		}

		protected string ParseString()
		{
			Read(); //read first "
			_sb.Clear();

			bool complete = false;
			while (!complete)
			{
				var c = Read();
				switch (c)
				{
					case -1: ParseError("Unterminated string before end of json string."); return _sb.ToString();
					case '"': complete = true; break;
					case '\\':
						var nc = Read();
						switch (nc)
						{
							case '"':
							case '\\':
							case '/':
								_sb.Append((char)nc);
								break;
							case 'b':
								_sb.Append('\b');
								break;
							case 'f':
								_sb.Append('\f');
								break;
							case 'n':
								_sb.Append('\n');
								break;
							case 'r':
								_sb.Append('\r');
								break;
							case 't':
								_sb.Append('\t');
								break;
							case 'u':
								ushort cp = 0;
								for (int i = 0; i < 4; i++)
								{
									if ((c = Read()) < 0)
										ParseError("Incomplete unicode.");
									cp *= 16;
									if ('0' <= c && c <= '9')
										cp += (ushort)(c - '0');
									if ('A' <= c && c <= 'F')
										cp += (ushort)(c - 'A' + 10);
									if ('a' <= c && c <= 'f')
										cp += (ushort)(c - 'a' + 10);
								}
								_sb.Append((char)cp);
								break;
						}
						break;
					default:
						_sb.Append((char)c);
						break;
				}
			}

			return _sb.ToString();
		}

		protected dynamic ParseValue()
		{
			ReadWhitespace();

			var c = Peek();
			switch (c)
			{
				case -1: ParseError("Unknown parsing error. Premature end of json string."); return null;
				case '{': return ParseObject();
				case '"': return ParseString();
				case '[': return ParseArray();
				case '-': return ParseNumber();
				case 't': if (TryRead("true")) { return true; } else { goto default; }
				case 'f': if (TryRead("false")) { return false; } else { goto default; }
				case 'n': if (TryRead("null")) { return null; } else { goto default; }
				default:
					if (c >= '0' && c <= '9')
						return ParseNumber();
					else
					{
						ParseError("Unrecognized JSON character token.");
						Read(); //get rid of bad character, go to next
						return ParseValue();
					}
			}
		}

		protected int Peek()
		{
			if (_index == _jsonText.Length)
				return -1; //EOF
			else
				return _jsonText[_index];
		}

		protected int Read()
		{
			if (_index == _jsonText.Length)
				return -1;
			else
			{
				int c = _jsonText[_index++];
				if (c == '\n')
				{
					_line++;
					_column = 0;
				}
				else
					_column++;

				return c;
			}
		}

		protected void ReadExpect(char c)
		{
			var expect = Read();
			if (expect == -1)
				ParseError(string.Format("Expected {0} but is at the end of the string.", c));
			else
				if (expect != c)
				ParseError(string.Format("Expected {0} but received {1}.", c, expect));
		}

		protected void ReadWhitespace()
		{
			bool doRead = true;
			while (doRead)
			{
				switch (Peek())
				{
					case ' ':
					case '\t':
					case '\r':
					case '\n':
						Read();
						break;
					default: doRead = false; break;
				}
			}
		}

		protected bool TryRead(string s)
		{
			bool success = true;
			for (var i = 0; i < s.Length; ++i)
				if (s[i] != Read())
				{
					_index = _index - i - 1;
					success = false;
					break;
				}
			return success;
		}

		protected void ParseError(string msg)
		{
			msg = string.Format("{0} ({1},{2})", msg, _line, _column);
			if (ExceptionOnParsingError)
				throw new System.Exception(msg);
			else
				_errorMessages.Add(msg);
		}

	}






	public class JsonObject : System.Dynamic.DynamicObject, System.ComponentModel.INotifyPropertyChanged
	{

		protected System.Collections.Generic.Dictionary<string, dynamic> _thisDict;

		public JsonObject()
		{
			_thisDict = new System.Collections.Generic.Dictionary<string, dynamic>();
		}

		public bool IsEmpty { get { return _thisDict.Count == 0; } }
		public System.Collections.Generic.IEnumerable<string> Keys { get { return _thisDict.Keys; } }
		public System.Collections.Generic.IEnumerable<dynamic> Values { get { return _thisDict.Values; } }

		public dynamic this[string key] { get { return _thisDict[key]; } set { _thisDict[key] = value; NotifyPropertyChanged(key); } }

		public void Add(string key, dynamic value)
		{
			_thisDict.Add(key, value);
			NotifyPropertyChanged(key);
		}

		public bool Remove(string key)
		{
			return _thisDict.Remove(key);
		}

		public void RemoveAll()
		{
			_thisDict.Clear();
		}

		public override bool TryGetMember(System.Dynamic.GetMemberBinder binder, out object result)
		{
			return _thisDict.TryGetValue(binder.Name, out result);
		}

		public override bool TrySetMember(System.Dynamic.SetMemberBinder binder, object value)
		{
			_thisDict[binder.Name] = value;
			NotifyPropertyChanged(binder.Name);
			return true;
		}

		public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
		public void NotifyPropertyChanged(string propertyName)
		{
			if (PropertyChanged != null)
				PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
		}
	}
}