Serialization 为什么可以'；如果对象包含的xml稍微变大，我是否反序列化对象？

我在尝试使用REST API向Azure服务总线发送消息并使用.NET Azure服务总线客户端API类接收消息时遇到问题。我可以单独使用SDK使用这些对象愉快地发送和接收消息，但在尝试使用RESTAPI时会遇到问题

我想我已经把问题缩小到了这个最小限度。基本上，如果我用少量XML作为有效负载序列化对象，那么一切都正常。如果我添加稍微多一些XML，那么我会得到一个反序列化它的异常。这应该剪切并粘贴到新的控制台应用程序中，以允许重新处理问题：

using System.IO;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Xml;
using System.Xml.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        GetMessageBytes(Guid.NewGuid());
    }

    private static byte[] GetMessageBytes(Guid requestId)
    {
        var payload = XElement.Parse(@"
<blah Type='TransactionRequest' Version='1' xmlns=''>
    <SomeData Type='Request' Selection='All'></SomeData>
</blah>");

        var invalidPayload = XElement.Parse(@"
<blah Type='TransactionRequest' Version='1' xmlns=''>
    <SomeData Type='Request' Selection='All'></SomeData>
    <SomeData Type='Request' Selection='All'></SomeData>
    <SomeData Type='Request' Selection='All'></SomeData>
    <SomeData Type='Request' Selection='All'></SomeData>
    <SomeData Type='Request' Selection='All'></SomeData>
</blah>");
        Message<XElement> message = new Message<XElement>()
        {
            Label = "Label",
            RequestId = requestId,
            Payload = payload
        };

        var messageBytes = EncodeMessage(message);
        var expectedResponse = DecodeMessage<Message<XElement>>(messageBytes);

        message = new Message<XElement>()
        {
            Label = "Label",
            RequestId = requestId,
            Payload = invalidPayload
        };

        messageBytes = EncodeMessage(message);
        expectedResponse = DecodeMessage<Message<XElement>>(messageBytes);
        Console.WriteLine(expectedResponse);
        return messageBytes;
    }

    private static byte[] EncodeMessage<T>(T message)
    {
        DataContractSerializer serializer = new DataContractSerializer(typeof(T));
        var memoryStream = new MemoryStream();
        XmlDictionaryWriter binaryDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(memoryStream);
        serializer.WriteObject(binaryDictionaryWriter, message);
        binaryDictionaryWriter.Flush();
        var bytesToPost = memoryStream.GetBuffer();
        return bytesToPost;
    }

    private static T DecodeMessage<T>(byte[] response)
    {
        var ms = new MemoryStream(response);
        var serializer = new DataContractSerializer(typeof(T));
        XmlDictionaryReader binaryDictionaryReader = XmlDictionaryReader.CreateBinaryReader(ms, XmlDictionaryReaderQuotas.Max);

        var message = serializer.ReadObject(binaryDictionaryReader);
        return (T)message;
    }
}

[MessageContract(WrapperName = "Message", WrapperNamespace = "http://blah.co.uk/contracts", IsWrapped = true)]
public sealed class Message<T>        where T : class
{
    [MessageHeader(Namespace = "http://blah.co.uk/contracts", Name = "RequestId")]
    public Guid RequestId { get; set; }

    [MessageHeader(Namespace = "http://blah.co.uk/contracts", Name = "Label")]
    public string Label { get; set; }

    [MessageBodyMember(Namespace = "http://blah.co.uk/contracts", Name = "Payload")]
    public T Payload { get; set; }

    [MessageBodyMember(Namespace = "http://blah.co.uk/contracts", Name = "MonitoringResults")]
    public MessageTimestamp MessageTimestamp { get; set; }


}

[DataContract]
public class MessageTimestamp
{
    private ICollection<Timestamp> timestamps = new List<Timestamp>();

    [DataMember]
    public ICollection<Timestamp> GetAllTimestamps
    {
        get
        {
            return timestamps.ToList();
        }

        private set
        {
            timestamps = new List<Timestamp>(value);
        }
    }        
}

public class Timestamp
{
    public Operation Operation { get; set; }
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }

    public TimeSpan TimeTaken
    {
        get
        {
            return EndTime - StartTime;
        }
    }
}

public enum Operation
{
    OverallProcessing
}

使用System.IO；
使用System.Runtime.Serialization；
使用System.ServiceModel；
使用System.Xml；
使用System.Xml.Linq；
使用制度；
使用System.Collections.Generic；
使用System.Linq；
班级计划
{
静态void Main（字符串[]参数）
{
GetMessageBytes（Guid.NewGuid（））；
}
私有静态字节[]GetMessageBytes（Guid请求ID）
{
var payload=XElement.Parse（@）
");
var invalidPayload=XElement.Parse（@）
");
消息消息=新消息（）
{
Label=“Label”，
RequestId=RequestId，
有效载荷=有效载荷
};
var messageBytes=EncodeMessage（消息）；
var expectedResponse=解码消息（messageBytes）；
消息=新消息（）
{
Label=“Label”，
RequestId=RequestId，
有效载荷=无效有效载荷
};
messageBytes=EncodeMessage（消息）；
expectedResponse=解码消息（messageBytes）；
Console.WriteLine（预期响应）；
返回消息字节；
}
专用静态字节[]编码消息（T消息）
{
DataContractSerializer serializer=新的DataContractSerializer（typeof（T））；
var memoryStream=新的memoryStream（）；
XmlDictionaryWriter binaryDictionaryWriter=XmlDictionaryWriter.CreateBaryWriter（memoryStream）；
serializer.WriteObject（binaryDictionaryWriter，消息）；
binaryDictionaryWriter.Flush（）；
var bytesToPost=memoryStream.GetBuffer（）；
通过testopost返回；
}
专用静态解码消息（字节[]响应）
{
var ms=新的内存流（响应）；
var serializer=新的DataContractSerializer（typeof（T））；
XmlDictionaryReader binaryDictionaryReader=XmlDictionaryReader.CreateBinaryReader（ms，XmlDictionaryReaderQuotas.Max）；
var message=serializer.ReadObject（binaryDictionaryReader）；
返回（T）消息；
}
}
[MessageContract（WrapperName=“Message”，WrapperNamespace=”http://blah.co.uk/contracts“，IsWrapped=true）]
公共密封类消息，其中T:class
{
[MessageHeader（命名空间=”http://blah.co.uk/contracts“，Name=“RequestId”）]
公共Guid RequestId{get；set；}
[MessageHeader（命名空间=”http://blah.co.uk/contracts“，Name=“Label”）]
公共字符串标签{get；set；}
[MessageBodyMember（命名空间=”http://blah.co.uk/contracts“，Name=“有效载荷”）]
公共T有效载荷{get；set；}
[MessageBodyMember（命名空间=”http://blah.co.uk/contracts“，Name=“监控结果”）]
public MessageTimestamp MessageTimestamp{get；set；}
}
[数据合同]
公共类消息时间戳
{
私有ICollection时间戳=新列表（）；
[数据成员]
公共ICollection GetAllTimestamps
{
得到
{
返回timestamps.ToList（）；
}
专用设备
{
时间戳=新列表（值）；
}
}        
}
公共类时间戳
{
公共操作操作{get；set；}
公共日期时间开始时间{get；set；}
公共日期时间结束时间{get；set；}
公共时间跨度所用时间
{
得到
{
返回结束时间-开始时间；
}
}
}
公共枚举操作
{
整体加工
}

引发的错误是：

反序列化类型的对象时出错

SerialisationIssue.Message

1[[System.Xml.Linq.XElement，System.Xml.Linq，Version=4.0.0.0，Culture=neutral，PublicKeyToken=b77a5c561934e089]`。 输入源的格式不正确

我已经尝试过序列化大量的XML（即无

Message

wrapper），但效果很好，因此我确信它实际上与XML的大小无关，但这始终会使它崩溃

我已经反映了ServiceBus SDK客户端库中使用的实际类，并尝试使用其中的反序列化程序（DataContractBinarySerializer），但这没有任何区别，似乎基本上与我手动执行的操作相同

---

有没有关于如何找到实际问题的想法？我该如何修复它呢？

因此，这个问题确实与

XmlBinaryReader

中的一些明显缺陷有关，如本文所述

---

这可以通过在序列化数据的末尾写入一些空格来解决，如

中所述，这可能与此有关吗@ojf我想是的，只是现在确认一下。