Comment sérialiser un objet en XML sans obtenir xmlns = "..."?

Question

Existe-t-il un moyen pour moi de sérialiser un objet dans .NET sans que les espaces de noms XML se sérialisent automatiquement également? Il semble que par défaut .NET pense que les espaces de noms XSI et XSD devraient être inclus, mais je ne les veux pas là.

Answer 1

Ahh ... peu importe. C'est toujours la recherche après que la question posée pose la réponse. Mon objet en cours de sérialisation est obj et a déjà été défini. L'ajout d'un XMLSerializerNamespace avec un seul espace de noms vide à la collection fait l'affaire.

Dans VB comme ceci:

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# comme ceci:

//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 vous voulez vous débarrasser de la xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" et xmlns:xsd="http://www.w3.org/2001/XMLSchema", mais toujours garder supplémentaire votre propre espace de noms xmlns="http://schemas.YourCompany.com/YourSchema/", vous utiliser le même code que ci-dessus, sauf pour ce simple changement:

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

Answer 3

Si vous ne parvenez pas à vous débarrasser de xmlns supplémentaires attributs pour chaque élément, lors de la sérialisation XML de classes générées (par exemple: quand xsd.exe a été utilisé), de sorte que vous avez quelque chose comme:

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

puis Je voudrais partager avec vous ce qui a fonctionné pour moi (un mélange de réponses précédentes et ce que je trouve here)

définir explicitement toutes vos différentes xmlns comme suit:

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") 

puis passer à la serialize

serializer.Serialize(writer, object, xmlns); 

vous aurez les trois espaces de noms déclarés dans l'élément racine et pas plus nécessaire à générer dans les autres éléments qui seront préfixés en conséquence

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

Answer 4

Je Suggérer cette classe d'aide:

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 vous souhaitez supprimer l'espace de nom, vous pouvez également supprimer la version. Pour vous éviter de devoir effectuer une recherche, j'ai ajouté cette fonctionnalité afin que le code ci-dessous fasse les deux. Je l'ai aussi enveloppé dans une méthode générique car je crée de très gros fichiers xml qui sont trop volumineux pour être sérialisés en mémoire, donc j'ai cassé mon fichier de sortie et je l'ai sérialisé en plus petits morceaux:

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 
     } 
    }