/// <summary> /// Deserializes the custom object. /// </summary> /// <param name="o">The o.</param> /// <param name="type">The type.</param> /// <returns></returns> internal static object DeserializeCustomObject(JavaScriptObject o, Type type) { object c = Activator.CreateInstance(type); MemberInfo[] members = type.GetMembers(BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance); foreach (MemberInfo memberInfo in members) { if (memberInfo.MemberType == MemberTypes.Field) { if (o.Contains(memberInfo.Name)) { FieldInfo fieldInfo = (FieldInfo)memberInfo; fieldInfo.SetValue(c, JavaScriptDeserializer.Deserialize((IJavaScriptObject)o[fieldInfo.Name], fieldInfo.FieldType)); } } else if (memberInfo.MemberType == MemberTypes.Property) { if (o.Contains(memberInfo.Name)) { PropertyInfo propertyInfo = (PropertyInfo)memberInfo; if (propertyInfo.CanWrite) { propertyInfo.SetValue(c, JavaScriptDeserializer.Deserialize((IJavaScriptObject)o[propertyInfo.Name], propertyInfo.PropertyType), new object[0]); } } } } return(c); }
/// <summary> /// Converts an IJavaScriptObject into an NET object. /// </summary> /// <param name="o">The IJavaScriptObject object to convert.</param> /// <param name="t"></param> /// <returns>Returns a .NET object.</returns> public override object Deserialize(IJavaScriptObject o, Type t) { JavaScriptObject ht = o as JavaScriptObject; if (ht == null) { throw new NotSupportedException(); } if (!ht.Contains("Columns") || !(ht["Columns"] is JavaScriptArray) || !ht.Contains("Rows") || !(ht["Rows"] is JavaScriptArray)) { throw new NotSupportedException(); } JavaScriptArray columns = (JavaScriptArray)ht["Columns"]; JavaScriptArray rows = (JavaScriptArray)ht["Rows"]; DataTable dt = new DataTable(); DataRow row = null; Type colType; JavaScriptArray column; if (ht.Contains("TableName") && ht["TableName"] is JavaScriptString) { dt.TableName = ht["TableName"].ToString(); } for (int i = 0; i < columns.Count; i++) { column = (JavaScriptArray)columns[i]; colType = Type.GetType(column[1].ToString(), true); dt.Columns.Add(column[0].ToString(), colType); } JavaScriptArray cols = null; object obj; for (int y = 0; y < rows.Count; y++) { // if(!(r is JavaScriptArray)) // continue; cols = (JavaScriptArray)rows[y]; row = dt.NewRow(); for (int i = 0; i < cols.Count; i++) { //row[i] = JavaScriptDeserializer.Deserialize((IJavaScriptObject)cols[i], dt.Columns[i].DataType); obj = JavaScriptDeserializer.Deserialize((IJavaScriptObject)cols[i], dt.Columns[i].DataType); row[i] = (obj == null) ? DBNull.Value : obj; } dt.Rows.Add(row); } return(dt); }
/// <summary> /// Converts an IJavaScriptObject into an NET object. /// </summary> /// <param name="o">The IJavaScriptObject object to convert.</param> /// <param name="t"></param> /// <returns>Returns a .NET object.</returns> public override object Deserialize(IJavaScriptObject o, Type t) { JavaScriptObject jso = o as JavaScriptObject; if (!typeof(NameValueCollection).IsAssignableFrom(t) || jso == null) { throw new NotSupportedException(); } NameValueCollection list = (NameValueCollection)Activator.CreateInstance(t); if (!AjaxPro.Utility.Settings.OldStyle.Contains("renderJsonCompliant")) { if (!jso.Contains("keys") || !jso.Contains("values")) { throw new ArgumentException("Missing values for 'keys' and 'values'."); } JavaScriptArray keys = (JavaScriptArray)jso["keys"]; JavaScriptArray values = (JavaScriptArray)jso["values"]; if (keys.Count != values.Count) { throw new IndexOutOfRangeException("'keys' and 'values' have different length."); } for (int i = 0; i < keys.Count; i++) { list.Add(keys[i].ToString(), values[i].ToString()); } } else { foreach (string key in jso.Keys) { list.Add(key, jso[key].ToString()); } } return(list); }
/// <summary> /// Converts an IJavaScriptObject into an NET object. /// </summary> /// <param name="o">The IJavaScriptObject object to convert.</param> /// <param name="t"></param> /// <returns>Returns a .NET object.</returns> public override object Deserialize(IJavaScriptObject o, Type t) { JavaScriptObject ht = o as JavaScriptObject; if (ht == null) { throw new NotSupportedException(); } if (!ht.Contains("keys") || !ht.Contains("values")) { throw new NotSupportedException(); } IDictionary d = (IDictionary)Activator.CreateInstance(t); ParameterInfo[] p = t.GetMethod("Add").GetParameters(); Type kT = p[0].ParameterType; Type vT = p[1].ParameterType; object key; object value; JavaScriptArray keys = ht["keys"] as JavaScriptArray; JavaScriptArray values = ht["values"] as JavaScriptArray; for (int i = 0; i < keys.Count && i < values.Count; i++) { key = JavaScriptDeserializer.Deserialize(keys[i], kT); value = JavaScriptDeserializer.Deserialize(values[i], vT); d.Add(key, value); } return(d); }
/// <summary> /// Deserializes the custom object. /// </summary> /// <param name="o">The o.</param> /// <param name="type">The type.</param> /// <returns></returns> internal static object DeserializeCustomObject(JavaScriptObject o, Type type) { object c = Activator.CreateInstance(type); // TODO: is this a security problem? // if(o.GetType().GetCustomAttributes(typeof(AjaxClassAttribute), true).Length == 0) // throw new System.Security.SecurityException("Could not create class '" + type.FullName + "' because of missing AjaxClass attribute."); MemberInfo[] members = type.GetMembers(BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance); foreach (MemberInfo memberInfo in members) { if (memberInfo.MemberType == MemberTypes.Field) { if (o.Contains(memberInfo.Name)) { FieldInfo fieldInfo = (FieldInfo)memberInfo; fieldInfo.SetValue(c, JavaScriptDeserializer.Deserialize((IJavaScriptObject)o[fieldInfo.Name], fieldInfo.FieldType)); } } else if (memberInfo.MemberType == MemberTypes.Property) { if (o.Contains(memberInfo.Name)) { PropertyInfo propertyInfo = (PropertyInfo)memberInfo; if (propertyInfo.CanWrite) { propertyInfo.SetValue(c, JavaScriptDeserializer.Deserialize((IJavaScriptObject)o[propertyInfo.Name], propertyInfo.PropertyType), new object[0]); } } } } return(c); }
/// <summary> /// Converts an IJavaScriptObject into an NET object. /// </summary> /// <param name="o">The IJavaScriptObject object to convert.</param> /// <param name="t"></param> /// <returns>Returns a .NET object.</returns> public override object Deserialize(IJavaScriptObject o, Type t) { if (AjaxPro.Utility.Settings.OldStyle.Contains("renderJsonCompliant")) { return(new NotSupportedException("DataSets are not supported when renderJsonCompliant is configured.")); } JavaScriptObject ht = o as JavaScriptObject; if (ht == null) { throw new NotSupportedException(); } if (!ht.Contains("Tables") || !(ht["Tables"] is JavaScriptArray)) { throw new NotSupportedException(); } JavaScriptArray tables = (JavaScriptArray)ht["Tables"]; DataSet ds = new DataSet(); DataTable dt = null; foreach (IJavaScriptObject table in tables) { dt = (DataTable)JavaScriptDeserializer.Deserialize(table, typeof(DataTable)); if (dt != null) { ds.Tables.Add(dt); } } return(ds); }
/// <summary> /// Converts an XML document to an IJavaScriptObject (JSON). /// <see cref="http://www.xml.com/pub/a/2006/05/31/converting-between-xml-and-json.html?page=1">Stefan Goessner</see> /// <see cref="http://developer.yahoo.com/common/json.html#xml">Yahoo XML JSON</see> /// </summary> /// <param name="n">The XmlNode to serialize to JSON.</param> /// <returns>A IJavaScriptObject.</returns> public static IJavaScriptObject GetIJavaScriptObjectFromXmlNode(XmlNode n) { if (n == null) { return(null); } //if (xpath == "" || xpath == "/") // xpath = n.Name; System.Text.RegularExpressions.Regex r = new System.Text.RegularExpressions.Regex(@"\w+|\W+", System.Text.RegularExpressions.RegexOptions.Compiled); JavaScriptObject o = new JavaScriptObject(); if (n.NodeType == XmlNodeType.Element) { for (int i = 0; i < n.Attributes.Count; i++) { o.Add("@" + n.Attributes[i].Name, new JavaScriptString(n.Attributes[i].Value)); } if (n.FirstChild != null) // element has child nodes { int textChild = 0; bool hasElementChild = false; for (XmlNode e = n.FirstChild; e != null; e = e.NextSibling) { if (e.NodeType == XmlNodeType.Element) { hasElementChild = true; } if (e.NodeType == XmlNodeType.Text && r.IsMatch(e.InnerText)) { textChild++; // non-whitespace text } } if (hasElementChild) { if (textChild < 2) // structured element with evtl. a single text node { for (XmlNode e = n.FirstChild; e != null; e = e.NextSibling) { if (e.NodeType == XmlNodeType.Text) { o.Add("#text", new JavaScriptString(e.InnerText)); } else if (o.Contains(e.Name)) { if (o[e.Name] is JavaScriptArray) { ((JavaScriptArray)o[e.Name]).Add(GetIJavaScriptObjectFromXmlNode(e)); } else { IJavaScriptObject _o = o[e.Name]; JavaScriptArray a = new JavaScriptArray(); a.Add(_o); a.Add(GetIJavaScriptObjectFromXmlNode(e)); o[e.Name] = a; } } else { o.Add(e.Name, GetIJavaScriptObjectFromXmlNode(e)); } } } } else if (textChild > 0) { if (n.Attributes.Count == 0) { return(new JavaScriptString(n.InnerText)); } else { o.Add("#text", new JavaScriptString(n.InnerText)); } } } if (n.Attributes.Count == 0 && n.FirstChild == null) { return(new JavaScriptString(n.InnerText)); } } else if (n.NodeType == XmlNodeType.Document) { return(GetIJavaScriptObjectFromXmlNode(((XmlDocument)n).DocumentElement)); } else { throw new NotSupportedException("Unhandled node type '" + n.NodeType + "'."); } return(o); }
/// <summary> /// Converts an IJavaScriptObject into an NET object. /// </summary> /// <param name="o">The IJavaScriptObject object to convert.</param> /// <param name="type">The type to convert the object to.</param> /// <returns>Returns a .NET object.</returns> public static object Deserialize(IJavaScriptObject o, Type type) { if (o == null) { return(null); } // If the IJavaScriptObject is an JavaScriptObject and we have a key // __type we will override the Type that is passed to this method. This // will allow us to use implemented classes where the method will use // only the interface. JavaScriptObject jso = o as JavaScriptObject; if (jso != null && jso.Contains("__type")) { Type t = Type.GetType(jso["__type"].ToString()); if (type == null || type.IsAssignableFrom(t)) { type = t; } } IJavaScriptConverter c = null; #if (NET20) if (Utility.Settings.DeserializableConverters.TryGetValue(type, out c)) { #else if (Utility.Settings.DeserializableConverters.ContainsKey(type)) { c = (IJavaScriptConverter)Utility.Settings.DeserializableConverters[type]; #endif return(c.Deserialize(o, type)); } object v; #if (NET20) foreach (IJavaScriptConverter c2 in Utility.Settings.DeserializableConverters.Values) { if (c2.TryDeserializeValue(o, type, out v)) { return(v); } } #else IEnumerator m = Utility.Settings.DeserializableConverters.Values.GetEnumerator(); while (m.MoveNext()) { if (((IJavaScriptConverter)m.Current).TryDeserializeValue(o, type, out v)) { return(v); } } #endif #if (NET20) if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) { //Type n = typeof(Nullable<>); //Type constructed = n.MakeGenericType(type.GetGenericArguments()[0]); Type tval = type.GetGenericArguments()[0]; object va = Deserialize(o, tval); object val = Convert.ChangeType(va, tval); return(Activator.CreateInstance(type, val)); } #endif if (typeof(IJavaScriptObject).IsAssignableFrom(type)) { return(o); } if (o is JavaScriptObject) { return(DeserializeCustomObject(o as JavaScriptObject, type)); } throw new NotImplementedException("The object of type '" + o.GetType().FullName + "' could not converted to type '" + type + "'."); }
/// <summary> /// Retreives the parameters. /// </summary> /// <returns></returns> public override object[] RetreiveParameters() { context.Request.ContentEncoding = System.Text.UTF8Encoding.UTF8; ParameterInfo[] pi = method.GetParameters(); object[] args = new object[pi.Length]; // initialize default values for (int i = 0; i < pi.Length; i++) { args[i] = pi[i].DefaultValue; } byte[] b = new byte[context.Request.InputStream.Length]; if (context.Request.InputStream.Read(b, 0, b.Length) == 0) { return(null); } StreamReader sr = new StreamReader(new MemoryStream(b), System.Text.UTF8Encoding.UTF8); string v = null; try { v = sr.ReadToEnd(); } finally { sr.Close(); } // If something went wrong or there are no arguments // we can return with the empty argument array. if (v == null || pi.Length == 0 || v == "{}") { return(args); } hashCode = v.GetHashCode(); // check if we have to decrypt the JSON string. if (Utility.Settings != null && Utility.Settings.Security != null) { v = Utility.Settings.Security.SecurityProvider.Decrypt(v); } context.Items.Add(Constant.AjaxID + ".JSON", v); JavaScriptObject jso = (JavaScriptObject)JavaScriptDeserializer.DeserializeFromJson(v, typeof(JavaScriptObject)); for (int i = 0; i < pi.Length; i++) { if (jso.Contains(pi[i].Name)) { //if(pi[i].ParameterType.IsAssignableFrom(jso[pi[i].Name].GetType())) //{ // args[i] = jso[pi[i].Name]; //} //else { args[i] = JavaScriptDeserializer.Deserialize((IJavaScriptObject)jso[pi[i].Name], pi[i].ParameterType); } } } return(args); }