如何使用带有XDocument的构造函数将XML反序列化为对象？

Question

I have a class:

public class MyClass
{
   public MyClass(){}
}

I would like to be able to use an XMLSeralizer to Deserialize an XDocument directly in the constructor thus:

public class MyClass
{
   private XmlSerializer _s = new XmlSerializer(typeof(MyClass));

   public MyClass(){}
   public MyClass(XDocument xd)
   {
      this = (MyClass)_s.Deserialize(xd.CreateReader());
   }
}

Except I am not allowed to assign to "this" within the constructor.

Is this possible?

Answer 1

No, it's not possible. Serializers create objects when they deserialize. You've already created an object. Instead, provide a static method to construct from an XDocument.

public static MyClass FromXml (XDocument xd)
{
   XmlSerializer s = new XmlSerializer(typeof(MyClass));
   return (MyClass)s.Deserialize(xd.CreateReader());
}

Answer 2

It's more standard to use a static load method.

public class MyClass
{
    public static MyClass Load(XDocument xDoc)
    {
        XmlSerializer _s = new XmlSerializer(typeof(MyClass));
        return (MyClass)_s.Deserialize(xDoc.CreateReader());
    }
}

Answer 3

Is better use some kind of factory, eg:

public static MyClass Create(XDocument xd)
{
    XmlSerializer _s = new XmlSerializer(typeof(MyClass));
    return (MyClass)_s.Deserialize(xd.CreateReader());
}

Answer 4

I wanted to do the same thing and decided to do the following:

public class MyClass
{
   public MyClass(){
   }

   public MyClass(XDocument xd)
   {
      var t = typeof(MyClass);
      var o = (MyClass)new XmlSerializer(t).Deserialize(xd.CreateReader());

      foreach (var property in t.GetProperties())
          property.SetValue(this, property.GetValue(o));
   }
}

Answer 5

The simple answer to your question is no, you can't. Reason therefore is that you create an object when you deserialize.

But if you really insist on the possibility for an object to instantiate itself so-to-speak, you can use a private static instance variable which you can load with the object you get after deserialization. The other public members should then work on the instance ( when it's not null that is )

an example ( out of my head, so there is a slight chance it isn't entirely correct ) :

public class MyClass
{
  private XmlSerializer _s = new XmlSerializer(typeof(MyClass));
  private static MyClass mInstance = null;

  public MyClass() { /* initialization logic */ }
  public MyClass(XDocument xd) 
  {
      mInstance = (MyClass)_s.Deserialize(xd.CreateReader());
  }

  public void DoSomething()
  {
     if (mInstance != null)
       mInstance.DoSomething();
     else 
     {
         // logic for DoSomething
     }

  }
}

I hope this makes it a bit clear, but I'm not fond of such design. I think it makes it all overly complex and error sensitive.