Comment puis-je désérialiser des données XML dans un objet à l'aide d'un constructeur qui prend un XDocument?

J'ai une classe:

public class MyClass
{
   public MyClass(){}
}

Je voudrais être en mesure d'utiliser un XMLSeralizer Désérialiser un XDocument directement dans le constructeur ainsi:

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

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

Sauf que je ne suis pas autorisé à céder à "cela" dans le constructeur.

Est-ce possible?

Pour quelle raison vous voulez le faire comme ça?
Parce que ce serait bien d'instancier la classe et vient nourrir un XDocument et l'avoir défini lui-même comme ça. Il y a d'autres solutions, mais cela semble plus élégante pour moi... je suis ouvert à de meilleures suggestions.
Ne peut-on pas définir la classe d'avoir des données sérialisées en elle, donc la création de l'instance pour vous?

OriginalL'auteur One Monkey | 2011-10-26

  1. 28

    Non, il n'est pas possible. Sérialiseurs créer des objets lorsqu'ils désérialiser. Vous avez déjà créé un objet. Au lieu de cela, fournir une méthode statique de construire à partir d'un XDocument. 

    public static MyClass FromXml (XDocument xd)
{
   XmlSerializer s = new XmlSerializer(typeof(MyClass));
   return (MyClass)s.Deserialize(xd.CreateReader());
}
    et comment le réfrigérateur que vous êtes censé faire quand la extraTypes (knownTypes) ne sont pas connus au moment de la compilation ? C'est méchant, nous n'avons même pas un pré-rappel à l'init des trucs avant de commencer à désérialiser ?

    OriginalL'auteur Tim Rogers

  2. 6

    C'est plus la norme à utiliser une méthode statique charge.

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

    OriginalL'auteur Ray

  3. 4

    Est préférable d'utiliser une sorte d'usine, par exemple:

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

    OriginalL'auteur Kirill Polishchuk

  4. 1

    J'ai voulu faire la même chose et a décidé de faire ce qui suit:

    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));
   }
}

    OriginalL'auteur Jimbo

  5. -1

    La réponse simple à votre question est non, vous ne pouvez pas. La raison, c'est que vous créez un objet lorsque vous désérialisez.

    Mais si vous avez vraiment insister sur la possibilité pour un objet à instancier lui-même pour ainsi dire, vous pouvez utiliser un privé statique de la variable d'instance que vous pouvez charger avec l'objet que vous obtenez après la désérialisation. Les autres membres du public devrait alors fonctionner sur l'instance ( quand il n'est pas null )

    un exemple ( hors de ma tête, donc il ya une petite chance qu'il n'est pas tout à fait 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
     }

  }
}

    J'espère que cela rend un peu clair, mais je ne suis pas fan de ce dessin. Je pense qu'il est tout trop complexes et sensibles à l'erreur.

    Vous vous rendez compte que tous les MyClass que vous instanciez passé la première remplacera la précédente instanciations de la statique mInstance? Ensuite, tous les instancié MyClass objets utilisant le même objet en mémoire.

    OriginalL'auteur Chris