/// <summary>主要入口方法。把目标对象指定成员写入数据流,处理基础类型、特殊类型、基础类型数组、特殊类型数组,通过委托方法处理成员</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public Boolean WriteObject(Object value, Type type, WriteObjectCallback callback) { if (type == null && value != null) { type = value.GetType(); } if (callback == null) { callback = WriteMember; } // 检查IAcessor接口 IAccessor accessor = value as IAccessor; if (accessor != null && accessor.Write(this)) { return(true); } Boolean rs = WriteObjectWithEvent(value, type, callback); // 检查IAcessor接口 if (accessor != null) { rs = accessor.WriteComplete(this, rs); } return(rs); }
/// <summary>写入枚举项</summary> /// <param name="value">对象</param> /// <param name="type">类型</param> /// <param name="index">成员索引</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> protected override bool OnWriteItem(object value, Type type, int index, WriteObjectCallback callback) { WriteLog("WriteEnumerableItem", index, type != null ? type.FullName : "Unknown type"); if (index > 0) { Writer.Write(","); } if (value != null && !IsExactType(type)) { type = value.GetType(); //避免base.OnWriteItem中写入value.GetType() writeValueType = value; } bool ret; if (value == null) { WriteNull(); ret = true; } else { ret = base.OnWriteItem(value, type, index, callback); } writeValueType = null; return(ret); }
/// <summary>写入枚举数据,复杂类型使用委托方法进行处理</summary> /// <param name="value">对象</param> /// <param name="type">类型</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> public virtual Boolean WriteEnumerable(IEnumerable value, Type type, WriteObjectCallback callback) { if (value == null) { return(true); } type = CheckAndWriteType("WriteEnumerableType", value, type); //type = value.GetType(); if (type != null && !typeof(IEnumerable).IsAssignableFrom(type)) { throw new InvalidOperationException("目标类型不是枚举类型!"); } // 计算元素类型,如果无法计算,这里不能处理,否则能写不能读(因为不知道元素类型) var elementType = TypeX.GetElementType(type); //if (elementType == null) return false; Int32 i = 0; foreach (var item in value) { Depth++; if (!WriteItem(item, elementType, i++, callback)) { return(false); } Depth--; } return(true); }
/// <summary>写入枚举项</summary> /// <param name="value">对象</param> /// <param name="type">类型</param> /// <param name="index">成员索引</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> protected override bool OnWriteItem(Object value, Type type, Int32 index, WriteObjectCallback callback) { Type t = type; if (value != null) { t = value.GetType(); } String name = t.GetCustomAttributeValue <XmlRootAttribute, String>(true); if (String.IsNullOrEmpty(name) && t != null) { name = t.Name; } Writer.WriteStartElement(name); AutoFlush(); Boolean rs = base.OnWriteItem(value, type, index, callback); AutoFlush(); Writer.WriteEndElement(); AutoFlush(); return(rs); }
/// <summary>实例化</summary> /// <param name="value">对象</param> /// <param name="type">对象类型</param> /// <param name="member">成员</param> /// <param name="index">成员序号</param> /// <param name="callback"></param> public WriteMemberEventArgs(Object value, Type type, IObjectMemberInfo member, Int32 index, WriteObjectCallback callback) : base(index, callback) { Value = value; Member = member; Type = type; }
/// <summary>写入实现了可序列化接口的对象</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型,如果type等于DataTable,需设置DataTable的名称</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public override bool WriteSerializable(object value, Type type, WriteObjectCallback callback) { if (!typeof(IXmlSerializable).IsAssignableFrom(type)) { return(base.WriteSerializable(value, type, callback)); } try { IXmlSerializable xml = value as IXmlSerializable; // 这里必须额外写一对标记,否则读取的时候只能读取得到模式而得不到数据 Boolean b = xml.GetSchema() != null; if (b) { Writer.WriteStartElement("Data"); } xml.WriteXml(Writer); if (b) { Writer.WriteEndElement(); } return(true); } catch { return(base.WriteSerializable(value, type, callback)); } }
/// <summary>实例化</summary> /// <param name="value">对象</param> /// <param name="keyType">键类型</param> /// <param name="valueType">值类型</param> /// <param name="index"></param> /// <param name="callback"></param> public WriteDictionaryEventArgs(DictionaryEntry value, Type keyType, Type valueType, Int32 index, WriteObjectCallback callback) : base(index, callback) { Value = value; KeyType = keyType; ValueType = valueType; }
/// <summary>写入对象。具体读写器可以重载该方法以修改写入对象前后的行为。</summary> /// <param name="value">对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> protected override bool OnWriteObject(object value, Type type, WriteObjectCallback callback) { if (value == null) { WriteNull(); return(true); } else if (!IsExactType(type)) { type = value.GetType(); if (Depth == 1) { writeValueType = value; } } if (Type.GetTypeCode(type) == TypeCode.Int16) // 在基类WriteValue时 Int16将会被转换成Int32处理,所以这里需要针对Int16特殊处理 { Int32 v = 0; if (value != null) { v = Convert.ToInt32(value.ToString()); } value = v; type = typeof(Int32); } return(base.OnWriteObject(value, type, callback)); }
/// <summary>将字典类型数据写入到当前流位置</summary> /// <param name="value"></param> /// <param name="type"></param> /// <param name="callback"></param> /// <returns></returns> public override bool WriteDictionary(IDictionary value, Type type, WriteObjectCallback callback) { if (value == null) { WriteNull(); return(true); } bool ret; Writer.Write("{"); ComplexObjectDepth++; if (!ComplexObjectDepthIsOverflow()) { WriteLine(); ret = base.WriteDictionary(value, type, callback); WriteLine(); } else { Depth++; WriteLog("WriteSkip", "ComplexObjectDepthIsOverflow"); Depth--; ret = true; } ComplexObjectDepth--; Writer.Write("}"); return(ret); }
/// <summary>写入枚举数据,复杂类型使用委托方法进行处理</summary> /// <param name="value">对象</param> /// <param name="type">类型</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> public override bool WriteEnumerable(IEnumerable value, Type type, WriteObjectCallback callback) { Boolean rs; Writer.Write("["); ComplexObjectDepth++; if (!ComplexObjectDepthIsOverflow()) { if (type.IsArray && value.GetType().GetArrayRank() > 1) { Array array = value as Array; List <String> lengths = new List <String>(); for (int i = 0; i < array.Rank; i++) { lengths.Add(array.GetLength(i).ToString()); } WriteLengths(String.Join(",", lengths.ToArray())); Writer.Write(","); } rs = base.WriteEnumerable(value, type, callback); } else { Depth++; WriteLog("WriteSkip", "ComplexObjectDepthIsOverflow"); Depth--; rs = true; } ComplexObjectDepth--; Writer.Write("]"); return(rs); }
/// <summary>写入实现了可序列化接口的对象</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public virtual Boolean WriteSerializable(Object value, Type type, WriteObjectCallback callback) { if (!typeof(ISerializable).IsAssignableFrom(type)) { return(false); } WriteLog("WriteSerializable", type.Name); return(WriteCustomObject(value, type, callback)); }
/// <summary>写自定义对象</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public virtual Boolean WriteCustomObject(Object value, Type type, WriteObjectCallback callback) { if (value == null) { return(true); } if (callback == null) { callback = WriteMember; } Object old = CurrentObject; CurrentObject = value; try { IObjectMemberInfo[] mis = GetMembers(type, value); if (mis == null || mis.Length < 1) { return(true); } // 调试输出成员列表 if (Debug) { ShowMembers("WriteCustomObject", mis); } for (int i = 0; i < mis.Length; i++) { Depth++; // 基础类型输出日志时,同时输出值,更直观 if (Type.GetTypeCode(mis[i].Type) == TypeCode.Object) { WriteLog("WriteMember", mis[i].Name, mis[i].Type.Name); } else { WriteLog("WriteMember", mis[i].Name, mis[i].Type.Name, mis[i][value]); } if (!WriteMember(value, mis[i].Type, mis[i], i, callback)) { return(false); } Depth--; } return(true); } finally { CurrentObject = old; } }
/// <summary>写入未知对象(其它所有方法都无法识别的对象),采用BinaryFormatter或者XmlSerialization</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public virtual Boolean WriteUnKnown(Object value, Type type, WriteObjectCallback callback) { WriteLog("WriteUnKnown", type.Name); // 调用.Net的二进制序列化来解决剩下的事情 BinaryFormatter bf = new BinaryFormatter(); MemoryStream ms = new MemoryStream(); bf.Serialize(ms, value); ms.Position = 0; Write(ms.ToArray()); return(true); }
/// <summary>写引用对象</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> protected override bool WriteRefObject(object value, Type type, WriteObjectCallback callback) { if (value != null) { type = value.GetType(); } // WriteType必须增加深度,否则写对象引用时将会受到影响,顶级对象不写对象引用 if (!Settings.IgnoreType && type != null) { Write(type); } return(base.WriteRefObject(value, type, callback)); }
/// <summary>写入枚举数据,复杂类型使用委托方法进行处理</summary> /// <param name="value">对象</param> /// <param name="type">类型</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> public override bool WriteEnumerable(IEnumerable value, Type type, WriteObjectCallback callback) { if (value != null && value.GetType().IsArray&& value.GetType().GetArrayRank() > 1) { Array arr = value as Array; List <String> lengths = new List <String>(); for (int j = 0; j < value.GetType().GetArrayRank(); j++) { lengths.Add(arr.GetLength(j).ToString()); } WriteLengths(String.Join(",", lengths.ToArray())); } Int32 count = 0; if (value != null) { if (type.IsArray) { Array arr = value as Array; count = arr.Length; } else { List <Object> list = new List <Object>(); foreach (Object item in value) { // 加入集合,防止value进行第二次遍历 list.Add(item); } count = list.Count; value = list; } } if (count == 0) { // 写入0长度。至此,枚举类型前面就会有两个字节用于标识,一个是是否为空,或者是对象引用,第二个是长度,注意长度为0的枚举类型 WriteSize(0); return(true); } // 写入长度 WriteSize(count); return(base.WriteEnumerable(value, type, callback)); }
/// <summary>写入枚举数据,复杂类型使用委托方法进行处理</summary> /// <param name="value">对象</param> /// <param name="type">类型</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> public override bool WriteEnumerable(IEnumerable value, Type type, WriteObjectCallback callback) { if (value == null) { return(true); } Type t = value.GetType(); Type elementType = null; if (t.HasElementType) { elementType = t.GetElementType(); } Boolean result = false; if (typeof(IEnumerable).IsAssignableFrom(elementType)) { if (typeof(IEnumerable).IsAssignableFrom(elementType.GetElementType())) { elementType = elementType.GetElementType(); WriteEnumerable(value as IEnumerable, elementType, callback); } foreach (Object item in value) { WriteLog("WriteEnumerable", elementType.Name); Writer.WriteStartElement("Item"); result = base.WriteEnumerable(item as IEnumerable, elementType, callback); Writer.WriteEndElement(); } return(result); } if (value.GetType().IsArray&& value.GetType().GetArrayRank() > 1) { Array arr = value as Array; List <String> lengths = new List <String>(); for (int j = 0; j < value.GetType().GetArrayRank(); j++) { lengths.Add(arr.GetLength(j).ToString()); } WriteLengths(String.Join(",", lengths.ToArray())); } return(base.WriteEnumerable(value, type, callback)); }
/// <summary>写对象成员</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public override bool WriteCustomObject(object value, Type type, WriteObjectCallback callback) { Boolean rs, writedType = false; Writer.Write("{"); if (value != null && writeValueType == value) //写入明确的类型 { WriteLine(); string fullname = value.GetType().FullName; Depth++; WriteLog("WriteType", "__type", fullname); WriteLiteral(string.Format("\"__type\":\"{0}\"", JavascriptStringEncode(fullname, this.Settings.UseStringUnicodeEncode))); //后续的逗号和换行符由WriteCustomObject中OnWriteMember输出,并将writeValueType置为null 因为后续可能没有任何成员 Depth--; writedType = true; } ComplexObjectDepth++; if (!ComplexObjectDepthIsOverflow()) { int i = WriteMemberCount; rs = base.WriteCustomObject(value, type, callback); writeValueType = null; if (WriteMemberCount > i) { WriteLine(); } WriteMemberCount = i; } else { if (writedType) { WriteLine(); } Depth++; WriteLog("WriteSkip", "ComplexObjectDepthIsOverflow"); Depth--; rs = true; } ComplexObjectDepth--; Writer.Write("}"); return(rs); }
/// <summary>写入枚举项</summary> /// <param name="value">对象</param> /// <param name="type">元素类型</param> /// <param name="index">元素索引</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> protected Boolean WriteItem(Object value, Type type, Int32 index, WriteObjectCallback callback) { // 写入成员前 WriteItemEventArgs e = null; if (OnItemWriting != null) { e = new WriteItemEventArgs(value, type, index, callback); OnItemWriting(this, e); // 事件处理器可能已经成功写入对象 if (e.Success) { return(true); } // 事件里面有可能改变了参数 value = e.Value; type = e.Type; index = e.Index; callback = e.Callback; } Boolean rs = OnWriteItem(value, type, index, callback); // 写入成员后 if (OnItemWrited != null) { if (e == null) { e = new WriteItemEventArgs(value, type, index, callback); } e.Success = rs; OnItemWrited(this, e); // 事件处理器可以影响结果 rs = e.Success; } return(rs); }
/// <summary>写入引用对象</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> protected virtual Boolean WriteRefObject(Object value, Type type, WriteObjectCallback callback) { // 字典 if (typeof(IDictionary).IsAssignableFrom(type)) { WriteLog("WriteDictionary", type.Name); if (WriteDictionary(value as IDictionary, type, callback)) { return(true); } } // 枚举 if (typeof(IEnumerable).IsAssignableFrom(type)) { WriteLog("WriteEnumerable", type.Name); if (WriteEnumerable(value as IEnumerable, type, callback)) { return(true); } } // 可序列化接口 if (WriteSerializable(value, type, callback)) { return(true); } // 复杂类型,处理对象成员 var old = CurrentObject; CurrentObject = value; if (WriteCustomObject(value, type, callback)) { CurrentObject = old; return(true); } CurrentObject = old; return(WriteUnKnown(value, type, callback)); }
Boolean WriteObjectWithEvent(Object value, Type type, WriteObjectCallback callback) { // 事件 WriteObjectEventArgs e = null; if (OnObjectWriting != null) { e = new WriteObjectEventArgs(value, type, callback); OnObjectWriting(this, e); // 事件处理器可能已经成功写入对象 if (e.Success) { return(true); } // 事件里面有可能改变了参数 value = e.Value; type = e.Type; callback = e.Callback; } Boolean rs = OnWriteObject(value, type, callback); // 事件 if (OnObjectWrited != null) { if (e == null) { e = new WriteObjectEventArgs(value, type, callback); } e.Success = rs; OnObjectWrited(this, e); // 事件处理器可以影响结果 rs = e.Success; } return(rs); }
/// <summary>写入字典类型数据</summary> /// <param name="value">字典数据</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public virtual Boolean WriteDictionary(IDictionary value, Type type, WriteObjectCallback callback) { if (value == null) { return(true); } // type = CheckAndWriteType("WriteDictionaryType", value, type); // 计算元素类型 Type keyType = null; Type valueType = null; // 取得键值类型 //if (!GetDictionaryEntryType(type, ref keyType, ref valueType)) return false; GetDictionaryEntryType(type, ref keyType, ref valueType); WriteSize(value.Count); if (value.Count == 0) { return(true); } //type = value.GetType(); if (type != null && !typeof(IDictionary).IsAssignableFrom(type)) { throw new InvalidOperationException("目标类型不是字典类型!"); } Int32 i = 0; foreach (DictionaryEntry item in value) { Depth++; if (!WriteKeyValue(item, keyType, valueType, i++, callback)) { return(false); } Depth--; } return(true); }
/// <summary>写入未知对象(其它所有方法都无法识别的对象),采用BinaryFormatter或者XmlSerialization</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> public override bool WriteUnKnown(object value, Type type, WriteObjectCallback callback) { try { WriteLog("WriteUnKnown", type.Name); //XmlSerializer serial = new XmlSerializer(type); //MemoryStream ms = new MemoryStream(); //serial.Serialize(ms, value); //String xml = Encoding.UTF8.GetString(ms.ToArray()); Write(value.ToXml(Settings.Encoding, "", "", false)); return(true); } catch { //只能处理公共类型,Type因其保护级别而不可访问。 } return(base.WriteUnKnown(value, type, callback)); }
/// <summary>写入枚举项</summary> /// <param name="value">对象</param> /// <param name="type">类型</param> /// <param name="index">成员索引</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> protected override bool WriteItem(Object value, Type type, Int32 index, WriteObjectCallback callback) { Type t = type; if (value != null) { t = value.GetType(); } String name = t.GetCustomAttributeValue <XmlRootAttribute, String>(true); if (String.IsNullOrEmpty(name) && t != null) { name = t.Name; } Writer.WriteStartElement(name); AutoFlush(); var rs = true; if (value != null) { rs = base.WriteItem(value, type, index, callback); } else { Writer.WriteAttributeString("p3", "nil", "http://www.w3.org/2001/XMLSchema-instance", "true"); } AutoFlush(); Writer.WriteEndElement(); AutoFlush(); return(rs); }
/// <summary>实例化</summary> /// <param name="value">对象</param> /// <param name="type">对象类型</param> /// <param name="callback"></param> public WriteObjectEventArgs(Object value, Type type, WriteObjectCallback callback) : base(callback) { Value = value; Type = type; }
/// <summary>把目标对象指定成员写入数据流,处理基础类型、特殊类型、基础类型数组、特殊类型数组,通过委托方法处理成员</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> protected virtual Boolean OnWriteObject(Object value, Type type, WriteObjectCallback callback) { //! 2011-05-27 17:33 //! 精确类型,直接写入值 //! 未知类型,写对象引用,写类型,写对象 if (IsExactType(type)) { // 基本类型 if (WriteValue(value, type)) { return(true); } // 写入对象引用 if (WriteObjRef(value)) { return(true); } // 扩展类型 if (WriteX(value, type)) { return(true); } // 写入引用对象 if (WriteRefObject(value, type, callback)) { return(true); } } else { // 写入对象引用 if (WriteObjRef(value)) { return(true); } // 写对象类型时增加缩进,避免写顶级对象类型的对象引用时无法写入(Depth=1的对象是不写对象引用的) Depth++; type = CheckAndWriteType("WriteObjectType", value, type); Depth--; // 基本类型 if (WriteValue(value, type)) { return(true); } // 扩展类型 if (WriteX(value, type)) { return(true); } // 写入引用对象 if (WriteRefObject(value, type, callback)) { return(true); } } return(true); }
/// <summary> /// 实例化 /// </summary> /// <param name="index">成员序号</param> /// <param name="callback"></param> public WriteIndexEventArgs(Int32 index, WriteObjectCallback callback) : base(callback) { Index = index; }
/// <summary> /// 实例化 /// </summary> /// <param name="callback"></param> public WriterEventArgs(WriteObjectCallback callback) { Callback = callback; }
/// <summary>实例化</summary> /// <param name="value">对象</param> /// <param name="type">对象类型</param> /// <param name="index">序号</param> /// <param name="callback"></param> public WriteItemEventArgs(Object value, Type type, Int32 index, WriteObjectCallback callback) : base(index, callback) { Value = value; Type = type; }
/// <summary>写入字典项 </summary> /// <param name="value">对象</param> /// <param name="keyType">键类型</param> /// <param name="valueType">值类型</param> /// <param name="index">成员索引</param> /// <param name="callback">使用指定委托方法处理复杂数据</param> /// <returns>是否写入成功</returns> protected override bool WriteKeyValue(DictionaryEntry value, Type keyType, Type valueType, int index, WriteObjectCallback callback) { // 如果无法取得字典项类型,则每个键值都单独写入类型 Writer.WriteStartElement("Item"); { Writer.WriteStartElement("Key"); if (!WriteObject(value.Key, keyType, callback)) { return(false); } Writer.WriteEndElement(); } { Writer.WriteStartElement("Value"); if (!WriteObject(value.Value, valueType, callback)) { return(false); } Writer.WriteEndElement(); } Writer.WriteEndElement(); return(true); }
/// <summary>写入对象成员</summary> /// <param name="name">成员名字</param> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="index">成员索引</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> protected override bool OnWriteMember(String name, Object value, Type type, int index, WriteObjectCallback callback) { if (!Settings.IgnoreName) { Write(name); } return(base.OnWriteMember(name, value, type, index, callback)); }
/// <summary>已重载。写入文档的开头和结尾</summary> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> protected override bool OnWriteObject(object value, Type type, WriteObjectCallback callback) { if (Depth > 1) { return(base.OnWriteObject(value, type, callback)); } Type t = type; if (t == null && value != null) { t = value.GetType(); } String name = RootName; if (String.IsNullOrEmpty(name)) { // 优先采用类型上的XmlRoot特性 if (type != null) { name = type.GetCustomAttributeValue <XmlRootAttribute, String>(true); } if (String.IsNullOrEmpty(name) && t != null) { name = t.GetCustomAttributeValue <XmlRootAttribute, String>(true); } if (String.IsNullOrEmpty(name)) { if (t != null) { name = GetName(t); } if (String.IsNullOrEmpty(RootName)) { RootName = name; } } } if (Depth == 1) { Writer.WriteStartDocument(); } Writer.WriteStartElement(name); AutoFlush(); Boolean rs = base.OnWriteObject(value, type, callback); AutoFlush(); if (Writer.WriteState != WriteState.Start) { Writer.WriteEndElement(); if (Depth == 1) { Writer.WriteEndDocument(); } } AutoFlush(); return(rs); }
/// <summary>实例化</summary> /// <param name="index">成员序号</param> /// <param name="callback"></param> public WriteIndexEventArgs(Int32 index, WriteObjectCallback callback) : base(callback) { Index = index; }
/// <summary>写入对象成员</summary> /// <param name="name">成员名字</param> /// <param name="value">要写入的对象</param> /// <param name="type">要写入的对象类型</param> /// <param name="index">成员索引</param> /// <param name="callback">处理成员的方法</param> /// <returns>是否写入成功</returns> protected override bool OnWriteMember(String name, Object value, Type type, Int32 index, WriteObjectCallback callback) { // 检查成员的值,如果是默认值,则不输出 //if (value != null && Settings.IgnoreDefault && IsDefault(value, member)) return true; // 特殊处理特性,只有普通值类型才能输出为特性 var isAtt = Settings.MemberAsAttribute && IsAttributeType(type); if (isAtt) { Writer.WriteStartAttribute(name); } else { Writer.WriteStartElement(name); } AutoFlush(); var rs = base.OnWriteMember(name, value, type, index, callback); if (!isAtt) { Writer.WriteEndElement(); } AutoFlush(); return(rs); }