目录

一，问题表现 

二、没有技术含量的解决方案 

三、本人彻底的解决方案

简要说明

贴代码

思路解析

思路

---

一，问题表现 

示例代码如下：

[Serializable]
public class NodeTest 
{public NodeTest (){new List<NodeTest> ();}public string Name { get; set; }public NodeTest Parent { get; set; }public List<NodeTest> Children { get; set; }}

先看错误地方，以上这个类要是序列化就会遇到，"序列化类型 Test.NodeTest 的对象时检测到循环引用。"错误。

二、没有技术含量的解决方案 

网上一搜，几乎到处都是这两种解决方案：

1. 使用NewtonSoft.Json，然后使用序列方法，加上设置 ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
2. 直接在循环错误属性上加XmlIgnore特性。

                NodeTest nd = new NodeTest ();nd.Name = "root";NodeTest nd1 = new NodeTest ();nd1.Name = "child1";nd1.Parent = nd;NodeTest nd2 = new NodeTest ();nd2.Name = "child2";nd2.Parent = nd;nd.Children.Add ( nd1 );nd.Children.Add ( nd2 );

上面的实例，采用第一种方法序列化是这结果：

 采用第二种是以下结果。

由此可见这两种方法简单，粗暴，没有一点技术含量。这么说是因为，直接忽略了其父子关系。反序列化成对象后Parent属性为空，如果需要逆向查找父对象时，完全行不通。

三、本人彻底的解决方案

• 简要说明

首先将例中NodeTest对象进行改装，让它继承自 IXmlSerializable 接口并实现，为的就是在序列化和反序列化时，可以自由控制以达到序列化时能包含父节点信息。其次是对他的属性Children进行改造，这很重要，如果继续使用List列表，会出现其他问题，这个后续会提到。

• 贴代码

现不废话，贴代码，代码看完，看后文解析，应该很容易明白，NodeTest 类：

    [Serializable]public class NodeTest : IXmlSerializable{internal const string ROOT = "NodeTest";internal const string NAME = "Name";internal const string PARENT = "Parent";internal const string ELEMENT_EXISTMARK = "ExistMark";internal const string ELEMENT_EXIST = "Exist";internal const string ELEMENT_NOTEXIST = "NotExist";public NodeTest (){Children = new NodeTestCollection ();}public string Name { get; set; }public NodeTest Parent { get; set; }[XmlArray ()]public NodeTestCollection/*List<NodeTest>*/ Children { get; set; }public System.Xml.Schema.XmlSchema GetSchema (){return null;}public static void ResetSerializationStatus (){_dicAllNodes.Clear ();}private static Dictionary<string, NodeTest> _dicAllNodes= new Dictionary<string, NodeTest> ();public void ReadXml ( System.Xml.XmlReader reader ){XmlSerializer xmlSer = XmlSerializer.FromTypes ( new Type[ ] { typeof ( NodeTest ) } )[ 0 ];if ( reader.IsEmptyElement ) return;while ( reader.NodeType != System.Xml.XmlNodeType.EndElement ){reader.ReadStartElement ( ROOT );reader.ReadStartElement ( NAME );this.Name = reader.ReadString ();reader.ReadEndElement ();reader.MoveToContent ();string sExistMark = ELEMENT_NOTEXIST;if ( reader.MoveToAttribute ( ELEMENT_EXISTMARK ) ){sExistMark = reader.GetAttribute ( ELEMENT_EXISTMARK );}reader.ReadStartElement ( PARENT );switch ( sExistMark ){case ELEMENT_EXIST:reader.ReadStartElement ( NAME );Parent = new NodeTest ();Parent.Name = reader.ReadString ();reader.ReadEndElement ();reader.ReadEndElement ();break;default:break;}XmlSerializer xmlSer2 = XmlSerializer.FromTypes ( new Type[ ] { typeof ( NodeTestCollection ) } )[ 0 ];Children = ( NodeTestCollection )xmlSer2.Deserialize ( reader );if ( Children.Count != 0 ){reader.ReadEndElement ();}_dicAllNodes.Add ( this.Name, this );}for ( int i = 0 ; i < Children.Count ; i++ ){var child = Children[ i ];if ( child.Parent != null ){child.Parent = _dicAllNodes[ child.Parent.Name ];}}}public void WriteXml ( System.Xml.XmlWriter writer ){XmlSerializer xmlSer = XmlSerializer.FromTypes ( new Type[ ] { typeof ( NodeTest ) } )[ 0 ];writer.WriteStartElement ( NAME );writer.WriteString ( this.Name );writer.WriteEndElement ();writer.WriteStartElement ( PARENT );if ( Parent != null ){writer.WriteAttributeString ( ELEMENT_EXISTMARK, ELEMENT_EXIST );writer.WriteStartElement ( NAME );writer.WriteString ( Parent.Name );writer.WriteEndElement ();}else{writer.WriteAttributeString ( ELEMENT_EXISTMARK, ELEMENT_NOTEXIST );}writer.WriteEndElement ();writer.Flush ();XmlSerializer xmlSer2 = XmlSerializer.FromTypes ( new Type[ ] { typeof ( NodeTestCollection ) } )[ 0 ];xmlSer2.Serialize ( writer, this.Children );writer.Flush ();writer.Flush ();}}

List<NodeTest>改成NodeTestCollection，解决序列化时结构错乱问题（本来打算细说的，算了，懒得打字了，看客自己试试就知道了），此改动，还很利于后续的优化扩展，比如名字索引等，实现如下：

    [Serializable][XmlRoot(ElementName = "Children" )]public class NodeTestCollection : IList<NodeTest>, IXmlSerializable{private const string ROOT = "Children";private const string CHILDCOUNT = "ChildCount";#region 继承实现自IList<NodeTest>private IList<NodeTest> m_lstNodes = new List<NodeTest> ();public int IndexOf ( NodeTest item ){int iIdx = -1;for ( int i = 0 ; i < m_lstNodes.Count ; i++ ){if ( m_lstNodes[ i ] == item ){iIdx = i;break;}}return iIdx;}public void Insert ( int index, NodeTest item ){m_lstNodes.Insert ( index, item );}[XmlElement ( "NodeTest", Type = typeof ( NodeTest ) )]public NodeTest this[ int index ]{get{return m_lstNodes[ index ];}set{m_lstNodes[ index ] = value;}}public void Add ( NodeTest item ){m_lstNodes.Add ( item );}public bool Contains ( NodeTest item ){return m_lstNodes.Contains ( item );}public void CopyTo ( NodeTest[ ] array, int arrayIndex ){m_lstNodes.CopyTo ( array, arrayIndex );}public bool Remove ( NodeTest item ){return m_lstNodes.Remove ( item );}IEnumerator<NodeTest> IEnumerable<NodeTest>.GetEnumerator (){return m_lstNodes.GetEnumerator ();}public void RemoveAt ( int index ){m_lstNodes.RemoveAt ( index );}public void Clear (){m_lstNodes.Clear ();}public int Count{get { return m_lstNodes.Count; }}public bool IsReadOnly{get { return false; }}System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator (){return m_lstNodes.GetEnumerator ();}#endregionpublic System.Xml.Schema.XmlSchema GetSchema (){return null;}public void ReadXml ( System.Xml.XmlReader reader ){//if ( reader.IsEmptyElement ) return;int iChildCount = 0;if ( reader.MoveToAttribute ( CHILDCOUNT ) ) iChildCount = int.Parse ( reader.GetAttribute ( CHILDCOUNT ) );reader.ReadStartElement ( ROOT );if (iChildCount > 0){XmlSerializer xmlSer = XmlSerializer.FromTypes ( new Type[ ] { typeof ( NodeTest ) } )[ 0 ];for ( int i = 0 ; i < iChildCount ; i++ ){var readerSub = reader.ReadSubtree();this.Add ( ( NodeTest )xmlSer.Deserialize ( readerSub ) );reader.ReadEndElement ();}}}public void WriteXml ( System.Xml.XmlWriter writer ){int iCnt = this.Count;writer.WriteAttributeString ( CHILDCOUNT, iCnt.ToString () );XmlSerializer xmlSer = XmlSerializer.FromTypes ( new Type[ ] { typeof ( NodeTest ) } )[ 0 ];for ( int i = 0 ; i < iCnt ; i++ ){xmlSer.Serialize ( writer, this[ i ] );}}}

• 思路解析

说说思路：改造的地方不多，主要是继承方法的实现上，也就是ReadXml 和WriteXml方法实现上。在实现它们时，采用一点手段，在方法体类对循环引用的对象进行区别处理。

思路

原理很简单，循环引用的地方，在本例中即Parent对象，采用简单存储，存储一个指引信息，这里为图简洁，直接使用Name属性作为指引【后续各位观众具体使用是可以使用唯一标识符进行优化，在此我就不改了】。将所有NodeTest对象信息存为字典，在反序列化时使用指引进行挂接，因为这是class，是引用对象，简单一改，全部挂接完成，挂接处就是For循环处。

此外还有两处XmlAttribute——ExistMark和ChildCount，分别用来辅助Parent存在时检测以及子节点存在检测。

采用这个方法，序列化出来如下图：

 

反序列化也成功进行挂接，不信，你试试。

原理就这么简单。

 不懂就留言吧。