.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名前空間を削除するには、xmlns =”…”を取得せずにオブジェクトをXMLにシリアル化する方法の回答に従います。

<message>(名前空間属性なしの)メッセージタグが必要です。これどうやってするの?


2
これでxmlの見栄えが良くなると思いますが、名前空間とそれに対応するxsdを提供する方がより良い方法です。

2
私はxmlを<message>としてのみ使用したいのですが、xmlns:xsiおよびxmlns:xsd名前空間の省略について話しています。
NetSide 2009年

5
記録として:一般に、これは愚かな間違いです。名前空間は理由のために存在し、それらをすべて削除すると問題が発生します。逆シリアル化のようなもの。
ジョンサンダース

66
時にはそれは愚かではなく、間違いではないことに注意してください。たとえば、ドキュメントのフラグメントを生成し、後でまとめる必要がある場合があります。個人的には、類似した非常に大きなドキュメントを大量に生成する必要がありました。それらのすべては木の奥深くに同じ大きな部分を持っていました。そのため、事前に不変部分を生成し、ドキュメントの生成時にそれらをバイト配列として挿入する必要がありました。したがって、出力をより読みやすく、より小さくするには、内部にある名前空間宣言の一部を省略する必要がありました。それらは上位レベルに存在していたためです。
Dmitry Tashkinov

回答:


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 2013

@ ThomasLevesque、XmlInclude属性の使用中にデフォルトの名前空間を削除するにはどうすればよいですか?
Jeson Martajaya 2014年

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

27

これは2つの答えの2番目です。

シリアル化中にドキュメントからすべての名前空間を任意に削除したい場合は、独自のXmlWriterを実装することでこれを行うことができます。

最も簡単な方法は、XmlTextWriterから派生し、名前空間を生成するStartElementメソッドをオーバーライドすることです。StartElementメソッドは、ルートなどの要素を出力するときにXmlSerializerによって呼び出されます。各要素の名前空間をオーバーライドし、それを空の文字列で置き換えることにより、出力から名前空間を取り除きました。

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公開識別子またはシステム識別子の文字。

XmlTextWriterに関するこれらの問題は、.NET Frameworkのv1.1以降で発生しており、下位互換性のために残っています。これらの問題について懸念がない場合は、必ず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());

これのクレジットをOleg Tkachenkoに


3
LookupPrefix(string ns)すべてのスキーマ宣言を削除するには、常に空の文字列を返すようにオーバーライドする必要があることもわかりました。
ケビンブロック

これは技術的に質問に答えるものではありません-あなたはXmlWriterではなくXmlTextWriterを使用しています。XmlWriterを使用したいので、使用できるXmlWriterSettingsに気づきました。
そろばん2013

@Abacusはコードを読みましたか?使っXmlWriter XmlWriterSettingsます。
Cheeso 2013

私の悪い、私はそれを逃したにちがいない。
そろばん

すばらしい回答、@ KevinBrockから追加されたメソッドに加えて、コードがすべてを削除する前に、<!-language:lang-cs-> WriteStartAttribute(string prefix、string localName、string ns)をオーバーロードする必要もありました。名前空間。また、名前空間の接頭辞がb2p1からp2に変更されたことにも注意する必要がありました。
Mabdullah 14

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>

私はこのメソッドを、Webサービス呼び出しのためにXMLにシリアル化されるクラスの深い階層を持つ最近のプロジェクトで正常に使用しました。Microsoftのドキュメントは、XmlSerializerNamespacesいったん作成した公にアクセス可能なメンバーをどうするかについてあまり明確ではなく、多くの人はそれを役に立たないと考えています。しかし、それらのドキュメントに従って上記の方法で使用することにより、サポートされていない動作や「独自のロール」シリアル化を実装することなく、XmlSerializerがクラスのXMLを生成する方法をカスタマイズできます。IXmlSerializable

この答えが、によって生成された標準xsixsd名前空間を取り除く方法を一時停止することを願っていますXmlSerializer

更新:OPのすべての名前空間の削除に関する質問に確実に回答したいだけです。上記の私のコードはこれで動作します。その方法をお見せしましょう。さて、上の例では、実際にはすべての名前空間を削除することはできません(2つの名前空間が使用されているため)。XMLドキュメントのどこかに、のようなものが必要になりますxmlns="urn:Abracadabra" xmlns:w="urn:Whoohoo。例のクラスがより大きなドキュメントの一部である場合、名前空間の上のどこかで、とのどちらか(または両方)Abracadbraを宣言する必要がありWhoohooます。そうでない場合は、一方または両方の名前空間の要素をある種の接頭辞で装飾する必要があります(デフォルトの名前空間を2つ持つことはできませんよね?)。したがって、この例で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名前空間。


「Microsoftのドキュメントには、サポートされていないことが明記されています。」どこで共有するか?
Dave Van den Eynde 2012年

Dave、同様の質問XmlSerializerへの私の回答に投稿したように、不要なxsiおよびxsd名前空間を削除します。リンクはここにあります:XmlSerializerNamespaces Class
fourpastmidnight

1
名前空間をSerializeメソッドに渡しています。パブリックメンバーを提供するという考えは、あなたがそうする必要がないということだと思いましたか?Serializeメソッドに渡さないと、機能しません。そして、残念ながら、そのメソッド呼び出しにアクセスできません。XmlSerializerインスタンスのみを使用するように設定できます。
ときめき

それが実際にXmlWriter含まれてXmlMediaTypeFormatterいるのは、xsiおよびxsd名前空間を強制的に出力に含めるものであることがわかりました。これは、WebApiのデフォルトを使用しているユーザーにのみ影響しますXmlMediaTypeFormatter。そのソースコードをコピーし、NamespacesプロパティをSerializeメソッドに渡すように変更してXmlWriter、が2つのデフォルトを自動的に追加しないようにする必要があります。参照してくださいこの回答
ときめき

@crush、あなたがリンクした回答は誤解を招く-間違いではありませんが、その主張はすべて正しいわけではありません。私の回答の最初のコードスニペットを見るXmlSerializerNamespacesと、で装飾された型のパブリックメンバーを公開するときにXmlSerializerがどのように機能するかを明示的に示すコメントが表示されますXmlNamespacesDeclarationAttribute。これはMSDNから直接取得れたものであり、基本的に、によって提供されるデフォルトの名前空間の代わりに、宣言された名前空間を使用しますXmlSerializer
fourpastmidnight

6

これは、質問に対する私の2つの回答の最初のものです。

名前空間を細かく制御したい場合-たとえば、一部の名前空間を省略し、他の名前空間を省略したくない場合、または1つの名前空間を別の名前空間に置き換えたい場合は、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>

ルート要素にはデフォルトの名前空間があり、「Label」要素にも別個の名前空間があることに注意してください。これらの名前空間は、上記のコードで型を装飾する属性によって決定されました。

.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);
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.