XMLSérialiseur avec de nouvelles valeurs d'énum

Utilisez la sérialisation personnalisée C # avec le versement des objets; Cela vous permettrait de gérer les différentes situations qui surviennent lorsqu'une application est mise à jour et que l'autre n'est pas

Malheureusement, il n'y a aucun moyen de contrôler comment les valeurs ENUM sont désérialisées ... comme solution de contournement, vous pouvez sérialiser les valeurs ENUM en tant que chaîne:

[XmlIgnore]
public MyEnum MyProperty { get; set; }

[XmlElement("MyProperty")]
public string MyPropertyAsString
{
    get
    {
        return EnumToString(MyProperty);
    }
    set
    {
        MyProperty = StringToEnum<MyEnum>(value);
    }
}

public T StringToEnum<T>(string stringValue)
{
    // Manually convert the string to enum, ignoring unknown values
}

public string EnumToString<T>(T enumValue)
{
    // Convert the enum to a string
}

Vous pouvez faire connaître la production des multiples versions des applications consommatrices et utiliser différents espaces de noms différents, XML et C #, pour chacune des versions. Il doit y avoir une certaine coordination entre les applications qui conviendront sur quel schéma ils suiviront et là responsabilités isadditionale sur la demande de production de continuer à être compatible avec toutes les applications de consommation actives possibles.

J'ai également lu avec ce problème et j'ai trouvé une solution partielle à l'aide de XMLattributeOverrides. Par la documentation MS:

Vous pouvez remplacer la valeur de la propriété Nom d'un XMLenumAttribute en créant une instance de la classe XMLenumateTribute et en l'attribuant à la propriété XMLENUM d'un objet XMLATtributes. Pour plus de détails, voir la classe XMLattributeOverrides. P> BlockQuote>

Alors je l'ai fait: P>

XmlEnumAttribute enumAttribute = new XmlEnumAttribute();
enumAttribute.Name = "new value";

XmlAttributes attributes = new XmlAttributes();
attributes.XmlEnum = enumAttribute;

XmlAttributeOverrides attributeOverrides = new XmlAttributeOverrides();
attributeOverrides.Add(typeof(EnumType), "OldValue", attributes);

XmlSerializer serializer = new XmlSerializer(typeof(MyType), attributeOverrides);
FileStream fs = new FileStream(filename, FileMode.Open);
MyType newObj = (MyType)serializer.Deserialize(fs);

Pour une référence future, la meilleure méthode que je pense consiste à utiliser xmlenumattribute.aspx"> xmlenumattribute a> qui indique à l'XMLSérialiseur quel nom chaque valeur ENum a pour la sérialisation et la désérialisation.

public enum EmployeeStatus
{
   [XmlEnum(Name = "Single")]
   One,
   [XmlEnum(Name = "Double")]
   Two,
   [XmlEnum(Name = "Triple")]
   Three
}

J'ai récemment couru dans ce même problème avec le DatacontractSérialiseur. Fondamentalement, le processus de désérialisation de l'énumé est impacciant à cet égard, ce qui rend presque impossible de gérer la compatibilité en arrière.

comme un travail autour, j'ai décidé d'utiliser un champ de support et de gérer la conversion enum moi-même. P>

[DataMember(Name="AddressType")]
private string _addressType { get; set; }

public AddressType AddressType
{
    get
    {
        AddressType result;
        Enum.TryParse(_addressType, out result);
        return result;
    }
}

meilleur moyen est de partager le code de sérialisation / désérialisation entre 2 applications Mais s'il n'est pas possible, vous pouvez utiliser XMLATTRibuteOverrides pour contrôler assez largement la manière dont XML sera désérialisé. Par exemple, au-dessous de la version antérieure de XML, nous voulons désérialiser

    var overrides = new XmlAttributeOverrides();
    overrides.Add(typeof(Style), "Style1", new XmlAttributes { XmlEnum = new 
        XmlEnumAttribute("1" ) } );
    overrides.Add(typeof(Style), "Style2", new XmlAttributes { XmlEnum = new      
        XmlEnumAttribute("2") });
    overrides.Add(typeof(Style), "Style3", new XmlAttributes { XmlEnum = new 
        XmlEnumAttribute("3") });

    var xmlSerializer = new XmlSerializer(typeof(ContentRootType),   
        overrides);
    var content = xmlSerializer.Deserialize(xmlReader) as ContentRootType;