XmlSerializer-Hubo un error que reflejaba el tipo

Recuerde que las clases serializadas deben tener constructores predeterminados (es decir, sin parámetros). Si no tienes ningún constructor, está bien; pero si tienes un constructor con un parámetro, necesitarás agregar el predeterminado también.

Tuve un problema similar, y resultó que el serializador no podía distinguir entre 2 clases que tenía con el mismo nombre (una era una subclase de la otra). La excepción interna se veía así:

'Tipos BaseNamespace.Class1 ' y ' BaseNamespace.SubNamespace.Class1 'ambos usan el nombre de tipo XML, 'Class1', from namespace ". Utilice los atributos XML para especificar un nombre XML único y/o un espacio de nombres para el tipo.

Donde BaseNamespace.SubNamespace.Class1 es una subclase de BaseNamespace.Clase 1.

Lo que necesitaba hacer era agregar un atributo a una de las clases (agregué a la clase base):

[XmlType("BaseNamespace.Class1")]

Nota: Si tiene más capas de clases, también debe agregarles un atributo.

También tenga en cuenta que XmlSerializer no puede serializar propiedades abstractas.. Vea mi pregunta aquí (a la que he agregado el código de solución)..

Serialización XML y Tipos Heredados

Razones Más comunes por mí:

 - the object being serialized has no parameterless constructor
 - the object contains Dictionary
 - the object has some public Interface members

Todos los objetos en el gráfico de serialización tienen que ser serializables.

Dado que XMLSerializer es una caja negra, marque estos enlaces si desea depurar más en el proceso de serialización..

Cambiar el lugar donde XmlSerializer Produce Conjuntos Temporales

CÓMO: Depurar en un ensamblado generado por. NET XmlSerializer

Si necesita manejar atributos específicos (es decir, Diccionario, o cualquier clase), puede implementar la interfaz IXmlSerialiable, que le permitirá más libertad a costa de una codificación más detallada.

public class NetService : IXmlSerializable
{
    #region Data

        public string Identifier = String.Empty;

        public string Name = String.Empty;

        public IPAddress Address = IPAddress.None;
        public int Port = 7777;

    #endregion

    #region IXmlSerializable Implementation

        public XmlSchema GetSchema() { return (null); }

        public void ReadXml(XmlReader reader)
        {
            // Attributes
            Identifier = reader[XML_IDENTIFIER];
            if (Int32.TryParse(reader[XML_NETWORK_PORT], out Port) == false)
            throw new XmlException("unable to parse the element " + typeof(NetService).Name + " (badly formatted parameter " + XML_NETWORK_PORT);
            if (IPAddress.TryParse(reader[XML_NETWORK_ADDR], out Address) == false)
            throw new XmlException("unable to parse the element " + typeof(NetService).Name + " (badly formatted parameter " + XML_NETWORK_ADDR);
        }

        public void WriteXml(XmlWriter writer)
        {
            // Attributes
            writer.WriteAttributeString(XML_IDENTIFIER, Identifier);
            writer.WriteAttributeString(XML_NETWORK_ADDR, Address.ToString());
            writer.WriteAttributeString(XML_NETWORK_PORT, Port.ToString());
        }

        private const string XML_IDENTIFIER = "Id";

        private const string XML_NETWORK_ADDR = "Address";

        private const string XML_NETWORK_PORT = "Port";

    #endregion
}

Hay un interesante artículo , que muestra una forma elegante de implementar una forma sofisticada de "extender" el XmlSerializer.

El artículo dice:

IXmlSerializable está cubierto en la documentación oficial, pero el la documentación indica que no está destinada al uso público y no proporciona información más allá de eso. Esto indica que el equipo de desarrollo quería reservarse el derecho de modificar, deshabilitar o incluso eliminar por completo este gancho de extensibilidad en el futuro. Sin embargo, mientras estés dispuesto a aceptar esta incertidumbre y lidiar con posibles cambios en el futuro, no hay razón alguna para que no puedas aprovecharla.

Debido a esto, sugiero implementar tus propias clases IXmlSerializable, para evitar implementaciones demasiado complicadas.

Could podría ser sencillo implementar nuestra clase personalizada XmlSerializer usando reflexión.

He descubierto que la clase Dictionary en.Net 2.0 no es serializable usando XML, pero se serializa bien cuando se usa la serialización binaria.

Encontré un trabajo alrededor de aquí.

Recientemente obtuve esto en una clase parcial de referencia web al agregar una nueva propiedad. La clase generada automáticamente agregaba los siguientes atributos.

    [System.Xml.Serialization.XmlElementAttribute(Order = XX)]

Necesitaba agregar un atributo similar con un orden más alto que el último en la secuencia generada automáticamente y esto lo arregló para mí.

Yo también pensé que el atributo Serializable tenía que estar en el objeto, pero a menos que esté siendo un novato completo (estoy en medio de una sesión de codificación nocturna), lo siguiente funciona desde el SnippetCompiler :

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

public class Inner
{
    private string _AnotherStringProperty;
    public string AnotherStringProperty 
    { 
      get { return _AnotherStringProperty; } 
      set { _AnotherStringProperty = value; } 
    }
}

public class DataClass
{
    private string _StringProperty;
    public string StringProperty 
    { 
       get { return _StringProperty; } 
       set{ _StringProperty = value; } 
    }

    private Inner _InnerObject;
    public Inner InnerObject 
    { 
       get { return _InnerObject; } 
       set { _InnerObject = value; } 
    }
}

public class MyClass
{

    public static void Main()
    {
        try
        {
            XmlSerializer serializer = new XmlSerializer(typeof(DataClass));
            TextWriter writer = new StreamWriter(@"c:\tmp\dataClass.xml");
            DataClass clazz = new DataClass();
            Inner inner = new Inner();
            inner.AnotherStringProperty = "Foo2";
            clazz.InnerObject = inner;
            clazz.StringProperty = "foo";
            serializer.Serialize(writer, clazz);
        }
        finally
        {
            Console.Write("Press any key to continue...");
            Console.ReadKey();
        }
    }

}

Me imagino que el XmlSerializer está usando reflexión sobre las propiedades públicas.

Tuve una situación en la que el Orden era el mismo para dos elementos en una fila

[System.Xml.Serialization.XmlElementAttribute(IsNullable = true, Order = 0, ElementName = "SeriousInjuryFlag")]

.... algún código ...

[System.Xml.Serialization.XmlElementAttribute(IsNullable = true, Order = 0, ElementName = "AccidentFlag")]

Cuando cambié el código para incrementar el orden en uno para cada nueva Propiedad en la clase, el error desapareció.

Acabo de recibir el mismo error y descubrí que una propiedad de tipo IEnumerable<SomeClass> era el problema. Parece que IEnumerable no puede ser serializado directamente.

También tenga en cuenta que no puede serializar los controles de la interfaz de usuario y que cualquier objeto que desee pasar al portapapeles debe ser serializable de lo contrario no se puede pasar a otros procesos.

He estado usando la clase NetDataSerialiser para serializar mis clases de dominio. NetDataContractSerializer Class.

Las clases de dominio se comparten entre cliente y servidor.

[Sistema.XML.Serialización.XmlElementAttribute ("strFieldName", Form = System.XML.Esquema.XmlSchemaForm.Sin reservas)]

//O

[XmlIgnore] string [] strFielsName {get; set;}

Tuve el mismo problema y en mi caso el objeto tenía una ReadOnlyCollection. Una colección debe implementar el método Add para ser serializable.