c# - w3org - Serializar SIN xmlns

w3c etiquetas html

Question

Tengo un par de métodos de extensión que manejan la serialización de mis clases, y dado que puede ser un proceso lento, se crean una vez por clase y se reparten por este método.

public static XmlSerializer GetSerializerFor(Type typeOfT)
{
    if (!serializers.ContainsKey(typeOfT))
    {
        var xmlAttributes = new XmlAttributes();
        var xmlAttributeOverrides = new XmlAttributeOverrides();

        System.Diagnostics.Debug.WriteLine(string.Format("XmlSerializerFactory.GetSerializerFor(typeof({0}));", typeOfT));

        xmlAttributes.Xmlns = false;
        xmlAttributeOverrides.Add(typeOfT, xmlAttributes);

        var newSerializer = new XmlSerializer(typeOfT, xmlAttributeOverrides);
        serializers.Add(typeOfT, newSerializer);
    }

    return serializers[typeOfT];
}

Esto es llamado por el método de extensión .Serialize ()

public static XElement Serialize(this object source)
{
    try
    {
        var serializer = XmlSerializerFactory.GetSerializerFor(source.GetType());
        var xdoc = new XDocument();
        using (var writer = xdoc.CreateWriter())
        {
            serializer.Serialize(writer, source, new XmlSerializerNamespaces(new[] { new XmlQualifiedName("", "") }));
        }

        return (xdoc.Document != null) ? xdoc.Document.Root : new XElement("Error", "Document Missing");
    }
    catch (Exception x)
    {
        return new XElement("Error", x.ToString());
    }
}

Desafortunadamente, cuando se serializan las clases que se generan automáticamente, tienen el atributo XmlTypeAttribute(Namespace="http://tempuri.org/") aplicado a ellas.

Esto causa la deserialización por parte de las contrapartes no autogeneradas para que fallen.

Necesito el serializador para ignorar por completo y no aplicar el espacio de nombres, pero lo que he escrito en el primer bloque de código no parece eliminarlo, aún así termino con xml como este

<Note>
  <ID xmlns="http://tempuri.org/">12</ID>
  <Author xmlns="http://tempuri.org/">
    <ID>1234</ID>
    <Type>Associate</Type>
    <IsAvailable>false</IsAvailable>
  </Author>
  <Created xmlns="http://tempuri.org/">2010-06-22T09:38:01.5024351-05:00</Created>
  <Text xmlns="http://tempuri.org/">This is an update</Text>
</Note>

En lugar de lo mismo, menos el atributo xmlns="http://tempuri.org/" .

Por favor ayuda, gracias, ¡esto me está volviendo loco!

EDITAR:

Conozco el problema, pero no cómo solucionarlo.

Mi clase no solo está llena de tipos simples.

Contiene propiedades con tipos de otras clases. Que también se generan automáticamente con el XmlTypeAttribute(Namespace = "http://tempuri.org/") . Entonces, lo que está sucediendo es que cuando ocurre la serialización y serializa las propiedades de mi clase, no están pasando por mi serialización personalizada, y por lo tanto, están teniendo el atributo aplicado y no anulado.

Ahora solo necesito descubrir cómo saltar ese aro. ¿Alguna idea de cómo?

EDICION 2:

Los siguientes trabajos para serializar SIN xmlns ... pero estoy teniendo un problema en el extremo de deserialización, aún no estoy seguro de si está relacionado o no

public static XmlSerializer GetSerializerFor(Type typeOfT)
{
    if (!serializers.ContainsKey(typeOfT))
    {
        var xmlAttributes = new XmlAttributes();
        var xmlAttributeOverrides = new XmlAttributeOverrides();

        System.Diagnostics.Debug.WriteLine(string.Format("XmlSerializerFactory.GetSerializerFor(typeof({0}));", typeOfT));

        xmlAttributes.XmlType = new XmlTypeAttribute
        {
            Namespace = ""
        };

        xmlAttributes.Xmlns = false;

        var types = new List<Type> {typeOfT, typeOfT.BaseType};

        foreach (var property in typeOfT.GetProperties())
        {
            types.Add(property.PropertyType);
        }

        types.RemoveAll(t => t.ToString().StartsWith("System."));

        foreach (var type in types)
        {
            xmlAttributeOverrides.Add(type, xmlAttributes);
        }

        var newSerializer = new XmlSerializer(typeOfT, xmlAttributeOverrides);
        //var newSerializer = new XmlSerializer(typeOfT, xmlAttributeOverrides, extraTypes.ToArray(), new XmlRootAttribute(), string.Empty);
        //var newSerializer = new XmlSerializer(typeOfT, string.Empty);

        serializers.Add(typeOfT, newSerializer);
    }

    return serializers[typeOfT];
}

EDIT3: Terminó usando la solución de ¿Cómo eliminar todos los espacios de nombres de XML con C #?

public static XElement RemoveAllNamespaces(this XElement source)
{
    return !source.HasElements
               ? new XElement(source.Name.LocalName)
                     {
                         Value = source.Value
                     }
               : new XElement(source.Name.LocalName, source.Elements().Select(el => RemoveAllNamespaces(el)));
}

Answer 1

No hay problema: simplemente pase una cadena vacía como el espacio de nombres predeterminado al serializador XML:

XmlSerializer newSerializer = 
   new XmlSerializer(typeOfT, "");

Desafortunadamente, no hay una sobrecarga de constructor fácil si realmente necesita definir XmlAttributeOverrides y el espacio de nombres predeterminado, por lo que puede omitir XmlAttributeOverrides y usar ese constructor que mencioné, o necesita usar el que define todos los parámetros posibles (incluyendo XmlAttributeOverrides y espacios de nombres XML predeterminados, y algunos más).

Answer 2

Una solución de trabajo, para el registro!

var ns = new XmlSerializerNamespaces();
ns.Add("", ""); 
var serializer = new XmlSerializer(yourType); 
serializer.Serialize(xmlTextWriter, someObject, ns);

Answer 3

 public static byte[] SerializeByteByType(object objectToSerialize, Type type)
    {
        XmlWriterSettings xmlSetting = new XmlWriterSettings()
        {
            NewLineOnAttributes = false,
            OmitXmlDeclaration = true,
            Indent = false,
            NewLineHandling = NewLineHandling.None,
            Encoding = Encoding.UTF8,
            NamespaceHandling = NamespaceHandling.OmitDuplicates
        };

        using (MemoryStream stm = new MemoryStream())
        {
            using (XmlWriter writer = XmlWriter.Create(stm, xmlSetting))
            {
                var xmlAttributes = new XmlAttributes();
                var xmlAttributeOverrides = new XmlAttributeOverrides();

                xmlAttributes.Xmlns = false;
                xmlAttributes.XmlType = new XmlTypeAttribute() { Namespace = "" };
                xmlAttributeOverrides.Add(type, xmlAttributes);

                XmlSerializer serializer = new XmlSerializer(type, xmlAttributeOverrides);
                //Use the following to serialize without namespaces
                XmlSerializerNamespaces xmlSrzNamespace = new XmlSerializerNamespaces();
                xmlSrzNamespace.Add("", "");

                serializer.Serialize(writer, objectToSerialize, xmlSrzNamespace);
                stm.Flush();
                stm.Position = 0;
            }

            return stm.ToArray();
        }
    }