如何序列化引用对象

[JL99000]

[Serializable]
public class MySerialClass
{
public MySerialClass()
{

}
public List<Maker> AllMakers
{
get;
set;
}
public Book Book
{
get;
set;
}
}
public class Book
{
public string name;
public Maker maker;
public Book()
{
}
public Book(string name,Maker maker)
{
this.name = name;
this.maker = maker;
}
}
[Serializable]
public class Maker
{
public string name;
public Maker()
{
}
public Maker(string name)
{
this.name = name;
}
}

以上是序列化的类

string strFile = "c:\\MySerialClass.xml";

public void Serialize(MySerialClass mc)
{
using (FileStream fs = new FileStream(strFile, FileMode.Create))
{
XmlSerializer formatter = new XmlSerializer(typeof(MySerialClass));
formatter.Serialize(fs, mc);
}
}

public MySerialClass DeSerialize()
{
MySerialClass mc;
using (FileStream fs = new FileStream(strFile, FileMode.Open))
{
XmlSerializer formatter = new XmlSerializer(typeof(MySerialClass));
mc = (MySerialClass)formatter.Deserialize(fs);
}
return mc;
}

private void btn_Save_Click(object sender, EventArgs e)
{
//this.graphControl1.Serialize();

MySerialClass mc = new MySerialClass();
Maker maker = new Maker("m1");
List<Maker> makerList = new List<Maker>();
makerList.Add(maker);
mc.AllMakers = makerList;
Book b = new Book("b1", makerList[0]);
mc.Book = b;
Serialize(mc);
}

private void btn_ReDraw_Click(object sender, EventArgs e)
{
//this.graphControl1.DeSerialize();

MySerialClass mc = DeSerialize();
}

以上是序列化的方法



我的问题是：

Book类中的Maker属性引用的是MySerialClass属性AllMakers中的一个对象

但是在序列化时保存的是两个对象（我想要实现的保存一个对象，同时有一个对该对象的引用），另外反序列化时只调用一次Maker的构造函数



请指教

[祁连雪狼之家]

顶顶顶！！！！

[LutzMark]

你说的序列化时保存的是两个对象，两个什么类型对象?
如果你说的是Maker对象，那么你自己的代码里写的一个是List<Maker>，另一个是Book里的Maker。
所以有两个Maker对象。

反序列化时调两次Maker构造函数也是如此。

这是由你序列化的MySerialClass对象结构决定的。

如果你想改成只保存一个Maker, 反序列化也只生成一个Maker对象，就得改MySerialClass类。你不用非要放一个集合类和一个Book属性，取而代之，你可以把他们放到一个可序列化字典类里

以下只是给你举个例子，为了方便使用console

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.IO;
using System.Xml;
using System.Runtime.Serialization;
using System.Xml.Schema;

namespace XmlSerializationConsole
{
   class Program
   {
      static void Main(string[] args)
      {
         DoSerialize();
         DeSerialize();
      }
      static string strFile = "c:\\MySerialClass.xml";

      public static void Serialize(MySerialClass mc)
      {
         using (FileStream fs = new FileStream(strFile, FileMode.Create))
         {
            XmlSerializer formatter = new XmlSerializer(typeof(MySerialClass));
            formatter.Serialize(fs, mc);
         }
      }

      public static MySerialClass DeSerialize()
      {
         MySerialClass mc;
         using (FileStream fs = new FileStream(strFile, FileMode.Open))
         {
            XmlSerializer formatter = new XmlSerializer(typeof(MySerialClass));
            mc = (MySerialClass)formatter.Deserialize(fs);
         }
         return mc;
      }

      private static void DoSerialize()
      {
         //this.graphControl1.Serialize();

         MySerialClass mc = new MySerialClass();
         Maker maker = new Maker("m1");

         SerializableDictionary<Maker, Book> makerList = new SerializableDictionary<Maker, Book>();
        //Book b = new Book("b1", makerList[0]);
        Book b = new Book("b1", maker);
        makerList.Add(maker, b);
        mc.AllMakerBooks = makerList;
         Serialize(mc);
      }

      private static void DoDeSerialize( )
      {
         //this.graphControl1.DeSerialize();

         MySerialClass mc = DeSerialize();
      }
   }
   [Serializable]
  public class MySerialClass
  {
  public MySerialClass()
  {

  }
  public SerializableDictionary<Maker, Book> AllMakerBooks
  {
  get;
  set;
  }

  }
   [Serializable]
  public class Book
  {
  public string name;
  public Maker maker;
  public Book()
  {  
  }
  public Book(string name,Maker maker)
  {
  this.name = name;
  this.maker = maker;
  }
  }
  [Serializable]
  public class Maker
  {
  public string name;
  public Maker()
  {  
  }
  public Maker(string name)
  {
  this.name = name;
  }
  }
   /// <summary>
   /// 可序列化字典类
   /// </summary>
   /// <typeparam name="TKey"></typeparam>
   /// <typeparam name="TValue"></typeparam>
    [XmlRoot("dictionary"), Serializable]   
    public class SerializableDictionary<TKey, TValue>   
        : Dictionary<TKey, TValue>, IXmlSerializable   
    {   
        public SerializableDictionary()   
        {   
        }   
  
        public SerializableDictionary(IDictionary<TKey, TValue> dictionary)   
            : base(dictionary)   
        {   
        }   
  
        public SerializableDictionary(IEqualityComparer<TKey> comparer)   
            : base(comparer)   
        {   
        }   
  
  
        public SerializableDictionary(int capacity)   
            : base(capacity)   
        {   
        }   
  
        public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer)   
            : base(capacity, comparer)   
        {   
        }   
  
        protected SerializableDictionary(SerializationInfo info, StreamingContext context)   
            : base(info, context)   
        {   
        }  
 
        #region IXmlSerializable Members   
  
        public XmlSchema GetSchema()   
        {   
            return null;   
        }   
  
        /// <summary>   
        /// 从对象的 XML 表示形式生成该对象   
        /// </summary>   
        /// <param name="reader"></param>   
        public void ReadXml(XmlReader reader)   
        {   
            var keySerializer = new XmlSerializer(typeof(TKey));   
            var valueSerializer = new XmlSerializer(typeof(TValue));   
            bool wasEmpty = reader.IsEmptyElement;   
            reader.Read();   
  
            if (wasEmpty)   
                return;   
            while (reader.NodeType != XmlNodeType.EndElement)   
            {   
                reader.ReadStartElement("item");   
                reader.ReadStartElement("key");   
                var key = (TKey)keySerializer.Deserialize(reader);   
                reader.ReadEndElement();   
                reader.ReadStartElement("value");   
                var value = (TValue)valueSerializer.Deserialize(reader);   
                reader.ReadEndElement();   
                Add(key, value);   
                reader.ReadEndElement();   
                reader.MoveToContent();   
            }   
            reader.ReadEndElement();   
        }   
  
        /// <summary>   
        /// 将对象转换为其 XML 表示形式   
        /// </summary>   
        /// <param name="writer"></param>   
        public void WriteXml(XmlWriter writer)   
        {   
            var keySerializer = new XmlSerializer(typeof(TKey));   
            var valueSerializer = new XmlSerializer(typeof(TValue));   
            foreach (TKey key in Keys)   
            {   
                writer.WriteStartElement("item");   
                writer.WriteStartElement("key");   
                keySerializer.Serialize(writer, key);   
                writer.WriteEndElement();   
                writer.WriteStartElement("value");   
                TValue value = this[key];   
                valueSerializer.Serialize(writer, value);   
                writer.WriteEndElement();   
                writer.WriteEndElement();   
            }   
        }  
 
        #endregion   
    }   

}