Wie wird ein Objekt in XML serialisiert, ohne xmlns = "..." zu erhalten?

Question

Gibt es eine Möglichkeit für mich, ein Objekt in .NET zu serialisieren, ohne dass die XML-Namespaces automatisch serialisiert werden? Es scheint, dass .NET standardmäßig glaubt, dass die XSI- und XSD-Namespaces enthalten sein sollten, aber ich will sie nicht dort.

Answer 1

Ahh ... vergiss es. Es ist immer die Suche nach der Frage, die die Antwort liefert. Mein Objekt, das serialisiert wird, ist obj und wurde bereits definiert. Das Hinzufügen eines XMLSerializerNamespace mit einem einzelnen leeren Namespace zur Auflistung führt den Trick aus.

In VB wie folgt aus:

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 

in C# wie folgt aus:

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

Wenn Sie den zusätzlichen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" und xmlns:xsd="http://www.w3.org/2001/XMLSchema" loswerden wollen, aber immer noch einen eigenen Namensraum xmlns="http://schemas.YourCompany.com/YourSchema/" halten Sie Verwenden Sie den gleichen Code wie oben, mit Ausnahme dieser einfachen Änderung:

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

Answer 3

Wenn Sie nicht extra Xmlns für jedes Element-Attribute, um loszuwerden, wenn sie von generierten Klassen in XML Serialisierung (zB: wenn xsd.exe verwendet wurde), so haben Sie so etwas wie:

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

dann ich würde mit Ihnen teilen, was für mich (eine Mischung aus früheren Antworten und was ich here gefunden) arbeitete

ausdrücklich alle Ihre verschiedenen xmlns wie folgt festgelegt:

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

gibt es dann an den serialize

serializer.Serialize(writer, object, xmlns); 

Sie werden die drei Namensräume im Stammelement deklariert haben und nicht mehr benötigten in den anderen Elementen erzeugt werden, die entsprechend

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

vorangestellt werden

Answer 4

ich schlage vor, diese Hilfsklasse:

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

Wenn Sie den Namespace entfernen möchten, können Sie auch die Version entfernen, um Sie zu speichern, ich habe diese Funktionalität hinzugefügt, so dass der folgende Code beides tun wird.

Ich habe es auch in eine generische Methode gewickelt, wie ich sehr große XML-Dateien erstellen, die zu groß sind, um im Speicher zu serialisieren, so habe ich meine Ausgabedatei heruntergebrochen und in kleineren "Brocken" serialisiert: