具有多个命名空间的 DataContractSerializer

Question

我正在使用 DataContractSerializer 将对象序列化为 XML。主要对象是 SecurityHolding，其命名空间为“http://personaltrading.test.com/”，并包含一个属性名为 Amount 的类，其命名空间为“http://core.test.com”。当我将其序列化为 XML 时，我得到以下信息：

<ArrayOfSecurityHolding xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://personaltrading.test.com/">
  <SecurityHolding>
    <Amount xmlns:d3p1="http://core.test.com/">
        <d3p1:Amount>1.05</d3p1:Amount>
        <d3p1:CurrencyCode>USD</d3p1:CurrencyCode>
    </Amount>
    <BrokerageID>0</BrokerageID>
    <BrokerageName i:nil="true" />
    <RecordID>3681</RecordID>
  </SecurityHolding></ArrayOfSecurityHolding>

我可以控制 d3p1 前缀吗？我是否做错了什么或者我应该做其他事情？

Answer 1

我也曾为这个问题苦苦挣扎。我在下面提出的解决方案不是最佳的恕我直言，但它有效。就像上面的 Marc Gravell 一样，我建议使用 XmlSerializer。

诀窍是向您的类添加一个返回 XmlSerializerNamespaces 对象的字段。该字段必须用 XmlNamespaceDeclarations 属性修饰。在类的构造函数中，添加命名空间，如下例所示。在下面的 xml 中，请注意根元素以及 someString 元素的前缀正确。

有关 XmlSerializerNamespace 的详细信息

架构参考

[XmlRoot(Namespace="http://STPMonitor.myDomain.com")]
public class CFMessage : IQueueMessage<CFQueueItem>
{
    [XmlNamespaceDeclarations]
    public XmlSerializerNamespaces xmlns;

    [XmlAttribute("schemaLocation", Namespace=System.Xml.Schema.XmlSchema.InstanceNamespace)]
    public string schemaLocation = "http://STPMonitor.myDomain.com/schemas/CFMessage.xsd";

    [XmlAttribute("type")]
    public string Type { get; set; }

    [XmlAttribute("username")]
    public string UserName { get; set; }

    [XmlAttribute("somestring", Namespace = "http://someURI.com")]
    public string SomeString = "Hello World";


    public List<CFQueueItem> QueueItems { get; set; }

    public CFMessage()
    {
        xmlns = new XmlSerializerNamespaces();
        xmlns.Add("myDomain", "http://STPMonitor.myDomain.com");
        xmlns.Add("xyz", "http://someURI.com");
    }
}


<?xml version="1.0" encoding="utf-16"?>
<myDomain:CFMessage xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xyz="http://someURI.com"
xsi:schemaLocation="http://STPMonitor.myDomain.com/schemas/CFMessage.xsd"
xyz:somestring="Hello World" type="JOIN" username="SJ-3-3008-1"
xmlns:myDomain="http://STPMonitor.myDomain.com" />

Answer 2

添加“http://www.w3.org/2001/XMLSchema”命名空间：

    private static string DataContractSerialize(object obj)
    {
        StringWriter sw = new StringWriter();

        DataContractSerializer serializer = new DataContractSerializer(obj.GetType());

        using (XmlTextWriter xw = new XmlTextWriter(sw))
        {
            //serializer.WriteObject(xw, obj);
            //
            // Insert namespace for C# types
            serializer.WriteStartObject(xw, obj);
            xw.WriteAttributeString("xmlns", "x", null, "http://www.w3.org/2001/XMLSchema");
            serializer.WriteObjectContent(xw, obj);
            serializer.WriteEndObject(xw);
        }

        StringBuilder buffer = sw.GetStringBuilder();

        return buffer.ToString();
    }

Answer 3

首先，命名空间别名的选择对于格式良好的解析器应该没有影响。

但;它必须是 DataContractSerializer 吗？通过 XmlSerializer，您可以使用接受 XmlSerializerNamespaces 的 Serialize 重载。这允许您选择您使用的名称空间和别名。

最终; DataContractSerializer不旨在提供完整的 xml 控制；这不是它的目标。如果您想要严格的 xml 控制，XmlSerializer 是更好的选择，即使它较旧（并且有自己的一些细微差别/缺点）。

完整示例：

using System;
using System.Xml.Serialization;
public class Amount
{
    public const string CoreNamespace = "http://core.test.com/";
    [XmlElement("Amount", Namespace=CoreNamespace)]
    public decimal Value { get; set; }
    [XmlElement("CurrencyCode", Namespace = CoreNamespace)]
    public string Currency { get; set; }
}
[XmlType("SecurityHolding", Namespace = SecurityHolding.TradingNamespace)]
public class SecurityHolding
{
    public const string TradingNamespace = "http://personaltrading.test.com/";

    [XmlElement("Amount", Namespace = Amount.CoreNamespace)]
    public Amount Amount { get; set; }

    public int BrokerageId { get; set; }
    public string BrokerageName { get; set; }
    public int RecordId { get; set; }
}
static class Program
{
    static void Main()
    {
        var data = new[] {
            new SecurityHolding {
                Amount = new Amount {
                    Value = 1.05M,
                    Currency = "USD"
                },
                BrokerageId = 0,
                BrokerageName = null,
                RecordId = 3681
            }
        };
        var ser = new XmlSerializer(data.GetType(),
            new XmlRootAttribute("ArrayOfSecurityHolding") { Namespace = SecurityHolding.TradingNamespace});
        var ns = new XmlSerializerNamespaces();
        ns.Add("foo", Amount.CoreNamespace);
        ser.Serialize(Console.Out, data, ns);
    }
}

输出：

<ArrayOfSecurityHolding xmlns:foo="http://core.test.com/" xmlns="http://personaltrading.test.com/">
  <SecurityHolding>
    <foo:Amount>
      <foo:Amount>1.05</foo:Amount>
      <foo:CurrencyCode>USD</foo:CurrencyCode>
    </foo:Amount>
    <BrokerageId>0</BrokerageId>
    <RecordId>3681</RecordId>
  </SecurityHolding>
</ArrayOfSecurityHolding>

Answer 4

我解决这个问题的方法与 Marc 略有不同，可以在基类中实现。

1. 创建一个新属性来定义您将在数据协定中使用的其他 XML 命名空间。

   [AttributeUsage(AttributeTargets.Class，Inherited = true，AllowMultiple = true)]    
   公共密封类 NamespaceAttribute ：属性    
   {   
   
       公共命名空间属性()
       {
       }
   
       public NamespaceAttribute（字符串前缀，字符串uri）
       {
           前缀=前缀；
           乌里 = 乌里；
       }
   
       公共字符串前缀 { get;放; }
       公共字符串 Uri { 获取；放; }
   }
   

2. 将该属性添加到您的数据契约中。

   [DataContract(Name = "SomeObject", Namespace = "http://schemas.domain.com/namespace/")]    
   [命名空间（前缀=“a”，Uri=“http://schemas.microsoft.com/2003/10/Serialization/Arrays”）]    
   [命名空间（前缀=“wm”，Uri=“http://schemas.datacontract.org/2004/07/System.Windows.Media”）]           
   公共类 SomeObject : SerializedObject          
   {    
   
       私有 IList<颜色>颜色;
   
       [数据成员]
       [显示名称（“颜色”）]
       公共 IList<颜色>颜色
       {
           获取{返回颜色； }
           设置{颜色=值; }
       }
   }
   

3. 然后在您的 Save 方法中，使用反射来获取属性，然后将它们写入文件。

   public static void Save(SerializedObject o, 字符串文件名)
   {
       使用 (Stream outputStream = new FileStream(文件名, FileMode.Create, FileAccess.Write))
       {
           如果（输出流==空）
               throw new ArgumentNullException(“必须有有效的输出流”);
   
           if (outputStream.CanWrite == false)
               throw new ArgumentException("无法写入输出流");
   
           对象[]属性；
           属性 = o.GetType().GetCustomAttributes(typeof(NamespaceAttribute), true);    
   
           XmlWriterSettings writerSettings = new XmlWriterSettings();                
           writerSettings.Indent = true;
           writerSettings.NewLineOnAttributes = true;                
           使用 (XmlWriter w = XmlWriter.Create(outputStream, writerSettings))
           {
               DataContractSerializer s = new DataContractSerializer(o.GetType());
   
               s.WriteStartObject(w, o);
               foreach（属性中的NamespaceAttribute ns）                      
                   w.WriteAttributeString("xmlns", ns.Prefix, null, ns.Uri);
   
               // 内容
               s.WriteObjectContent(w, o);
               s.WriteEndObject(w);
           }
       }
   }