.net - serialización - serializar objeto c#

¿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 se serialicen automáticamente también? Parece que por defecto .NET cree que los espacios de nombres XSI y XSD deberían incluirse, pero no los quiero allí.

Answer 1

Si desea deshacerse de los xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" adicionales xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" y xmlns:xsd="http://www.w3.org/2001/XMLSchema" , pero aún conserve su propio espacio de nombres xmlns="http://schemas.YourCompany.com/YourSchema/" , utiliza el mismo código que el anterior, excepto por este simple cambio:

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

Answer 2

Si desea eliminar el espacio de nombre, es posible que también desee eliminar la versión, para ahorrarle 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 serializarlos 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
}
}

Answer 3

Si no puede deshacerse de los atributos xmlns adicionales para cada elemento, al serializar a xml desde las clases generadas (por ej .: cuando se usó xsd.exe ), entonces tiene algo como:

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

entonces compartiría contigo lo que funcionó para mí (una combinación de respuestas anteriores y lo que encontré here )

Establezca explícitamente todos 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 pásalo a la serialización

serializer.Serialize(writer, object, xmlns);

tendrá los tres espacios de nombres declarados en el elemento raíz y ya no será necesario generarlos en los otros elementos, que serán prefijados 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

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 como este:

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 este:

//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);