¿Cómo serializar un objeto a XML sin obtener xmlns = "..."?

Question

¿Hay alguna forma de serializar un objeto en .NET sin que los espacios de nombres XML también se serialicen automáticamente? Parece que por defecto .NET cree que los espacios de nombres XSI y XSD deberían incluirse, pero no los quiero allí.

Answer 1

Ahh ... no importa. Siempre es la búsqueda después de la pregunta lo que arroja la respuesta. Mi objeto que se está serializando es obj y ya se ha definido. Agregar un XMLSerializerNamespace con un solo espacio de nombre vacío a la colección hace el truco.

En VB así:

Dim xs As New XmlSerializer(GetType(cEmploymentDetail)) 
Dim ns As New XmlSerializerNamespaces() 
ns.Add("", "") 

Dim settings As New XmlWriterSettings() 
settings.OmitXmlDeclaration = True 

Using ms As New MemoryStream(), _ 
    sw As XmlWriter = XmlWriter.Create(ms, settings), _ 
    sr As New StreamReader(ms) 
xs.Serialize(sw, obj, ns) 
ms.Position = 0 
Console.WriteLine(sr.ReadToEnd()) 
End Using 

en C# como esto:

//Create our own namespaces for the output 
XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); 

//Add an empty namespace and empty value 
ns.Add("", ""); 

//Create the serializer 
XmlSerializer slz = new XmlSerializer(someType); 

//Serialize the object with our own namespaces (notice the overload) 
slz.Serialize(myXmlTextWriter, someObject, ns); 

Answer 2

Si desea deshacerse del exceso xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" y xmlns:xsd="http://www.w3.org/2001/XMLSchema", pero aún así mantener su propio espacio de nombres xmlns="http://schemas.YourCompany.com/YourSchema/", se utilice el mismo código que el anterior excepto para este cambio simple:

// Add lib namespace with empty prefix 
ns.Add("", "http://schemas.YourCompany.com/YourSchema/"); 

Answer 3

Si no puede deshacerse de xmlns adicionales atributos de cada elemento, cuando la serialización XML a partir de las clases generadas (por ejemplo: cuando se utilizó xsd.exe), por lo que tiene algo como:

<manyElementWith xmlns="urn:names:specification:schema:xsd:one" /> 

entonces me gustaría compartir con ustedes lo que funcionó para mí (una mezcla de respuestas anteriores y lo que me encontré here)

establece explícitamente todas sus diferentes xmlns de la siguiente manera:

Dim xmlns = New XmlSerializerNamespaces() 
xmlns.Add("one", "urn:names:specification:schema:xsd:one") 
xmlns.Add("two", "urn:names:specification:schema:xsd:two") 
xmlns.Add("three", "urn:names:specification:schema:xsd:three") 

luego pasarlo a la serialización

serializer.Serialize(writer, object, xmlns); 

tendrá los tres espacios de nombres declarados en el elemento raíz y no más necesario para generar en los demás elementos que se usará como prefijo en consecuencia

<root xmlns:one="urn:names:specification:schema:xsd:one" ... /> 
    <one:Element /> 
    <two:ElementFromAnotherNameSpace /> ... 

Answer 4

Sugiero esta clase de ayuda:

public static class Xml 
{ 
    #region Fields 

    private static readonly XmlWriterSettings WriterSettings = new XmlWriterSettings {OmitXmlDeclaration = true, Indent = true}; 
    private static readonly XmlSerializerNamespaces Namespaces = new XmlSerializerNamespaces(new[] {new XmlQualifiedName("", "")}); 

    #endregion 

    #region Methods 

    public static string Serialize(object obj) 
    { 
     if (obj == null) 
     { 
      return null; 
     } 

     return DoSerialize(obj); 
    } 

    private static string DoSerialize(object obj) 
    { 
     using (var ms = new MemoryStream()) 
     using (var writer = XmlWriter.Create(ms, WriterSettings)) 
     { 
      var serializer = new XmlSerializer(obj.GetType()); 
      serializer.Serialize(writer, obj, Namespaces); 
      return Encoding.UTF8.GetString(ms.ToArray()); 
     } 
    } 

    public static T Deserialize<T>(string data) 
     where T : class 
    { 
     if (string.IsNullOrEmpty(data)) 
     { 
      return null; 
     } 

     return DoDeserialize<T>(data); 
    } 

    private static T DoDeserialize<T>(string data) where T : class 
    { 
     using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(data))) 
     { 
      var serializer = new XmlSerializer(typeof (T)); 
      return (T) serializer.Deserialize(ms); 
     } 
    } 

    #endregion 
} 

:)

Answer 5

Si desea eliminar el espacio de nombre, es posible que también desee eliminar la versión, para ahorrar la búsqueda agregué esa funcionalidad, por lo que el siguiente código hará ambas cosas.

También lo envolví en un método genérico ya que estoy creando archivos xml muy grandes que son demasiado grandes para serializar en la memoria así que he roto mi archivo de salida y lo serializo en "trozos" más pequeños:

public static string XmlSerialize<T>(T entity) where T : class 
    { 
     // removes version 
     XmlWriterSettings settings = new XmlWriterSettings(); 
     settings.OmitXmlDeclaration = true; 

     XmlSerializer xsSubmit = new XmlSerializer(typeof(T)); 
     using (StringWriter sw = new StringWriter()) 
     using (XmlWriter writer = XmlWriter.Create(sw, settings)) 
     { 
      // removes namespace 
      var xmlns = new XmlSerializerNamespaces(); 
      xmlns.Add(string.Empty, string.Empty); 

      xsSubmit.Serialize(writer, entity, xmlns); 
      return sw.ToString(); // Your XML 
     } 
    }