/// <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="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="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="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="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="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="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);
}
