Trucchi di serializzazione XML .NET? [chiuso]

Ho riscontrato alcuni trucchi durante la serializzazione XML C # che pensavo di condividere:

• Non è possibile serializzare elementi di sola lettura (come KeyValuePairs)
• Non è possibile serializzare un dizionario generico. Prova invece questa classe wrapper (da http://weblogs.asp.net/pwelter34/archive/2006/05/03/444961.aspx ):

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;

[XmlRoot("dictionary")]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{      
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }

    public void ReadXml(System.Xml.XmlReader reader)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();

        if (wasEmpty)
            return;

        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
            reader.ReadStartElement("item");

            reader.ReadStartElement("key");
            TKey key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();

            reader.ReadStartElement("value");
            TValue value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();

            this.Add(key, value);

            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }

    public void WriteXml(System.Xml.XmlWriter writer)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));

        foreach (TKey key in this.Keys)
        {
            writer.WriteStartElement("item");

            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();

            writer.WriteStartElement("value");
            TValue value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();

            writer.WriteEndElement();
        }
    }
}

Qualche altro trucco di serializzazione XML là fuori?

Un altro enorme trucco: quando si invia XML tramite una pagina Web (ASP.NET), non si desidera includere Unicode Byte-Order Mark . Naturalmente, i modi per utilizzare o meno la distinta materiali sono quasi gli stessi:

BAD (include BOM):

XmlTextWriter wr = new XmlTextWriter(stream, new System.Text.Encoding.UTF8);

BENE:

XmlTextWriter  wr = new XmlTextWriter(stream, new System.Text.UTF8Encoding(false))

È possibile passare esplicitamente false per indicare che non si desidera la distinta componenti. Notare la chiara, ovvia differenza tra Encoding.UTF8e UTF8Encoding.

I tre byte BOM aggiuntivi all'inizio sono (0xEFBBBF) o (239 187 191).

Riferimento: http://chrislaco.com/blog/troubleshooting-common-problems-with-the-xmlserializer/

Non posso ancora fare commenti, quindi commenterò il post di Dr8k e farò un'altra osservazione. Variabili private che sono esposte come proprietà getter / setter pubbliche e vengono serializzate / deserializzate come tali tramite tali proprietà. L'abbiamo sempre fatto nel mio vecchio lavoro.

Una cosa da notare però è che se hai una logica in quelle proprietà, la logica viene eseguita, quindi a volte, l'ordine di serializzazione è davvero importante. I membri sono ordinati in modo implicito in base a come sono ordinati nel codice, ma non ci sono garanzie, soprattutto quando si eredita un altro oggetto. Ordinarli esplicitamente è un dolore nella parte posteriore.

Sono stato bruciato da questo in passato.

Durante la serializzazione in una stringa XML da un flusso di memoria, assicurati di usare MemoryStream # ToArray () invece di MemoryStream # GetBuffer () o ti ritroverai con caratteri spazzatura che non verranno deserializzati correttamente (a causa del buffer aggiuntivo allocato).

http://msdn.microsoft.com/en-us/library/system.io.memorystream.getbuffer(VS.80).aspx

Se il serializzatore rileva un membro / proprietà che ha un'interfaccia come tipo, non verrà serializzato. Ad esempio, quanto segue non verrà serializzato in XML:

public class ValuePair
{
    public ICompareable Value1 { get; set; }
    public ICompareable Value2 { get; set; }
}

Sebbene questo serializzerà:

public class ValuePair
{
    public object Value1 { get; set; }
    public object Value2 { get; set; }
}

IEnumerables<T>che vengono generati tramite i rendimenti di rendimento non sono serializzabili. Questo perché il compilatore genera una classe separata per implementare il rendimento del rendimento e quella classe non è contrassegnata come serializzabile.

Non è possibile serializzare le proprietà di sola lettura. È necessario disporre di un getter e di un setter, anche se non si intende mai utilizzare la deserializzazione per trasformare XML in un oggetto.

Per lo stesso motivo, non è possibile serializzare proprietà che restituiscono interfacce: il deserializzatore non saprebbe quale classe concreta istanziare.

Oh, eccone uno buono: poiché il codice di serializzazione XML viene generato e inserito in una DLL separata, non si ottiene alcun errore significativo quando c'è un errore nel codice che interrompe il serializzatore. Qualcosa come "impossibile individuare s3d3fsdf.dll". Bello.

Non è possibile serializzare un oggetto che non ha un costruttore senza parametri (è stato appena morso da quello).

E per qualche motivo, dalle seguenti proprietà, Value viene serializzato, ma non FullName:

    public string FullName { get; set; }
    public double Value { get; set; }

Non sono mai riuscito a capire perché, ho solo cambiato Value in internal ...

Un'altra cosa da notare: non è possibile serializzare membri di classi private / protette se si utilizza la serializzazione XML "predefinita".

Ma puoi specificare una logica di serializzazione XML personalizzata che implementa IXmlSerializable nella tua classe e serializzare tutti i campi privati ​​di cui hai bisogno / desideri.

http://msdn.microsoft.com/en-us/library/system.xml.serialization.ixmlserializable.aspx

Se l'assembly generato dalla serializzazione XML non è nello stesso contesto di caricamento del codice che tenta di usarlo, ti imbatterai in errori fantastici come:

System.InvalidOperationException: There was an error generating the XML document.
---System.InvalidCastException: Unable to cast object
of type 'MyNamespace.Settings' to type 'MyNamespace.Settings'. at
Microsoft.Xml.Serialization.GeneratedAssembly.
  XmlSerializationWriterSettings.Write3_Settings(Object o)

La causa di ciò per me era un plug-in caricato utilizzando il contesto LoadFrom che presenta molti svantaggi nell'utilizzo del contesto di caricamento. Piuttosto divertente rintracciarlo.

Potrebbero verificarsi problemi durante la serializzazione di oggetti di tipo Colore e / o Carattere.

Ecco i consigli che mi hanno aiutato:

http://www.codeproject.com/KB/XML/xmlsettings.aspx

http://www.codeproject.com/KB/cs/GenericXmlSerializition.aspx

Vedere " Supporto di associazione degli attributi del linguaggio di definizione dello schema XML avanzato " per i dettagli di ciò che è supportato dal serializzatore XML e per i dettagli sul modo in cui sono supportate le funzionalità XSD supportate.

Se si tenta di serializzare un array List<T>o IEnumerable<T>che contiene istanze di sottoclassi di T, è necessario utilizzare XmlArrayItemAttribute per elencare tutti i sottotipi utilizzati. Altrimenti otterrai un inutile System.InvalidOperationExceptionin fase di esecuzione quando serializzi.

Ecco parte di un esempio completo dalla documentazione

public class Group
{  
   /* The XmlArrayItemAttribute allows the XmlSerializer to insert both the base 
      type (Employee) and derived type (Manager) into serialized arrays. */

   [XmlArrayItem(typeof(Manager)), XmlArrayItem(typeof(Employee))]
   public Employee[] Employees;

Le variabili / proprietà private non sono serializzate nel meccanismo predefinito per la serializzazione XML, ma sono nella serializzazione binaria.

Le proprietà contrassegnate con l' Obsoleteattributo non vengono serializzate. Non ho provato con l' Deprecatedattributo ma presumo che si comporterebbe allo stesso modo.

Non posso davvero spiegare questo, ma ho scoperto che non serializzerà:

[XmlElement("item")]
public myClass[] item
{
    get { return this.privateList.ToArray(); }
}

ma questo:

[XmlElement("item")]
public List<myClass> item
{
    get { return this.privateList; }
}

E vale anche la pena notare che se stai serializzando un memstream, potresti voler cercare 0 prima di usarlo.

Fai attenzione a serializzare i tipi senza serializzazione esplicita, può causare ritardi mentre .Net li crea. L'ho scoperto di recente durante la serializzazione di RSAParameters .

Se il tuo XSD fa uso di gruppi di sostituzione, è probabile che tu non possa (de) serializzarlo automaticamente. Dovrai scrivere i tuoi serializzatori per gestire questo scenario.

Per esempio.

<xs:complexType name="MessageType" abstract="true">
    <xs:attributeGroup ref="commonMessageAttributes"/>
</xs:complexType>

<xs:element name="Message" type="MessageType"/>

<xs:element name="Envelope">
    <xs:complexType mixed="false">
        <xs:complexContent mixed="false">
            <xs:element ref="Message" minOccurs="0" maxOccurs="unbounded"/>
        </xs:complexContent>
    </xs:complexType>
</xs:element>

<xs:element name="ExampleMessageA" substitutionGroup="Message">
    <xs:complexType mixed="false">
        <xs:complexContent mixed="false">
                <xs:attribute name="messageCode"/>
        </xs:complexContent>
    </xs:complexType>
</xs:element>

<xs:element name="ExampleMessageB" substitutionGroup="Message">
    <xs:complexType mixed="false">
        <xs:complexContent mixed="false">
                <xs:attribute name="messageCode"/>
        </xs:complexContent>
    </xs:complexType>
</xs:element>

In questo esempio, una busta può contenere messaggi. Tuttavia, il serializzatore predefinito di .NET non distingue tra Message, ExampleMessageA e ExampleMessageB. Serializzerà solo da e verso la classe Message di base.

Le variabili / proprietà private non sono serializzate nella serializzazione XML, ma sono nella serializzazione binaria.

Credo che questo ti dia anche se stai esponendo i membri privati ​​attraverso proprietà pubbliche: i membri privati ​​non vengono serializzati, quindi i membri pubblici fanno tutti riferimento a valori nulli.