请问XML序列化与反序列化的问题

Question

假定有如下类：[Serializable]
public class Family
{
public Family()
{
}    public Husband Male
    {
        get;
        set;
    }    public Wife Female
    {
        get;
        set;
    }
}[Serializable]
public class Husband
{
    public Wife Wife
    {
        get;
        set;
    }
}[Serializable]
public class Wife
{
    public Husband Husband
    {
        get;
        set;
    }
}
我需要对Family进行序列化和反序列化操作，但出现了类交叉使用的情况，该如何来解决该问题？谢谢！！

Answer 1

    [Serializable]
    [DataContract]
    [XmlInclude(typeof(ChamberRecipePair))]
    public class Sequence : SequenceHeader, IEquatable<Sequence>楼主加下  [XmlInclude(typeof(ChamberRecipePair))]类似这样的，
如果要在sequence里面用ChamberRecipePair类的话，你的也一样

Answer 2

这种XmlInclude我尝试过，貌似不行正在考虑着仅只对Husband进行序列化，而不对Wife进行序列化，在反序列化时，动态生成Wife

Answer 3

正在想办法处理IXmlSerialzable中，大侠们也请帮我想想该如何来解决最完美假定三个类都加了一个Guid的属性
[Serializable]
public class Family
{
public Family()
{
}
    public Guid Guid
    {
        get;
        set;
    }
    public Husband Male
    {
        get;
        set;
    }    public Wife Female
    {
        get;
        set;
    }
}[Serializable]
public class Husband
{
    public Guid Guid
    {
        get;
        set;
    }
    public Wife Wife
    {
        get;
        set;
    }
}[Serializable]
public class Wife
{
    public Guid Guid
    {
        get;
        set;
    }
    public Husband Husband
    {
        get;
        set;
    }
}

Answer 4

你的这种设计，其实是引用地址的反复引用，某个对象只有一个，但是通过引用链却出现了不止一次。要控制无限递归是不难，但是反序列化的结果可能就不是之前的效果了，因为当你原先是互相引用，而反序列化却是单独生成一个新对象，那肯定就不一样了。
所以必须自定义Xml序列化方法来实现，让你的类继承接口IXmlSerializable，实现ReadXml和WriteXml方法。
序列化之前，必须定义一个局部的字典缓存，用来存放对象的引用。
就你的例子，我给你写一个通过IXmlSerializable的实现，大概要1小时左右的调试时间，请等待。

Answer 5

核心类：        public static class SerCache
        {
            public static Dictionary<int, object> cache = new Dictionary<int, object>();
        }        public class Husband : IXmlSerializable
        {
            public Wife Wife
            {
                get;
                set;
            }            #region IXmlSerializable 成员            public System.Xml.Schema.XmlSchema GetSchema()
            {
                return null;
            }            public void ReadXml(System.Xml.XmlReader reader)
            {
                if (reader.IsEmptyElement)
                    return;
                XmlSerializer wifeSerializer = new XmlSerializer(typeof(Wife));
                int hashcode = int.Parse(reader.GetAttribute("HashCode"));
                SerCache.cache.Add(hashcode, this);
                reader.Read();
                hashcode = int.Parse(reader.GetAttribute("HashCode"));
                if (SerCache.cache.Keys.Contains(hashcode))
                {
                    Wife = (Wife)SerCache.cache[hashcode];
                }
                else
                {
                    Wife = (Wife)wifeSerializer.Deserialize(reader);
                }
            }            public void WriteXml(System.Xml.XmlWriter writer)
            {
                writer.WriteStartAttribute("HashCode");
                writer.WriteValue(this.GetHashCode());
                writer.WriteEndAttribute();
                if (SerCache.cache.Keys.Contains(this.GetHashCode()))
                    return;
                SerCache.cache.Add(this.GetHashCode(), null);
                XmlSerializer wifeSerializer = new XmlSerializer(typeof(Wife));
                wifeSerializer.Serialize(writer, Wife);
            }            #endregion
        }        public class Wife : IXmlSerializable
        {
            public Husband Husband
            {
                get;
                set;
            }            #region IXmlSerializable 成员            public System.Xml.Schema.XmlSchema GetSchema()
            {
                return null;
            }            public void ReadXml(System.Xml.XmlReader reader)
            {
                if (reader.IsEmptyElement)
                    return;
                XmlSerializer wifeSerializer = new XmlSerializer(typeof(Husband));
                int hashcode = int.Parse(reader.GetAttribute("HashCode"));
                SerCache.cache.Add(hashcode, this);
                reader.Read();
                hashcode = int.Parse(reader.GetAttribute("HashCode"));
                if (SerCache.cache.Keys.Contains(hashcode))
                {
                    Husband = (Husband)SerCache.cache[hashcode];
                }
                else
                {
                    Husband = (Husband)wifeSerializer.Deserialize(reader);
                }
            }            public void WriteXml(System.Xml.XmlWriter writer)
            {
                writer.WriteStartAttribute("HashCode");
                writer.WriteValue(this.GetHashCode());
                writer.WriteEndAttribute();
                if (SerCache.cache.Keys.Contains(this.GetHashCode()))
                    return;
                SerCache.cache.Add(this.GetHashCode(), null);
                XmlSerializer wifeSerializer = new XmlSerializer(typeof(Husband));
                wifeSerializer.Serialize(writer, Husband);
            }            #endregion
        }如果你用XmlSerializer序列化的话，将得到如下形式的递归表现，重复会停止：
<?xml version="1.0" encoding="utf-8"?>
<Husband HashCode="511887">
  <Wife HashCode="37621475">
    <Husband HashCode="511887" />
  </Wife>
</Husband>注意：每次序列化和反序列化之前，必须调用“SerCache.cache.Clear();”将上次可能产生的序列化缓存清空（你也可以在序列化或反序列化结束的时候这么做）。

Answer 6

非常感谢我现在一板一眼地写XmlDocument，不使用Xml序列化了，其实效果差不多，使用的想法与您提出的是一样的，有一个缓存队列，先实例化所有的对象，然后遍历一遍后再进行赋值。再次感谢！