public static void RegisterExporter <T>(ExporterFunc <T> exporter) { custom_exporters_table[typeof(T)] = (obj, writer) => exporter((T)obj, writer); }
private static void RegisterUnityExporters() { ExporterFunc <Vector2> vec2exporter; vec2exporter = new ExporterFunc <Vector2>(delegate(Vector2 obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Vector2>(vec2exporter); ExporterFunc <Vector3> vec3exporter; vec3exporter = new ExporterFunc <Vector3>(delegate(Vector3 obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Vector3>(vec3exporter); ExporterFunc <Vector4> vec4exporter; vec4exporter = new ExporterFunc <Vector4>(delegate(Vector4 obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Vector4>(vec4exporter); ExporterFunc <Vector2Int> vec2Intexporter; vec2Intexporter = new ExporterFunc <Vector2Int>(delegate(Vector2Int obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Vector2Int>(vec2Intexporter); ExporterFunc <Vector3Int> vec3Intexporter; vec3Intexporter = new ExporterFunc <Vector3Int>(delegate(Vector3Int obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Vector3Int>(vec3Intexporter); ExporterFunc <Rect> rectexporter; rectexporter = new ExporterFunc <Rect>(delegate(Rect obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Rect>(rectexporter); ExporterFunc <RectInt> rectIntexporter; rectIntexporter = new ExporterFunc <RectInt>(delegate(RectInt obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <RectInt>(rectIntexporter); ExporterFunc <Color> colorexporter; colorexporter = new ExporterFunc <Color>(delegate(Color obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Color>(colorexporter); ExporterFunc <Color32> color32exporter; color32exporter = new ExporterFunc <Color32>(delegate(Color32 obj, JsonWriter writer) { writer.Write(TypeConvert.ToString(obj)); }); JsonMapper.RegisterExporter <Color32>(color32exporter); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { writer.Write("[MAX_NESTING]"); return; } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Single) { writer.Write((float)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in (IDictionary)obj) { writer.WritePropertyName(entry.Key.ToString()); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object #if USE_REFLECTION AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { if (p_data.IsField) { writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } /* sparedes 20130802: Disable property inspection to avoid circular references which are likely to happen on this. * else { * PropertyInfo p_info = (PropertyInfo) p_data.Info; * * if (p_info.CanRead) { * writer.WritePropertyName (p_data.Info.Name); * WriteValue (p_info.GetValue (obj, null), * writer, writer_is_private, depth + 1); * } * }*/ } writer.WriteObjectEnd(); #else throw new JsonException(string.Format("Can not serialize {0} without System.Reflection.", obj_type)); #endif }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > JsonMapper.max_nesting_depth) { JsonException.Throw(new JsonException(string.Format("Max allowed object depth reached while trying to export from type {0}", obj.GetType()))); } if (obj == null) { writer.Write(null); } else if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } } else if (obj is string) { writer.Write((string)obj); } else if (obj is double) { writer.Write((double)obj); } else if (obj is int) { writer.Write((int)obj); } else if (obj is bool) { writer.Write((bool)obj); } else if (obj is long) { writer.Write((long)obj); } else if (obj is Array) { writer.WriteArrayStart(); foreach (object current in ((Array)obj)) { JsonMapper.WriteValue(current, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); } else if (obj is IList) { writer.WriteArrayStart(); foreach (object current in ((IList)obj)) { JsonMapper.WriteValue(current, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); } else if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry dictionaryEntry in ((IDictionary)obj)) { writer.WritePropertyName((string)dictionaryEntry.Key); JsonMapper.WriteValue(dictionaryEntry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); } else { Type type = obj.GetType(); if (JsonMapper.custom_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc = JsonMapper.custom_exporters_table[type]; exporterFunc(obj, writer); } else if (JsonMapper.base_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc = JsonMapper.base_exporters_table[type]; exporterFunc(obj, writer); } else if (obj is Enum) { Type underlyingType = Enum.GetUnderlyingType(type); if (underlyingType == typeof(long) || underlyingType == typeof(uint) || underlyingType == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } } else { JsonMapper.AddTypeProperties(type); IList <PropertyMetadata> list = JsonMapper.type_properties[type]; writer.WriteObjectStart(); foreach (PropertyMetadata current2 in list) { if (current2.IsField) { writer.WritePropertyName(current2.Info.Name); JsonMapper.WriteValue(((FieldInfo)current2.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo propertyInfo = (PropertyInfo)current2.Info; if (propertyInfo.CanRead) { writer.WritePropertyName(current2.Info.Name); JsonMapper.WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); } } }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in (IDictionary)obj) { writer.WritePropertyName((string)entry.Key); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } #region dx //如果定义了这个对象应该被忽略 if (JsonTypeRegister.listIgnoreClass.Contains(obj_type)) { return; } //xuexueJsonClass xxjc = obj.GetType().GetCustomAttribute<xuexueJsonClass>(); //if (xxjc.intermediary != null) //{ // IIntermediary obj_im = Activator.CreateInstance(xxjc.intermediary) as IIntermediary; // obj_im.InitWithTarget(obj);//从目标类型读值 // obj = obj_im; // obj_type = xxjc.intermediary;//目标类型已经没用了,全部换过来 //} #endregion // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { if (p_data.IsField) { writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; if (p_info.CanRead) { writer.WritePropertyName(p_data.Info.Name); WriteValue(p_info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } #region UnityEngine specific #if UNITY3D if (obj is UnityEngine.Vector2) { writer.Write((UnityEngine.Vector2)obj); return; } if (obj is UnityEngine.Vector3) { writer.Write((UnityEngine.Vector3)obj); return; } if (obj is UnityEngine.Vector4) { writer.Write((UnityEngine.Vector4)obj); return; } if (obj is UnityEngine.Quaternion) { writer.Write((UnityEngine.Quaternion)obj); return; } if (obj is UnityEngine.Matrix4x4) { writer.Write((UnityEngine.Matrix4x4)obj); return; } if (obj is UnityEngine.Ray) { writer.Write((UnityEngine.Ray)obj); return; } if (obj is UnityEngine.RaycastHit) { writer.Write((UnityEngine.RaycastHit)obj); return; } if (obj is UnityEngine.Color) { writer.Write((UnityEngine.Color)obj); return; } #endif #endregion if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in (IDictionary)obj) { writer.WritePropertyName((string)entry.Key); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table [obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table [obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties [obj_type]; // TODO Class wide ignore attributes must be handled already before creating the JSON object writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { #if UNITY3D // Skip certain UnityEngine specific types that can't be serialized if (IsUnserializableUnityType(p_data)) { continue; } #endif // Skip certain fields / properties that has the Ignore Attribute set if (IsPropertyIgnored(p_data)) { continue; } if (p_data.IsField) { writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; if (p_info.CanRead) { writer.WritePropertyName(p_data.Info.Name); WriteValue(p_info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }
public static void RegisterExporter(Type tp, ExporterFunc exporter) { JsonMapper.custom_exporters_table[tp] = exporter; }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException($"Max allowed object depth reached while trying to export from type {obj.GetType()}"); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is string) { writer.Write((string)obj); return; } if (obj is double) { writer.Write((double)obj); return; } if (obj is int) { writer.Write((int)obj); return; } if (obj is bool) { writer.Write((bool)obj); return; } if (obj is long) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object item in (Array)obj) { WriteValue(item, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object item2 in (IList)obj) { WriteValue(item2, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry item3 in (IDictionary)obj) { writer.WritePropertyName((string)item3.Key); WriteValue(item3.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type type = obj.GetType(); if (custom_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc = custom_exporters_table[type]; exporterFunc(obj, writer); return; } if (base_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc = base_exporters_table[type]; exporterFunc(obj, writer); return; } if (obj is Enum) { Type underlyingType = Enum.GetUnderlyingType(type); if (underlyingType == typeof(long) || underlyingType == typeof(uint) || underlyingType == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } AddTypeProperties(type); IList <PropertyMetadata> list = type_properties[type]; writer.WriteObjectStart(); foreach (PropertyMetadata item4 in list) { if ((item4.Ignore & JsonIgnoreWhen.Serializing) > JsonIgnoreWhen.Never) { continue; } if (item4.IsField) { writer.WritePropertyName(item4.Info.Name); WriteValue(((FieldInfo)item4.Info).GetValue(obj), writer, writer_is_private, depth + 1); continue; } PropertyInfo propertyInfo = (PropertyInfo)item4.Info; if (propertyInfo.CanRead) { writer.WritePropertyName(item4.Info.Name); WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1); } } writer.WriteObjectEnd(); }
public static void RegisterExporter <T>(ExporterFunc <T> exporter) { ExporterFunc exporter_wrapper = delegate(object obj, JsonWriter writer) { exporter((T)obj, writer); }; custom_exporters_table[typeof(T)] = exporter_wrapper; }
public static void RegisterExporter <T>(ExporterFunc <T> exporter) { ExporterFunc exporterFunc = (ExporterFunc)((obj, writer) => exporter((T)obj, writer)); JsonMapper.custom_exporters_table[typeof(T)] = exporterFunc; }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}{1}", obj.GetType(), obj)); } //Null handler if (obj == null) { writer.Write(null); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object FIRST as in BEFORE ANYTHING ELSE!!! Love, Mark if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } /*** Check Base Types ***/ if (obj.GetType().ToString() == "System.MonoType") { writer.Write(obj.ToString()); return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { Type valueType = obj.GetType().GetGenericArguments()[0]; writer.WriteArrayStart(); foreach (object elem in (IList)obj) { if (!valueType.IsAbstract) { WriteValue(elem, writer, writer_is_private, depth + 1); } else { writer.WriteObjectStart(); writer.WritePropertyName(elem.GetType().ToString()); WriteValue(elem, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); } } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); IDictionary dict = (IDictionary)obj; Type curType = obj.GetType(); bool isDict = typeof(IDictionary).IsAssignableFrom(curType); while (isDict) { isDict = typeof(IDictionary).IsAssignableFrom(curType.BaseType); if (isDict) { curType = curType.BaseType; } } Type valueType = curType.GetGenericArguments()[1]; foreach (DictionaryEntry entry in dict) { //This next line means we can't have anything but base types as keys. Love, Mark //writer.WritePropertyName (entry.Key.ToString()); if (IsBaseType(entry.Key)) { writer.WritePropertyName(entry.Key.ToString()); } else { JsonWriter newWriter = new JsonWriter(); JsonMapper.ToJson(entry.Key, newWriter); //string key = writer.JsonToString(newWriter.ToString()); string key = newWriter.ToString(); writer.WritePropertyName(key); } if (!valueType.IsAbstract) { WriteValue(entry.Value, writer, writer_is_private, depth + 1); } else { //Creates a second layer that stores the child type key of the object for decoding writer.WriteObjectStart(); if (entry.Value != null) { writer.WritePropertyName(entry.Value.GetType().ToString()); } else { writer.WritePropertyName("null"); } WriteValue(entry.Value, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); } } writer.WriteObjectEnd(); return; } /*Type obj_type = obj.GetType (); * * // See if there's a custom exporter for the object * if (custom_exporters_table.ContainsKey (obj_type)) { * ExporterFunc exporter = custom_exporters_table[obj_type]; * exporter (obj, writer); * * return; * }*/ // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { bool skip = false; bool force = false; System.Object[] attrs = p_data.Info.GetCustomAttributes(false); if (attrs.Length > 0) { for (int j = 0; j < attrs.Length; j++) { if (attrs[j].GetType() == typeof(SkipSerialization)) { skip = true; break; } if (attrs[j].GetType() == typeof(ForceSerialization)) { force = true; break; } } } if (skip) { continue; } if (p_data.IsField) { FieldInfo f_info = ((FieldInfo)p_data.Info); if (f_info.GetValue(obj) == null && !force) { continue; } writer.WritePropertyName(p_data.Info.Name); if (f_info.FieldType.IsAbstract) { writer.WriteObjectStart(); writer.WritePropertyName(f_info.GetValue(obj).GetType().ToString()); depth++; } WriteValue(f_info.GetValue(obj), writer, writer_is_private, depth + 1); if (f_info.FieldType.IsAbstract) { writer.WriteObjectEnd(); } } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; if (p_info.CanRead) { object propertyValue = GetPropertyValue(obj, p_info); if (propertyValue == null && !force) { continue; } writer.WritePropertyName(p_data.Info.Name); if (p_info.PropertyType.IsAbstract) { writer.WriteObjectStart(); //writer.WritePropertyName(p_info.GetValue(obj, null).GetType().ToString()); writer.WritePropertyName(propertyValue.GetType().ToString()); depth++; } //WriteValue (p_info.GetValue (obj, null), writer, writer_is_private, depth + 1); WriteValue(propertyValue, writer, writer_is_private, depth + 1); if (p_info.PropertyType.IsAbstract) { writer.WriteObjectEnd(); } } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in (IDictionary)obj) { writer.WritePropertyName((string)entry.Key.ToString()); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { // Don't serialize a field or property if if (p_data.Include == false) { continue; } // havoc here 2 if (p_data.IsField) { FieldInfo fInfo = ((FieldInfo)p_data.Info); //Changed: Only write data if field does NOT have the [NonSerialized] Attribute and does NOT have the XmlIgnore Attribute if (fInfo.IsNotSerialized == false //&& !fInfo.GetCustomAttributes(false).Any(a => a is System.Xml.Serialization.XmlIgnoreAttribute) //&& !fInfo.GetCustomAttributes(false).Any(a => a is System.Runtime.Serialization.IgnoreDataMemberAttribute) ) { writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; //Changed: Only write to json if property can be written to // if (p_info.CanRead && p_info.CanWrite // //&& (p_info.GetSetMethod(true) != null && !p_info.GetSetMethod(true).IsPrivate) // //&& !p_info.GetCustomAttributes(false).Any(a => a is System.Xml.Serialization.XmlIgnoreAttribute) // && p_info.GetCustomAttributes(false).Any(a => a is Service.Serializer.Serialize) // ) { if (p_info.CanRead && p_info.CanWrite //&& !p_info.GetCustomAttributes(false).Any(a => a is System.Runtime.Serialization.IgnoreDataMemberAttribute) ) { writer.WritePropertyName(p_data.Info.Name); WriteValue(p_info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { Debug.LogError("writer" + writer.ToString()); throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is float) { writer.Write((float)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); List <DictionaryEntry> entries = new List <DictionaryEntry>(); foreach (DictionaryEntry entry in (IDictionary)obj) { entries.Add(entry); } entries.Sort((kv1, kv2) => { return(kv1.Key.GetHashCode() - kv2.Key.GetHashCode()); if (kv1.Key is int && kv2.Key is int) { return((int)kv1.Key - (int)kv2.Key); } if (kv1.Key is IComparable && kv2.Key is IComparable) { return(((IComparable)kv1.Key).CompareTo(kv2.Key)); } return(kv1.Key.GetHashCode() - kv2.Key.GetHashCode()); }); foreach (DictionaryEntry entry in entries) { writer.WritePropertyName(entry.Key.ToString()); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type; if (obj is ILRuntime.Runtime.Intepreter.ILTypeInstance) { obj_type = ((ILRuntime.Runtime.Intepreter.ILTypeInstance)obj).Type.ReflectionType; } else if (obj is ILRuntime.Runtime.Enviorment.CrossBindingAdaptorType) { obj_type = ((ILRuntime.Runtime.Enviorment.CrossBindingAdaptorType)obj).ILInstance.Type.ReflectionType; } else { obj_type = obj.GetType(); } // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { if (p_data.IsField) { if (((FieldInfo)p_data.Info).IsStatic || obj_type == p_data.Type) { continue; } writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; if (/*p_info.GetAccessors(true)[0].IsStatic|| */ obj_type == p_info.PropertyType) { continue; } if (p_info.CanRead) { writer.WritePropertyName(p_data.Info.Name); WriteValue(p_info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth, bool withTypeInfo = false) { if (depth > max_nesting_depth) { throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); Type t = obj.GetType().GetElementType(); foreach (object elem in (Array)obj) { currentMemberType = t; WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); Type t = obj.GetType().GetGenericArguments()[0]; foreach (object elem in (IList)obj) { currentMemberType = t; WriteValue(elem, writer, writer_is_private, depth + 1, withTypeInfo); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); Type t = obj.GetType().GetGenericArguments()[1]; foreach (DictionaryEntry entry in (IDictionary)obj) { currentMemberType = t; writer.WritePropertyName((string)entry.Key); WriteValue(entry.Value, writer, writer_is_private, depth + 1, withTypeInfo); } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); if (withTypeInfo && currentMemberType != null) { // include typeinfo as string in the serialized object writer.WritePropertyName(keyTypeInfo); // get qualified type name and trim it to contain only the necessary parts(reduce json size) string qualifiedname = obj_type.AssemblyQualifiedName; qualifiedname = rexQualifiedName.Replace(qualifiedname, ""); writer.Write(qualifiedname); } foreach (PropertyMetadata p_data in props) { currentMemberType = null; // Don't serialize a field or property with the JsonIgnore attribute with serialization usage if ((p_data.Ignore & JsonIgnoreWhen.Serializing) > 0) { continue; } if (p_data.IsField) { writer.WritePropertyName(p_data.Info.Name); FieldInfo info = (FieldInfo)p_data.Info; var val = info.GetValue(obj); if (withTypeInfo && val != null) { if (val.GetType().IsSubclassOf(info.FieldType)) { currentMemberType = val.GetType(); Console.WriteLine("write type info for " + currentMemberType); } } WriteValue(val, writer, writer_is_private, depth + 1, withTypeInfo); } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; var val = p_info.GetValue(obj, null); if (withTypeInfo) { if (val != null && val.GetType().IsSubclassOf(p_info.PropertyType)) { currentMemberType = val.GetType(); Console.WriteLine("write type info for " + currentMemberType); } } if (p_info.CanRead) { writer.WritePropertyName(p_data.Info.Name); WriteValue(val, writer, writer_is_private, depth + 1, withTypeInfo); } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException(String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Single) { writer.Write((float)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } #if UNITY_2018_3_OR_NEWER if (obj is IDictionary dictionary) { #else if (obj is IDictionary) { var dictionary = obj as IDictionary; #endif writer.WriteObjectStart(); foreach (DictionaryEntry entry in dictionary) { #if UNITY_2018_3_OR_NEWER var propertyName = entry.Key is string key ? key : Convert.ToString(entry.Key, CultureInfo.InvariantCulture); #else var propertyName = entry.Key is string?(entry.Key as string) : Convert.ToString(entry.Key, CultureInfo.InvariantCulture); #endif writer.WritePropertyName(propertyName); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); writer.WritePropertyName("_t"); writer.Write(obj_type.Name); foreach (PropertyMetadata p_data in props) { var skipAttributesList = p_data.Info.GetCustomAttributes(typeof(IgnoreDataMemberAttribute), true); var skipAttributes = skipAttributesList as ICollection <Attribute>; if (skipAttributes.Count > 0) { continue; } if (p_data.IsField) { writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; if (p_info.CanRead) { writer.WritePropertyName(p_data.Info.Name); WriteValue(p_info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }
public static void RegisterExporter <T>(ExporterFunc <T> exporter) { JsonMapper.< > c__DisplayClass37 <T> < > c__DisplayClass = new JsonMapper.< > c__DisplayClass37 <T>();
/// <summary> /// Registers the exporter. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="exporter">The exporter.</param> internal void RegisterExporter <T>(ExporterFunc <T> exporter) { ExporterFunc exporterWrapper = (obj, writer) => exporter((T)obj, writer); _customExportersTable[typeof(T)] = exporterWrapper; }
/** */ public static void RegisterExporter(Type tp, ExporterFunc exporter) { custom_exporters_table[tp] = exporter; }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > JsonMapper.max_nesting_depth) { throw new JsonException(string.Format("Max allowed object depth reached while trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is string) { writer.Write((string)obj); return; } if (obj is double) { writer.Write((double)obj); return; } if (obj is float) { writer.Write((double)((float)obj)); return; } if (obj is int) { writer.Write((int)obj); return; } if (obj is bool) { writer.Write((bool)obj); return; } if (obj is long) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); IEnumerator enumerator = ((Array)obj).GetEnumerator(); try { while (enumerator.MoveNext()) { object obj2 = enumerator.Current; JsonMapper.WriteValue(obj2, writer, writer_is_private, depth + 1); } } finally { IDisposable disposable; if ((disposable = (enumerator as IDisposable)) != null) { disposable.Dispose(); } } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); IEnumerator enumerator2 = ((IList)obj).GetEnumerator(); try { while (enumerator2.MoveNext()) { object obj3 = enumerator2.Current; JsonMapper.WriteValue(obj3, writer, writer_is_private, depth + 1); } } finally { IDisposable disposable2; if ((disposable2 = (enumerator2 as IDisposable)) != null) { disposable2.Dispose(); } } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); IDictionaryEnumerator enumerator3 = ((IDictionary)obj).GetEnumerator(); try { while (enumerator3.MoveNext()) { object obj4 = enumerator3.Current; DictionaryEntry dictionaryEntry = (DictionaryEntry)obj4; writer.WritePropertyName((string)dictionaryEntry.Key); JsonMapper.WriteValue(dictionaryEntry.Value, writer, writer_is_private, depth + 1); } } finally { IDisposable disposable3; if ((disposable3 = (enumerator3 as IDisposable)) != null) { disposable3.Dispose(); } } writer.WriteObjectEnd(); return; } Type type = obj.GetType(); if (JsonMapper.custom_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc = JsonMapper.custom_exporters_table[type]; exporterFunc(obj, writer); return; } if (JsonMapper.base_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc2 = JsonMapper.base_exporters_table[type]; exporterFunc2(obj, writer); return; } if (obj is Enum) { Type underlyingType = Enum.GetUnderlyingType(type); if (underlyingType == typeof(long) || underlyingType == typeof(uint) || underlyingType == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } JsonMapper.AddTypeProperties(type); IList <PropertyMetadata> list = JsonMapper.type_properties[type]; writer.WriteObjectStart(); foreach (PropertyMetadata propertyMetadata in list) { if (propertyMetadata.IsField) { writer.WritePropertyName(propertyMetadata.Info.Name); JsonMapper.WriteValue(((FieldInfo)propertyMetadata.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo propertyInfo = (PropertyInfo)propertyMetadata.Info; if (propertyInfo.CanRead) { writer.WritePropertyName(propertyMetadata.Info.Name); JsonMapper.WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException(string.Format("Max allowed object depth reached while trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write((string)null); } else if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } } else if (obj is string) { writer.Write((string)obj); } else if (obj is double) { writer.Write((double)obj); } else if (obj is int) { writer.Write((int)obj); } else if (obj is bool) { writer.Write((bool)obj); } else if (obj is long) { writer.Write((long)obj); } else if (obj is Array) { writer.WriteArrayStart(); foreach (object obj2 in (Array)obj) { WriteValue(obj2, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); } else if (obj is IList) { writer.WriteArrayStart(); foreach (object obj3 in (IList)obj) { WriteValue(obj3, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); } else if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in (IDictionary)obj) { writer.WritePropertyName((string)entry.Key); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); } else { Type key = obj.GetType(); if (custom_exporters_table.ContainsKey(key)) { ExporterFunc func = custom_exporters_table[key]; func(obj, writer); } else if (base_exporters_table.ContainsKey(key)) { ExporterFunc func2 = base_exporters_table[key]; func2(obj, writer); } else if (obj is Enum) { Type underlyingType = Enum.GetUnderlyingType(key); if (((underlyingType == typeof(long)) || (underlyingType == typeof(uint))) || (underlyingType == typeof(ulong))) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } } else { AddTypeProperties(key); IList <PropertyMetadata> list = type_properties[key]; writer.WriteObjectStart(); foreach (PropertyMetadata metadata in list) { if (metadata.IsField) { writer.WritePropertyName(metadata.Info.Name); WriteValue(((FieldInfo)metadata.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo info = (PropertyInfo)metadata.Info; if (info.CanRead) { writer.WritePropertyName(metadata.Info.Name); WriteValue(info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); } } }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException( string.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is string) { writer.Write((string)obj); return; } if (obj is double) { writer.Write((double)obj); return; } if (obj is int) { writer.Write((int)obj); return; } if (obj is bool) { writer.Write((bool)obj); return; } if (obj is long) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); Array arr = (Array)obj; Type elemType = arr.GetType().GetElementType(); foreach (object elem in arr) { // if the collection contains polymorphic elements, we need to include type information for deserialization if (writer.TypeHinting && elem != null & elem.GetType() != elemType) { writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(elem.GetType().FullName); writer.WritePropertyName(writer.HintValueName); WriteValue(elem, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(elem, writer, writer_is_private, depth + 1); } } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); IList list = (IList)obj; // collection might be non-generic type like Arraylist Type elemType = typeof(object); if (list.GetType().GetGenericArguments().Length > 0) { // collection is a generic type like List<T> elemType = list.GetType().GetGenericArguments()[0]; } foreach (object elem in list) { // if the collection contains polymorphic elements, we need to include type information for deserialization if (writer.TypeHinting && elem != null && elem.GetType() != elemType) { writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(elem.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(elem, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(elem, writer, writer_is_private, depth + 1); } } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); IDictionary dict = (IDictionary)obj; // collection might be non-generic type like Hashtable Type elemType = typeof(object); if (dict.GetType().GetGenericArguments().Length > 1) { // collection is a generic type like Dictionary<T, V> elemType = dict.GetType().GetGenericArguments()[1]; } foreach (DictionaryEntry entry in dict) { writer.WritePropertyName((string)entry.Key); // if the collection contains polymorphic elements, we need to include type information for deserialization if (writer.TypeHinting && entry.Value != null && entry.Value.GetType() != elemType) { writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(entry.Value.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(entry.Value, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(entry.Value, writer, writer_is_private, depth + 1); } } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { // Don't serialize a field or property with the JsonIgnore attribute with serialization usage if ((p_data.Ignore & JsonIgnoreWhen.Serializing) > 0) { continue; } if (p_data.IsField) { FieldInfo info = (FieldInfo)p_data.Info; writer.WritePropertyName(info.Name); object value = info.GetValue(obj); if (writer.TypeHinting && value != null && info.FieldType != value.GetType()) { // the object stored in the field might be a different type that what was declared, need type hinting writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(value.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(value, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(value, writer, writer_is_private, depth + 1); } } else { PropertyInfo info = (PropertyInfo)p_data.Info; if (info.CanRead) { writer.WritePropertyName(info.Name); object value = info.GetValue(obj, null); if (writer.TypeHinting && value != null && info.PropertyType != value.GetType()) { // the object stored in the property might be a different type that what was declared, need type hinting writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(value.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(value, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(value, writer, writer_is_private, depth + 1); } } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool privateWriter, int depth) { if (depth > maxNestingDepth) { throw new JsonException(string.Format("Max allowed object depth reached while trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (privateWriter) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is string) { writer.Write((string)obj); return; } if (obj is double) { writer.Write((double)obj); return; } if (obj is long) { writer.Write((long)obj); return; } if (obj is bool) { writer.Write((bool)obj); return; } if (obj is Array) { writer.WriteArrayStart(); Array arr = (Array)obj; Type elemType = arr.GetType().GetElementType(); foreach (object elem in arr) { // if the collection contains polymorphic elements, we need to include type information for deserialization if (writer.TypeHinting && elem != null & elem.GetType() != elemType) { writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(elem.GetType().FullName); writer.WritePropertyName(writer.HintValueName); WriteValue(elem, writer, privateWriter, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(elem, writer, privateWriter, depth + 1); } } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); IList list = (IList)obj; // collection might be non-generic type like Arraylist Type elemType = typeof(object); if (list.GetType().GetGenericArguments().Length > 0) { // collection is a generic type like List<T> elemType = list.GetType().GetGenericArguments()[0]; } foreach (object elem in list) { // if the collection contains polymorphic elements, we need to include type information for deserialization if (writer.TypeHinting && elem != null && elem.GetType() != elemType) { writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(elem.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(elem, writer, privateWriter, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(elem, writer, privateWriter, depth + 1); } } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); IDictionary dict = (IDictionary)obj; // collection might be non-generic type like Hashtable Type elemType = typeof(object); if (dict.GetType().GetGenericArguments().Length > 1) { // collection is a generic type like Dictionary<T, V> elemType = dict.GetType().GetGenericArguments()[1]; } foreach (DictionaryEntry entry in dict) { writer.WritePropertyName((string)entry.Key); // if the collection contains polymorphic elements, we need to include type information for deserialization if (writer.TypeHinting && entry.Value != null && entry.Value.GetType() != elemType) { writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(entry.Value.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(entry.Value, writer, privateWriter, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(entry.Value, writer, privateWriter, depth + 1); } } writer.WriteObjectEnd(); return; } Type objType = obj.GetType(); // Try a base or custom importer if one exists ExporterFunc exporter = GetExporter(objType); if (exporter != null) { exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type enumType = Enum.GetUnderlyingType(objType); if (enumType == typeof(long)) { writer.Write((long)obj); } else { ExporterFunc enumConverter = GetExporter(enumType); if (enumConverter != null) { enumConverter(obj, writer); } } return; } // Okay, it looks like the input should be exported as an object ObjectMetadata tdata = AddObjectMetadata(objType); writer.WriteObjectStart(); foreach (string property in tdata.Properties.Keys) { PropertyMetadata pdata = tdata.Properties[property]; // Don't serialize soft aliases (which get added to ObjectMetadata.Properties twice). if (pdata.Alias != null && property != pdata.Info.Name && tdata.Properties.ContainsKey(pdata.Info.Name)) { continue; } // Don't serialize a field or property with the JsonIgnore attribute with serialization usage if ((pdata.Ignore & JsonIgnoreWhen.Serializing) > 0) { continue; } if (pdata.IsField) { FieldInfo info = (FieldInfo)pdata.Info; if (pdata.Alias != null) { writer.WritePropertyName(pdata.Alias); } else { writer.WritePropertyName(info.Name); } object value = info.GetValue(obj); if (writer.TypeHinting && value != null && info.FieldType != value.GetType()) { // the object stored in the field might be a different type that what was declared, need type hinting writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(value.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(value, writer, privateWriter, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(value, writer, privateWriter, depth + 1); } } else { PropertyInfo info = (PropertyInfo)pdata.Info; if (info.CanRead) { if (pdata.Alias != null) { writer.WritePropertyName(pdata.Alias); } else { writer.WritePropertyName(info.Name); } object value = info.GetValue(obj, null); if (writer.TypeHinting && value != null && info.PropertyType != value.GetType()) { // the object stored in the property might be a different type that what was declared, need type hinting writer.WriteObjectStart(); writer.WritePropertyName(writer.HintTypeName); writer.Write(value.GetType().AssemblyQualifiedName); writer.WritePropertyName(writer.HintValueName); WriteValue(value, writer, privateWriter, depth + 1); writer.WriteObjectEnd(); } else { WriteValue(value, writer, privateWriter, depth + 1); } } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in (IDictionary)obj) { writer.WritePropertyName((string)entry.Key); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { if (p_data.IsField) { writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; if (p_info.CanRead) { writer.WritePropertyName(p_data.Info.Name); WriteValue(p_info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > max_nesting_depth) { throw new JsonException( String.Format("Max allowed object depth reached while " + "trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is String) { writer.Write((string)obj); return; } if (obj is Double) { writer.Write((double)obj); return; } if (obj is Single) { writer.Write((float)obj); return; } if (obj is Int32) { writer.Write((int)obj); return; } if (obj is Boolean) { writer.Write((bool)obj); return; } if (obj is Int64) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); foreach (object elem in (Array)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is Vector3) { writer.WriteObjectStart(); var val = (Vector3)obj; writer.WritePropertyName("x"); WriteValue(val.x, writer, writer_is_private, depth + 1); writer.WritePropertyName("y"); WriteValue(val.y, writer, writer_is_private, depth + 1); writer.WritePropertyName("z"); WriteValue(val.z, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); return; } if (obj is Vector4) { writer.WriteObjectStart(); var val = (Vector4)obj; writer.WritePropertyName("x"); WriteValue(val.x, writer, writer_is_private, depth + 1); writer.WritePropertyName("y"); WriteValue(val.y, writer, writer_is_private, depth + 1); writer.WritePropertyName("z"); WriteValue(val.z, writer, writer_is_private, depth + 1); writer.WritePropertyName("w"); WriteValue(val.w, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); return; } if (obj is Vector2) { writer.WriteObjectStart(); var val = (Vector2)obj; writer.WritePropertyName("x"); WriteValue(val.x, writer, writer_is_private, depth + 1); writer.WritePropertyName("y"); WriteValue(val.y, writer, writer_is_private, depth + 1); writer.WriteObjectEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); foreach (object elem in (IList)obj) { WriteValue(elem, writer, writer_is_private, depth + 1); } writer.WriteArrayEnd(); return; } if (obj is IDictionary dictionary) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in dictionary) { var propertyName = entry.Key is string key ? key : Convert.ToString(entry.Key, CultureInfo.InvariantCulture); writer.WritePropertyName(propertyName); WriteValue(entry.Value, writer, writer_is_private, depth + 1); } writer.WriteObjectEnd(); return; } Type obj_type; #if ILRUNTIME if (obj is ILRuntime.Runtime.Intepreter.ILTypeInstance) { obj_type = ((ILRuntime.Runtime.Intepreter.ILTypeInstance)obj).Type.ReflectionType; } else if (obj is ILRuntime.Runtime.Enviorment.CrossBindingAdaptorType) { obj_type = ((ILRuntime.Runtime.Enviorment.CrossBindingAdaptorType)obj).ILInstance.Type.ReflectionType; } else #endif obj_type = obj.GetType(); // See if there's a custom exporter for the object if (custom_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = custom_exporters_table[obj_type]; exporter(obj, writer); return; } // If not, maybe there's a base exporter if (base_exporters_table.ContainsKey(obj_type)) { ExporterFunc exporter = base_exporters_table[obj_type]; exporter(obj, writer); return; } // Last option, let's see if it's an enum if (obj is Enum) { Type e_type = Enum.GetUnderlyingType(obj_type); if (e_type == typeof(long) || e_type == typeof(uint) || e_type == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } // Okay, so it looks like the input should be exported as an // object AddTypeProperties(obj_type); IList <PropertyMetadata> props = type_properties[obj_type]; writer.WriteObjectStart(); foreach (PropertyMetadata p_data in props) { if (p_data.IsField) { writer.WritePropertyName(p_data.Info.Name); WriteValue(((FieldInfo)p_data.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo p_info = (PropertyInfo)p_data.Info; if (p_info.CanRead) { writer.WritePropertyName(p_data.Info.Name); WriteValue(p_info.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } writer.WriteObjectEnd(); }