Ignorar propiedades en las clases derivadas al usar XmlSerializer de .NET

Question

Tengo una clase base con una propiedad virtual y un tipo derivado que anula la propiedad virtual. El tipo se puede serializar a XML. Lo que trato de hacer es NO persistir en la propiedad Lista de elementos cuando el objeto es del tipo derivado. Para lograr esto, la clase derivada decora la propiedad anulada con el atributo [XmlIgnore]. La propiedad virtual en la clase base NO aplica el atributo XmlIgnore. Por algún motivo, la Lista de elementos se serializa incluso cuando el objeto es del tipo derivado (DynamicCart).

Cuando aplique el atributo XmlIgnore a la propiedad virtual en la clase base, la lista no se serializa en el archivo.

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

Supongo que debe declarar el tipo derivado en la clase base para la serialización XML. Suena un poco tonto, pero es por especificación.

ver este MSDN page, y buscar el siguiente ejemplo:

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

Answer 2

probar este

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

esto le permitirá añadir tantos tipos, desea serializador a inclusde.

Answer 3

Creo que su serializador usa su clase base en lugar de la derivada.

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

Puede hacerlo agregando un método virtual ShouldSerialize*** a la clase base. Por ejemplo:

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

Esto produce (se arregló un poco):

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

SUB: 
<Sub /> 

El método debe tener incluyen el nombre exacto de la propiedad a considerar después de ShouldInclude....