在.NET中序列化对象时,是否省略所有xsi和xsd命名空间?


132

代码如下:

StringBuilder builder = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = true;
using (XmlWriter xmlWriter = XmlWriter.Create(builder, settings))
{
    XmlSerializer s = new XmlSerializer(objectToSerialize.GetType());
    s.Serialize(xmlWriter, objectToSerialize);
}

生成的序列化文档包括名称空间,如下所示:

<message xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" 
    xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" 
    xmlns="urn:something">
 ...
</message>

要删除xsi和xsd命名空间,我可以按照如何将对象序列化为XML而不得到xmlns =”…”的回答

我希望我的消息标签为<message>(没有任何名称空间属性)。我怎样才能做到这一点?


2
我知道您认为这可能会使xml看起来更好,但是提供名称空间和相应的xsd是更好的做法。

2
我只希望我的xml作为<message>,我正在谈论省略xmlns:xsi和xmlns:xsd命名空间。
NetSide

5
作为记录:通常,这是一个愚蠢的错误。命名空间的存在是有原因的,将其全部删除会破坏事情。诸如反序列化之类的事情。
约翰·桑德斯

66
请注意,有时候这不是愚蠢的,也不是错误的。例如,可能需要生成文档片段,然后将它们放在一起。我个人需要生成许多相似且非常大的文档。他们所有人在树的深处都有相同的大部分。因此,我必须事先生成不变部分,并在生成文档时将它们作为字节数组插入。因此,为了使输出更具可读性和较小性,我需要在内部省略一些名称空间声明,因为它们存在于更高级别。
德米特里·塔什基诺夫

Answers:


233
...
XmlSerializer s = new XmlSerializer(objectToSerialize.GetType());
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("","");
s.Serialize(xmlWriter, objectToSerialize, ns);

2
我只想补充一点,删除默认名称空间会产生意想不到的后果:例如,如果您使用XmlInclude属性序列化派生类型,则无论您是否想要,名称空间都会添加到每个这些元素中,因为它们是反序列化所必需的
托马斯·列维斯克

3
另外,正如所提问题,这并不会删除所有 xml名称空间。如问题stackoverflow.com/questions/258960中所述,它仅删除xsi和xsd名称空间,该问题也在问题中引用。
Cheeso

1
如我自己的答案中所述,MS也不支持。它并不总是工作,尤其是当你的类型可能会与其他人一起使用有命名空间。
fourpastmidnight

@ThomasLevesque,如何在使用XmlInclude属性时删除默认名称空间?
Jeson Martajaya 2014年

4
可以缩短为s.Serialize(writer, objectToSerialize, new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty }));
Xeevis

27

这是两个答案中的第二个。

如果只想在序列化过程中从文档中任意剥离所有命名空间,则可以通过实现自己的XmlWriter来实现。

最简单的方法是从XmlTextWriter派生并覆盖发出名称空间的StartElement方法。发出任何元素(包括根)时,XmlSerializer会调用StartElement方法。通过覆盖每个元素的名称空间,并将其替换为空字符串,您已经从输出中剥离了名称空间。

public class NoNamespaceXmlWriter : XmlTextWriter
{
    //Provide as many contructors as you need
    public NoNamespaceXmlWriter(System.IO.TextWriter output)
        : base(output) { Formatting= System.Xml.Formatting.Indented;}

    public override void WriteStartDocument () { }

    public override void WriteStartElement(string prefix, string localName, string ns)
    {
        base.WriteStartElement("", localName, "");
    }
}

假设这是类型:

// explicitly specify a namespace for this type,
// to be used during XML serialization.
[XmlRoot(Namespace="urn:Abracadabra")]
public class MyTypeWithNamespaces
{
    // private fields backing the properties
    private int _Epoch;
    private string _Label;

    // explicitly define a distinct namespace for this element
    [XmlElement(Namespace="urn:Whoohoo")]
    public string Label
    {
        set {  _Label= value; } 
        get { return _Label; } 
    }

    // this property will be implicitly serialized to XML using the
    // member name for the element name, and inheriting the namespace from
    // the type.
    public int Epoch
    {
        set {  _Epoch= value; } 
        get { return _Epoch; } 
    }
}

这是在序列化过程中使用这种方法的方式:

        var o2= new MyTypeWithNamespaces { ..intializers.. };
        var builder = new System.Text.StringBuilder();
        using ( XmlWriter writer = new NoNamespaceXmlWriter(new System.IO.StringWriter(builder)))
        {
            s2.Serialize(writer, o2, ns2);
        }            
        Console.WriteLine("{0}",builder.ToString());

不过,XmlTextWriter有点破损。根据参考doc,在编写时不会检查以下内容:

  • 属性和元素名称中的字符无效。

  • 不符合指定编码的Unicode字符。如果Unicode字符不适合指定的编码,则XmlTextWriter不会将Unicode字符转义为字符实体。

  • 属性重复。

  • DOCTYPE公共标识符或系统标识符中的字符。

自.NET Framework v1.1起,XmlTextWriter的这些问题就已经存在,并且为了向后兼容,这些问题将一直存在。如果您不担心这些问题,那么请务必使用XmlTextWriter。但是大多数人想要更多的可靠性。

为此,尽管在序列化期间仍然抑制名称空间,而不是从XmlTextWriter派生,而是定义抽象XmlWriter及其24个方法的具体实现。

一个例子在这里:

public class XmlWriterWrapper : XmlWriter
{
    protected XmlWriter writer;

    public XmlWriterWrapper(XmlWriter baseWriter)
    {
        this.Writer = baseWriter;
    }

    public override void Close()
    {
        this.writer.Close();
    }

    protected override void Dispose(bool disposing)
    {
        ((IDisposable) this.writer).Dispose();
    }

    public override void Flush()
    {
        this.writer.Flush();
    }

    public override string LookupPrefix(string ns)
    {
        return this.writer.LookupPrefix(ns);
    }

    public override void WriteBase64(byte[] buffer, int index, int count)
    {
        this.writer.WriteBase64(buffer, index, count);
    }

    public override void WriteCData(string text)
    {
        this.writer.WriteCData(text);
    }

    public override void WriteCharEntity(char ch)
    {
        this.writer.WriteCharEntity(ch);
    }

    public override void WriteChars(char[] buffer, int index, int count)
    {
        this.writer.WriteChars(buffer, index, count);
    }

    public override void WriteComment(string text)
    {
        this.writer.WriteComment(text);
    }

    public override void WriteDocType(string name, string pubid, string sysid, string subset)
    {
        this.writer.WriteDocType(name, pubid, sysid, subset);
    }

    public override void WriteEndAttribute()
    {
        this.writer.WriteEndAttribute();
    }

    public override void WriteEndDocument()
    {
        this.writer.WriteEndDocument();
    }

    public override void WriteEndElement()
    {
        this.writer.WriteEndElement();
    }

    public override void WriteEntityRef(string name)
    {
        this.writer.WriteEntityRef(name);
    }

    public override void WriteFullEndElement()
    {
        this.writer.WriteFullEndElement();
    }

    public override void WriteProcessingInstruction(string name, string text)
    {
        this.writer.WriteProcessingInstruction(name, text);
    }

    public override void WriteRaw(string data)
    {
        this.writer.WriteRaw(data);
    }

    public override void WriteRaw(char[] buffer, int index, int count)
    {
        this.writer.WriteRaw(buffer, index, count);
    }

    public override void WriteStartAttribute(string prefix, string localName, string ns)
    {
        this.writer.WriteStartAttribute(prefix, localName, ns);
    }

    public override void WriteStartDocument()
    {
        this.writer.WriteStartDocument();
    }

    public override void WriteStartDocument(bool standalone)
    {
        this.writer.WriteStartDocument(standalone);
    }

    public override void WriteStartElement(string prefix, string localName, string ns)
    {
        this.writer.WriteStartElement(prefix, localName, ns);
    }

    public override void WriteString(string text)
    {
        this.writer.WriteString(text);
    }

    public override void WriteSurrogateCharEntity(char lowChar, char highChar)
    {
        this.writer.WriteSurrogateCharEntity(lowChar, highChar);
    }

    public override void WriteValue(bool value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(DateTime value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(decimal value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(double value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(int value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(long value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(object value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(float value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteValue(string value)
    {
        this.writer.WriteValue(value);
    }

    public override void WriteWhitespace(string ws)
    {
        this.writer.WriteWhitespace(ws);
    }


    public override XmlWriterSettings Settings
    {
        get
        {
            return this.writer.Settings;
        }
    }

    protected XmlWriter Writer
    {
        get
        {
            return this.writer;
        }
        set
        {
            this.writer = value;
        }
    }

    public override System.Xml.WriteState WriteState
    {
        get
        {
            return this.writer.WriteState;
        }
    }

    public override string XmlLang
    {
        get
        {
            return this.writer.XmlLang;
        }
    }

    public override System.Xml.XmlSpace XmlSpace
    {
        get
        {
            return this.writer.XmlSpace;
        }
    }        
}

然后,像以前一样,提供一个覆盖StartElement方法的派生类:

public class NamespaceSupressingXmlWriter : XmlWriterWrapper
{
    //Provide as many contructors as you need
    public NamespaceSupressingXmlWriter(System.IO.TextWriter output)
        : base(XmlWriter.Create(output)) { }

    public NamespaceSupressingXmlWriter(XmlWriter output)
        : base(XmlWriter.Create(output)) { }

    public override void WriteStartElement(string prefix, string localName, string ns)
    {
        base.WriteStartElement("", localName, "");
    }
}

然后像这样使用该作家:

        var o2= new MyTypeWithNamespaces { ..intializers.. };
        var builder = new System.Text.StringBuilder();
        var settings = new XmlWriterSettings { OmitXmlDeclaration = true, Indent= true };
        using ( XmlWriter innerWriter = XmlWriter.Create(builder, settings))
            using ( XmlWriter writer = new NamespaceSupressingXmlWriter(innerWriter))
            {
                s2.Serialize(writer, o2, ns2);
            }            
        Console.WriteLine("{0}",builder.ToString());

信贷这奥列格·特卡琴科


3
我发现我还需要重写LookupPrefix(string ns)以始终返回一个空字符串以删除所有模式声明。
凯文·布洛克

从技术上讲,这不能回答问题-您正在使用XmlTextWriter,而不是XmlWriter。我注意到了,因为我想对XmlWriterSettings使用XmlWriter,以便可以将其使用。
算盘

@Abacus您阅读代码了吗?它使用XmlWriter XmlWriterSettings
Cheeso

我不好,我一定错过了。
算盘

很好的答案,除了@KevinBrock的添加方法外,我还需要重载<!-语言:lang-cs-> WriteStartAttribute(字符串前缀,字符串localName,字符串ns),然后我的代码才会删除所有命名空间。同样值得注意的是,我的名称空间前缀从b2p1更改为p2,这导致我检查了其他使用前缀的方法。
Mabdullah

15

在在线阅读Microsoft的文档和几种解决方案后,我发现了解决此问题的方法。它可以通过内置XmlSerializer和自定义XML序列化一起使用IXmlSerialiazble

到目前为止,我将使用与MyTypeWithNamespaces该问题的答案相同的XML示例。

[XmlRoot("MyTypeWithNamespaces", Namespace="urn:Abracadabra", IsNullable=false)]
public class MyTypeWithNamespaces
{
    // As noted below, per Microsoft's documentation, if the class exposes a public
    // member of type XmlSerializerNamespaces decorated with the 
    // XmlNamespacesDeclarationAttribute, then the XmlSerializer will utilize those
    // namespaces during serialization.
    public MyTypeWithNamespaces( )
    {
        this._namespaces = new XmlSerializerNamespaces(new XmlQualifiedName[] {
            // Don't do this!! Microsoft's documentation explicitly says it's not supported.
            // It doesn't throw any exceptions, but in my testing, it didn't always work.

            // new XmlQualifiedName(string.Empty, string.Empty),  // And don't do this:
            // new XmlQualifiedName("", "")

            // DO THIS:
            new XmlQualifiedName(string.Empty, "urn:Abracadabra") // Default Namespace
            // Add any other namespaces, with prefixes, here.
        });
    }

    // If you have other constructors, make sure to call the default constructor.
    public MyTypeWithNamespaces(string label, int epoch) : this( )
    {
        this._label = label;
        this._epoch = epoch;
    }

    // An element with a declared namespace different than the namespace
    // of the enclosing type.
    [XmlElement(Namespace="urn:Whoohoo")]
    public string Label
    {
        get { return this._label; }
        set { this._label = value; }
    }
    private string _label;

    // An element whose tag will be the same name as the property name.
    // Also, this element will inherit the namespace of the enclosing type.
    public int Epoch
    {
        get { return this._epoch; }
        set { this._epoch = value; }
    }
    private int _epoch;

    // Per Microsoft's documentation, you can add some public member that
    // returns a XmlSerializerNamespaces object. They use a public field,
    // but that's sloppy. So I'll use a private backed-field with a public
    // getter property. Also, per the documentation, for this to work with
    // the XmlSerializer, decorate it with the XmlNamespaceDeclarations
    // attribute.
    [XmlNamespaceDeclarations]
    public XmlSerializerNamespaces Namespaces
    {
        get { return this._namespaces; }
    }
    private XmlSerializerNamespaces _namespaces;
}

这就是这堂课的全部。现在,有些人反对XmlSerializerNamespaces在他们的班级中某个地方放置一个物体。但是正如您所看到的,我将它巧妙地藏在默认构造函数中,并公开了一个公共属性以返回名称空间。

现在,当需要序列化类时,您将使用以下代码:

MyTypeWithNamespaces myType = new MyTypeWithNamespaces("myLabel", 42);

/******
   OK, I just figured I could do this to make the code shorter, so I commented out the
   below and replaced it with what follows:

// You have to use this constructor in order for the root element to have the right namespaces.
// If you need to do custom serialization of inner objects, you can use a shortened constructor.
XmlSerializer xs = new XmlSerializer(typeof(MyTypeWithNamespaces), new XmlAttributeOverrides(),
    new Type[]{}, new XmlRootAttribute("MyTypeWithNamespaces"), "urn:Abracadabra");

******/
XmlSerializer xs = new XmlSerializer(typeof(MyTypeWithNamespaces),
    new XmlRootAttribute("MyTypeWithNamespaces") { Namespace="urn:Abracadabra" });

// I'll use a MemoryStream as my backing store.
MemoryStream ms = new MemoryStream();

// This is extra! If you want to change the settings for the XmlSerializer, you have to create
// a separate XmlWriterSettings object and use the XmlTextWriter.Create(...) factory method.
// So, in this case, I want to omit the XML declaration.
XmlWriterSettings xws = new XmlWriterSettings();
xws.OmitXmlDeclaration = true;
xws.Encoding = Encoding.UTF8; // This is probably the default
// You could use the XmlWriterSetting to set indenting and new line options, but the
// XmlTextWriter class has a much easier method to accomplish that.

// The factory method returns a XmlWriter, not a XmlTextWriter, so cast it.
XmlTextWriter xtw = (XmlTextWriter)XmlTextWriter.Create(ms, xws);
// Then we can set our indenting options (this is, of course, optional).
xtw.Formatting = Formatting.Indented;

// Now serialize our object.
xs.Serialize(xtw, myType, myType.Namespaces);

完成此操作后,应获得以下输出:

<MyTypeWithNamespaces>
    <Label xmlns="urn:Whoohoo">myLabel</Label>
    <Epoch>42</Epoch>
</MyTypeWithNamespaces>

我在最近的项目中成功使用了此方法,该项目具有很深层次的类,这些类已序列化为XML以进行Web服务调用。XmlSerializerNamespaces创建公开可访问成员后,Microsoft的文档尚不清楚如何处理它,因此许多人认为它没有用。但是通过遵循他们的文档并以上面显示的方式使用它,您可以自定义XmlSerializer如何为您的类生成XML,而无需诉诸不受支持的行为或通过实现实现“滚动自己的”序列化IXmlSerializable

我希望这个答案能够一劳永逸地解决如何摆脱产生的标准xsixsd名称空间XmlSerializer

更新:我只想确保我回答了OP有关删除所有名称空间的问题。我上面的代码将为此工作;让我告诉你怎么做。现在,在上面的示例中,您确实无法摆脱所有名称空间(因为有两个名称空间正在使用中)。在XML文档中的某处,您将需要具有xmlns="urn:Abracadabra" xmlns:w="urn:Whoohoo。如果在示例类是一个更大的文档的一部分,然后某处命名空间上方必须声明为中的任一个(或两者)AbracadbraWhoohoo。如果不是,则必须使用某种前缀来装饰一个或两个名称空间中的元素(不能有两个默认名称空间,对吗?)。因此,对于此示例,Abracadabra是defalt名称空间。我可以在MyTypeWithNamespaces类内部为名称空间添加名称空间前缀,Whoohoo如下所示:

public MyTypeWithNamespaces
{
    this._namespaces = new XmlSerializerNamespaces(new XmlQualifiedName[] {
        new XmlQualifiedName(string.Empty, "urn:Abracadabra"), // Default Namespace
        new XmlQualifiedName("w", "urn:Whoohoo")
    });
}

现在,在我的类定义中,我表明该<Label/>元素位于命名空间中"urn:Whoohoo",因此我不需要做任何其他事情。现在,当我使用上面未更改的序列化代码序列化该类时,输出为:

<MyTypeWithNamespaces xmlns:w="urn:Whoohoo">
    <w:Label>myLabel</w:Label>
    <Epoch>42</Epoch>
</MyTypeWithNamespaces>

因为<Label>它与文档的其余部分位于不同的名称空间中,所以在某种程度上,它必须用名称空间“修饰”。请注意,仍然没有xsixsd名称空间。


“微软的文档明确表示不支持。” 关心分享在哪里?
Dave Van den Eynde 2012年

Dave,正如您在我对类似问题XmlSerializer的回答中所述:删除不必要的xsi和xsd命名空间一样,链接位于此处:XmlSerializerNamespaces Class
fourpastmidnight

1
您仍在将名称空间传递给Serialize方法。我认为提供公共成员的想法是您不必这样做?如果不将其传递给Serialize方法,我将无法使其正常工作。不幸的是,我无权访问该方法调用。我只能设置要使用的XmlSerializer实例。
暗恋

我发现实际上XmlWriterXmlMediaTypeFormatter强制将xsi和xsd命名空间放入我的输出中的。这只会影响使用WebApi的default的用户XmlMediaTypeFormatter。我为其复制了源代码,并对其进行了修改,以将其Namespaces属性传递给Serialize方法,以防止它XmlWriter自动添加两个默认值。看到这个答案
暗恋

@crush,您链接到的答案具有误导性-没错,但是它的断言并不都是正确的。如果查看答案中的第一个代码段,您将看到一条注释,其中明确指出了当公开用XmlSerializerNamespaces修饰的类型的公共成员时,XmlSerializer的工作方式XmlNamespacesDeclarationAttribute。这是直接从MSDN获取的,实际上使用了那些声明的名称空间来代替.NET提供的默认名称空间XmlSerializer
fourpastmidnight

6

这是我对这个问题的两个回答中的第一个。

如果要对命名空间进行精细控制-例如,如果要忽略其中一些而不是其他命名空间,或者想要将一个命名空间替换为另一个命名空间,则可以使用XmlAttributeOverrides进行此操作。

假设您具有以下类型定义:

// explicitly specify a namespace for this type,
// to be used during XML serialization.
[XmlRoot(Namespace="urn:Abracadabra")]
public class MyTypeWithNamespaces
{
    // private fields backing the properties
    private int _Epoch;
    private string _Label;

    // explicitly define a distinct namespace for this element
    [XmlElement(Namespace="urn:Whoohoo")]
    public string Label
    {
        set {  _Label= value; } 
        get { return _Label; } 
    }

    // this property will be implicitly serialized to XML using the
    // member name for the element name, and inheriting the namespace from
    // the type.
    public int Epoch
    {
        set {  _Epoch= value; } 
        get { return _Epoch; } 
    }
}

而这个序列化伪代码:

        var o2= new MyTypeWithNamespaces() { ..initializers...};
        ns.Add( "", "urn:Abracadabra" );
        XmlSerializer s2 = new XmlSerializer(typeof(MyTypeWithNamespaces));
        s2.Serialize(System.Console.Out, o2, ns);

您将获得类似以下XML的内容:

<MyTypeWithNamespaces xmlns="urn:Abracadabra">
  <Label xmlns="urn:Whoohoo">Cimsswybclaeqjh</Label>
  <Epoch>97</Epoch>
</MyTypeWithNamespaces>

请注意,根元素上有一个默认名称空间,而“标签”元素上也有一个独特的名称空间。在上面的代码中,这些名称空间由装饰类型的属性决定。

.NET中的Xml序列化框架包括显式覆盖装饰实际代码的属性的可能性。您可以通过XmlAttributesOverrides类和朋友来执行此操作。假设我具有相同的类型,并以此方式序列化:

        // instantiate the container for all attribute overrides
        XmlAttributeOverrides xOver = new XmlAttributeOverrides();

        // define a set of XML attributes to apply to the root element
        XmlAttributes xAttrs1 = new XmlAttributes();

        // define an XmlRoot element (as if [XmlRoot] had decorated the type)
        // The namespace in the attribute override is the empty string. 
        XmlRootAttribute xRoot = new XmlRootAttribute() { Namespace = ""};

        // add that XmlRoot element to the container of attributes
        xAttrs1.XmlRoot= xRoot;

        // add that bunch of attributes to the container holding all overrides
        xOver.Add(typeof(MyTypeWithNamespaces), xAttrs1);

        // create another set of XML Attributes
        XmlAttributes xAttrs2 = new XmlAttributes();

        // define an XmlElement attribute, for a type of "String", with no namespace
        var xElt = new XmlElementAttribute(typeof(String)) { Namespace = ""};

        // add that XmlElement attribute to the 2nd bunch of attributes
        xAttrs2.XmlElements.Add(xElt);

        // add that bunch of attributes to the container for the type, and
        // specifically apply that bunch to the "Label" property on the type.
        xOver.Add(typeof(MyTypeWithNamespaces), "Label", xAttrs2);

        // instantiate a serializer with the overrides 
        XmlSerializer s3 = new XmlSerializer(typeof(MyTypeWithNamespaces), xOver);

        // serialize
        s3.Serialize(System.Console.Out, o2, ns2);

结果看起来像这样;

<MyTypeWithNamespaces>
  <Label>Cimsswybclaeqjh</Label>
  <Epoch>97</Epoch>
</MyTypeWithNamespaces>

您已经删除了命名空间。

逻辑上的问题是,是否可以在序列化过程中从任意类型中剥离所有名称空间,而无需进行显式覆盖? 答案是肯定的,该如何做是我的下一个答复。


6
XmlSerializer sr = new XmlSerializer(objectToSerialize.GetType());
TextWriter xmlWriter = new StreamWriter(filename);
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
namespaces.Add(string.Empty, string.Empty);
sr.Serialize(xmlWriter, objectToSerialize, namespaces);
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.