using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Reflection;
using System.Reflection.Emit;
using System.IO;
namespace fastJSON
{
public class JSON
{
public readonly static JSON Instance = new JSON();
private JSON()
{
}
public string ToJSON(object obj)
{
return ToJSON(obj, true);
}
public string ToJSON(object obj, bool useMinimalDataSetSchema)
{
return new JSONSerializer(useMinimalDataSetSchema).ConvertToJSON(obj);
}
public object ToObject(string json)
{
Dictionary<string, object> ht = new JsonParser(json).Decode() as Dictionary<string, object>;
if (ht == null) return null;
return ParseDictionary(ht);
}
#region [ PROPERTY GET SET CACHE ]
SafeDictionary<Type, string> _tyname = new SafeDictionary<Type, string>();
internal string GetTypeAssemblyName(Type t)
{
if(_tyname.ContainsKey(t))
return _tyname[t];
else
{
string s = t.AssemblyQualifiedName;
_tyname.Add(t,s);
return s;
}
}
SafeDictionary<string, Type> _typecache = new SafeDictionary<string, Type>();
private Type GetTypeFromCache(string typename)
{
if (_typecache.ContainsKey(typename))
return _typecache[typename];
else
{
Type t = Type.GetType(typename);
_typecache.Add(typename, t);
return t;
}
}
SafeDictionary<Type, CreateObject> _constrcache = new SafeDictionary<Type, CreateObject>();
private delegate object CreateObject();
private object FastCreateInstance(Type objtype)
{
CreateObject c = null;
if(_constrcache.ContainsKey(objtype))
{
c = _constrcache[objtype];
return c();
}
else
{
DynamicMethod dynMethod = new DynamicMethod("_", objtype, null);
ILGenerator ilGen = dynMethod.GetILGenerator();
ilGen.Emit(OpCodes.Newobj, objtype.GetConstructor(Type.EmptyTypes));
ilGen.Emit(OpCodes.Ret);
c = (CreateObject)dynMethod.CreateDelegate(typeof(CreateObject));
_constrcache.Add(objtype, c);
return c();
}
}
private struct myPropInfo
{
public bool filled;
public Type pt;
public Type changeType;
public bool isDictionary;
public bool isValueType;
public bool isGenericType;
public bool isArray;
public bool isByteArray;
public bool isGuid;
public bool isDataSet;
public bool isHashtable;
public GenericSetter setter;
public bool isEnum;
public bool isDateTime;
}
SafeDictionary<string, myPropInfo> _propertycache = new SafeDictionary<string, myPropInfo>();
private myPropInfo getproperty(Type type, string typename, string propertyname)
{
if (propertyname == "$type")
return new myPropInfo();
string n = string.Concat(typename, propertyname);
if (_propertycache.ContainsKey(n))
{
return _propertycache[n];
}
else
{
PropertyInfo[] pr = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo p in pr)
{
myPropInfo d = new myPropInfo();
d.filled = true;
d.pt = p.PropertyType;
d.isDictionary = p.Name.Contains("Dictionary");
d.isValueType = p.PropertyType.IsValueType;
d.isGenericType = p.PropertyType.IsGenericType;
d.isArray = p.PropertyType.IsArray;
d.isByteArray = p.PropertyType == typeof(byte[]);
d.isGuid = (p.PropertyType == typeof(Guid) || p.PropertyType == typeof(Guid?));
d.isHashtable = p.PropertyType == typeof(Hashtable);
d.isDataSet = p.PropertyType == typeof(DataSet);
d.setter = CreateSetMethod(p);
d.changeType = GetChangeType(p.PropertyType);
d.isEnum = p.PropertyType.IsEnum;
d.isDateTime = p.PropertyType == typeof(DateTime) || p.PropertyType == typeof(DateTime?);
string nn = string.Concat(typename, p.Name);
if (_propertycache.ContainsKey(nn) == false)
_propertycache.Add(nn, d);
}
return _propertycache[n];
}
}
private delegate void GenericSetter(object target, object value);
private static GenericSetter CreateSetMethod(PropertyInfo propertyInfo)
{
MethodInfo setMethod = propertyInfo.GetSetMethod();
if (setMethod == null)
return null;
Type[] arguments = new Type[2];
arguments[0] = arguments[1] = typeof(object);
DynamicMethod setter = new DynamicMethod("_", typeof(void), arguments, propertyInfo.DeclaringType);
ILGenerator il = setter.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
il.Emit(OpCodes.Ldarg_1);
if (propertyInfo.PropertyType.IsClass)
il.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
else
il.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
il.EmitCall(OpCodes.Callvirt, setMethod, null);
il.Emit(OpCodes.Ret);
return (GenericSetter)setter.CreateDelegate(typeof(GenericSetter));
}
internal delegate object GenericGetter(object obj);
private GenericGetter CreateGetMethod(PropertyInfo propertyInfo)
{
MethodInfo getMethod = propertyInfo.GetGetMethod();
if (getMethod == null)
return null;
Type[] arguments = new Type[1];
arguments[0] = typeof(object);
DynamicMethod getter = new DynamicMethod("_", typeof(object), arguments);
ILGenerator il = getter.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
il.EmitCall(OpCodes.Callvirt, getMethod, null);
if (!propertyInfo.PropertyType.IsClass)
il.Emit(OpCodes.Box, propertyInfo.PropertyType);
il.Emit(OpCodes.Ret);
return (GenericGetter)getter.CreateDelegate(typeof(GenericGetter));
}
readonly SafeDictionary<Type, List<Getters>> _getterscache = new SafeDictionary<Type, List<Getters>>();
internal List<Getters> GetGetters(Type type)
{
if (_getterscache.ContainsKey(type)) return _getterscache[type];
PropertyInfo[] props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
List<Getters> getters = new List<Getters>();
foreach (PropertyInfo p in props)
{
if (!p.CanWrite) continue;
JSON.GenericGetter g = CreateGetMethod(p);
if (g != null)
{
Getters gg = new Getters();
gg.Name = p.Name;
gg.Getter = g;
getters.Add(gg);
}
}
_getterscache.Add(type, getters);
return getters;
}
#endregion
private object ParseDictionary(Dictionary<string, object> d)
{
string tn = d["$type"].ToString();
Type type = GetTypeFromCache(tn);
string typename = type.Name;
object o = FastCreateInstance(type);
foreach (string name in d.Keys)
{
myPropInfo pi = getproperty(type, typename, name);
if (pi.filled == true )
{
object v = d[name];
if (v != null)
{
object oset = null;
if (pi.isGenericType && pi.isValueType == false && pi.isDictionary == false)
oset = CreateGenericList(v as ArrayList, pi.pt);
else if (pi.isByteArray)
oset = Convert.FromBase64String((v as string));
else if (pi.isArray && pi.isValueType == false)
oset = CreateArray(v as ArrayList, pi.pt);
else if (pi.isGuid)
oset = new Guid((v as string));
else if (pi.isDataSet)
oset = CreateDataset((v as Dictionary<string, object>));
else if (pi.isDictionary || pi.isHashtable)
oset = CreateDictionary((v as ArrayList), pi.pt);
else if(pi.isEnum)
oset = Enum.Parse(pi.pt,v as string);
else if(pi.isDateTime)
oset = CreateDateTime(v as string);
else
oset = Convert.ChangeType(v, pi.changeType, CultureInfo.InvariantCulture);
pi.setter(o, oset);
}
}
}
return o;
}
private DateTime CreateDateTime(string value)
{
// 0123456789012345678
// datetime format = yyyy-MM-dd HH:mm:ss
int year = int.Parse(value.Substring(0,4));
int month = int.Parse(value.Substring(5,2));
int day = int.Parse(value.Substring(8,2));
int hour = int.Parse(value.Substring(11,2));
int min = int.Parse(value.Substring(14,2));
int sec = int.Parse(value.Substring(17,2));
return new DateTime(year,month,day,hour,min,sec);
}
private object CreateArray(ArrayList data, Type pt)
{
ArrayList col = new ArrayList();
Type bt = pt.GetElementType();
// create an array of objects
foreach (object ob in data)
{
if (ob is IDictionary)
col.Add(ParseDictionary((ob as Dictionary<string, object>)));
else
col.Add(ob);
}
return col.ToArray(bt);
}
private object CreateGenericList(ArrayList data, Type pt)
{
IList col = (IList)FastCreateInstance(pt);
// create an array of objects
foreach (object ob in data)
{
if (ob is IDictionary)
col.Add(ParseDictionary(ob as Dictionary<string, object>));
else
col.Add(ob);
}
return col;
}
private object CreateDictionary(ArrayList reader, Type pt)
{
IDictionary col = (FastCreateInstance(pt) as IDictionary);
Type[] types = col.GetType().GetGenericArguments();
foreach (Dictionary<string, object> values in reader)
{
object key = values["k"];
object val = values["v"];
if (key is Dictionary<string, object>)
key = ParseDictionary((Dictionary<string, object>)key);
else
key = ChangeType(key, types[0]);
if (val is Dictionary<string, object>)
val = ParseDictionary((Dictionary<string, object>)val);
else
val = ChangeType(val, types[1]);
col.Add(key, val);
}
return col;
}
SafeDictionary<Type, Type> _changetype = new SafeDictionary<Type, Type>();
private object ChangeType(object value, Type conversionType)
{
if (_changetype.ContainsKey(conversionType))
conversionType = _changetype[conversionType];
else
{
Type t = GetChangeType(conversionType);
_changetype.Add(conversionType, t);
conversionType = t;
}
return Convert.ChangeType(value, conversionType, CultureInfo.InvariantCulture);
}
private Type GetChangeType(Type conversionType)
{
if (conversionType.IsGenericType &&
conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
return conversionType.GetGenericArguments()[0];
}
return conversionType;
}
private DataSet CreateDataset(Dictionary<string, object> reader)
{
DataSet ds = new DataSet();
ds.EnforceConstraints = false;
ds.BeginInit();
// read dataset schema here
var schema = reader["$schema"];
if (schema is string)
{
TextReader tr = new StringReader((string)schema);
ds.ReadXmlSchema(tr);
}
else
{
DatasetSchema ms = (DatasetSchema)ParseDictionary((Dictionary<string, object>)schema);
ds.DataSetName = ms.Name;
for (int i = 0; i < ms.Info.Count; i += 3)
{
if (ds.Tables.Contains(ms.Info[i]) == false)
ds.Tables.Add(ms.Info[i]);
ds.Tables[ms.Info[i]].Columns.Add(ms.Info[i + 1], Type.GetType(ms.Info[i + 2]));
}
}
foreach (KeyValuePair<string, object> pair in reader)
{
if (pair.Key == "$type" || pair.Key == "$schema") continue;
ArrayList rows = pair.Value as ArrayList;
if (rows == null) continue;
DataTable dt = ds.Tables[pair.Key];
dt.BeginInit();
dt.BeginLoadData();
foreach (Dictionary<string, object> row in rows)
{
object[] v = new object[row.Values.Count];
row.Values.CopyTo(v, 0);
dt.Rows.Add(v);
}
dt.EndLoadData();
dt.EndInit();
}
ds.EndInit();
return ds;
}
}
}
Submit an article or tip