Ignorare le proprietà sulle classi derivate quando si utilizza .NET XmlSerializer

Question

Ho una classe base con una proprietà virtuale e un tipo derivato che sostituisce la proprietà virtuale. Il tipo può essere serializzato in XML. Quello che sto cercando di fare NON è mantenere la proprietà Elenco di oggetti quando l'oggetto è del tipo derivato. Per ottenere ciò, la classe derivata decora la proprietà sostituita con l'attributo [XmlIgnore]. La proprietà virtuale nella classe base NON applica l'attributo XmlIgnore. Per qualche motivo l'Elenco degli elementi viene serializzato ogni anche quando l'oggetto è del tipo derivato (DynamicCart).

Quando si applica l'attributo XmlIgnore alla proprietà virtuale nella classe base, l'elenco non viene serializzato su file.

public class ShoppingCart 
{ 
    public virtual List<items> Items{get; set;} 

    //and other properties 

    public void SerializeToXML (string filePath) 
    { 
    var xmlSerializer = new XmlSerializer(this.GetType()); 
    textWriter = new System.IO.StreamWriter(filePath); 
    xmlSerializer.Serialize(textWriter, this); 
    textWriter.Flush(); 
    textWriter.Close(); 
    } 
} 

//A cart that is populated by algo based on parameters supplied by user. I have no need to 
//persist the actual items across sessions. 
class DynamicCart: ShoppingCart 
{ 
    [XmlIgnore] 
    public override List<items>{get;set;} 
    //and other properties 
} 

class Shop 
{ 
    ShoppingCart cart = new DynamicCart(); 
    PopulateCart(cart); 
    cart.serializeToXML(<PATH TO FILE>); 
} 

Answer 1

Suppongo che sia necessario dichiarare il tipo derivato nella classe base per la serializzazione XML. Sembra un po 'sciocco, ma è secondo le specifiche.

Vai a questa MSDN page, e cercare il seguente esempio:

[System.Xml.Serialization.XmlInclude(typeof(Derived))] 
public class Base 
{ 
    // ... 
} 

Answer 2

Prova questa

XmlSerializer serializer = new XmlSerializer(typeof(DynamicCart), new Type[]{typeof(ShoppingCart)}); 

questo vi permetterà di aggiungere il maggior numero di tipi, si vuole serializzatore a inclusde.

Answer 3

Penso che il serializzatore stia utilizzando la classe base anziché quella derivata.

public void SerializeToXML(string filePath, Type type) 
{ 
    xmlSerializer = new XmlSerializer(type); 
    textWriter = new System.IO.StreamWriter(filePath); 
    xmlSerializer.Serialize(textWriter, this); 
    textWriter.Flush(); 
    textWriter.Close(); 
} 

class Shop 
{ 
    ShoppingCart cart= new DynamicCart(); 
    PopulateCart(cart); 
    cart.serializeToXML(<PATH TO FILE>, typeof(DynamicCart)); 
} 

Answer 4

È possibile eseguire questa operazione aggiungendo un metodo virtuale ShouldSerialize*** alla classe base. Per esempio:

[XmlInclude(typeof(Sub))] 
public class Base 
{ 
    public virtual string Prop { get; set; } 

    public virtual bool ShouldSerializeProp() { return true; } 
} 

public class Sub : Base 
{ 
    public override string Prop { get; set; } 

    public override bool ShouldSerializeProp() { return false; } 
} 

internal class Program 
{ 
    private static void Main() 
    { 
     var o = new Sub { Prop = "Value" }; 

     var baseSer = new XmlSerializer(typeof (Base)); 
     var subSer = new XmlSerializer(typeof (Sub)); 

     Console.Out.WriteLine("BASE:"); 
     baseSer.Serialize(Console.Out, o); 
     Console.Out.WriteLine(); 

     Console.Out.WriteLine("SUB:"); 
     subSer.Serialize(Console.Out, o); 
     Console.Out.WriteLine(); 

     Console.ReadLine(); 
    } 
} 

Questo produce (riordinato un po '):

BASE: 
<Base xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="Sub"> 
    <Prop>Value</Prop> 
</Base> 

SUB: 
<Sub /> 

Il metodo deve avere includono il nome esatto della proprietà di prendere in considerazione dopo ShouldInclude....