Question

我们目前正在使用Web服务（IBM Message Broker）。由于服务仍在开发中，在许多情况下它会返回无效的XML（是的，这将被修复，我承诺）。

使用ClientBase<T>使用svcutil生成的客户端从.NET调用此服务时会出现问题。似乎使用的XmlSerializer不会对无效的XML元素造成错误。

以下是无法报告错误的示例，只返回部分初始化的元素：

using System;
using System.Diagnostics;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

[Serializable]
public class Program
{
  [XmlElement(Order = 0)]
  public string One { get;set; }

  [XmlElement(Order = 1)]
  public string Two { get;set; }

  static void Main(string[] args)
  {
    var ser = new XmlSerializer(typeof(Program));
    ser.UnknownElement += (o, e) => { 
      Console.WriteLine("Unknown element: {0}", e.Element.Name); 
    };

    using (var input = new StringReader(
@"<?xml version=""1.0"" encoding=""utf-8"" ?>
<Program>
  <Two>Two</Two>
  <One>One</One>
</Program>"))
    {
      var p = (Program)ser.Deserialize(input);
      Debug.Assert(p.One != null);
    }
  }
}

当附加到UnknownElement事件时，它会正确报告无效的XML（元素顺序不匹配），但在使用ClientBase<T>时，这些（以及其他一些情况）会被忽略（就好像不使用XmlSerializer）的错误事件。

我的问题是如何让ClientBase<T>检测无效的XML？有没有办法挂钩XmlSerializer使用的ClientBase<T>的错误事件？

目前，如果没有意义，我们必须使用SoapUI手动检查响应。

由于

Answer 1

因此，开箱即用的WCF并不相信XML验证。它将XML视为一种消息格式，读取看似正确的信息并忽略其余信息。这具有服务将接受的非常宽松的优势。

当元素的排序开始变得重要时，就会出现问题。可以认为结构的排序不应该是重要的，您可以指示数据本身中的信息排序（例如，日期，时间或索引属性）。在您的琐碎案例中，排序实际上并不重要，因为您可以阅读和理解信息，无论其出现的顺序如何。我相信您的实际案例很多更有效，所以我不会进一步努力。

为了验证XML结构，您需要访问WCF管道中的消息。最简单的方法是使用IClientMessageInspector强制执行验证邮件并使用行为将其附加到客户端。

假设您要对XSD进行XML模式验证，您可以创建一个这样的检查器：

class XsdValidationInspector : IClientMessageInspector
{
    private readonly XmlSchemaSet _schemas;

    public XsdValidationInspector(XmlSchemaSet schemas)
    {
        this._schemas = schemas;
    }

    public void AfterReceiveReply(ref Message reply, object correlationState)
    {
        // Buffer the message so we can read multiple times.
        var buffer = reply.CreateBufferedCopy();

        // Validate the message content.
        var message = buffer.CreateMessage();

        using (var bodyReader
            = message.GetReaderAtBodyContents().ReadSubTree())
        {
            var settings = new XmlReaderSettings
            {
                Schemas = this._schemas,
                ValidationType = ValidationType.Schema,
            };

            var events = new List<ValidationEventArgs>();
            settings.ValidationEventHandler += (sender, e) => events.Add(e);

            using (var validatingReader
                = XmlReader.Create(bodyReader, settings))
            {
                // Read to the end of the body.
                while(validatingReader.Read()) {  }
            }

            if (events.Any())
            {
                // TODO: Examine events and decide whether to throw exception.
            }
        }

        // Assign a copy to be passed to the next component.
        reply = buffer.CreateMessage();
    }

    public object BeforeSendRequest(
        ref Message request,
        IClientChannel channel) {}
}

随附的验证行为并不特别复杂：

class XsdValiationBehavior : IEndpointBehavior
{
    private readonly XmlSchemaSet _schemas;

    public XsdValidationBehavior(XmlSchemaSet schemas)
    {
        this._schemas = schemas;
    }

    public void AddBindingParameters(
        ServiceEndpoint endpoint,
        BindingParameterCollection bindingParameters) {}

    public void ApplyClientBehavior(
        ServiceEndpoint endpoint,
        ClientRuntime clientRuntime)
    {
        clientRuntime.MessageInspectors.Add(
            new XsdValidationInspector(this._schemas));
    }

    public void ApplyDispatchBehavior(
        ServiceEndpoint endpoint,
        EndpointDispatcher endpointDispatcher) {}

    public void Validate(ServiceEndpoint endpoint){}
}

您可以创建一些配置元素并通过配置应用行为，也可以通过在打开客户端连接之前修改客户端的通道工厂以编程方式执行此操作。这是程序化方法：

var schemaMarkup =  @"<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
       <xsd:element name='Program'>
        <xsd:complexType>
         <xsd:sequence>
          <xsd:element name='One' minOccurs='1' maxOccurs='1'/>
          <xsd:element name='Two' minOccurs='1' maxOccurs='1'/>
         </xsd:sequence>
        </xsd:complexType>
       </xsd:element>
      </xsd:schema>";

var schema = new XmlSchema();
using (var stringReader = new StringReader(schemaMarkup));
{
    var events = new List<ValidationEventArgs>();
    schema.Read(stringReader, (sender, e) => events.Add(e));

    // TODO: Check events for any errors.
}

var validation = new XsdValidationBehavior(new XmlSchemaSet { schema });

client.ChannelFactory.Behaviours.Add(validation);

Answer 2

我建议使用与Tragedian相同的实现，例如。创建一个客户端消息检查器，该检查器添加到服务端点，该检查器预先对所有消息进行模式验证。

使用本地服务架构进行动态验证

下面是动态加载最初从用于生成服务引用的服务中获取的模式的示例。这样，您始终可以更新服务，而无需更改此代码以使用模式验证xml。

这使用您必须的服务引用加载解决方案上的现有架构（您可以使用文件资源管理器在项目内的ServiceReference文件夹中查看架构信息。

using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.Xml.Schema;

namespace ConsoleApplication1
{
    class Program
    {
        class XsdValidationInspector : IClientMessageInspector ... //omitted for clarity
        class XsdValiationBehavior : IEndpointBehavior ... //omitted for clarity

        static void Main(string[] args)
        {
            ContractDescription cd = ContractDescription.GetContract(typeof(ServiceReference1.IService1));

            WsdlExporter exporter = new WsdlExporter();

            exporter.ExportContract(cd);

            XmlSchemaSet set = exporter.GeneratedXmlSchemas;

            // Client implementation omitted for clarity sake.
            var client = <some client here>; //omitted for clarity

            var validation = new XsdValidationBehavior(new XmlSchemaSet { xmlSchema });

            client.ChannelFactory.Behaviours.Add(validation);
        }
    }
}

动态检查服务终点架构

但是根据您的评论，不必更改硬编码的架构和/或我在下面添加的对象，您可以从服务端点动态自动获取架构。我建议你缓存一下。

您甚至可以使用它来识别服务终点是否已更改，例如。当您第一次获得服务的引用时，将其保存到磁盘并生成消息，然后服务可以每天从服务端点动态获取架构，并检查是否有任何修改或差异，并通知您或记录任何错误。

请参阅下面的示例，了解如何执行此操作。

using System;
using System.IO;
using System.Net;
using System.Web.Services.Description;
using System.Text;
using System.Xml.Schema;

namespace ConsoleApplication1
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            //Build the URL request string
            UriBuilder uriBuilder = new UriBuilder(@"http://myservice.local/xmlbooking.asmx");
            uriBuilder.Query = "WSDL";

            HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uriBuilder.Uri);
            webRequest.ContentType = "text/xml;charset=\"utf-8\"";
            webRequest.Method = "GET";
            webRequest.Accept = "text/xml";

            //Submit a web request to get the web service's WSDL
            ServiceDescription serviceDescription;
            using (WebResponse response = webRequest.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    serviceDescription = ServiceDescription.Read(stream);
                }
            }

            Types types = serviceDescription.Types;
            XmlSchema xmlSchema = types.Schemas[0];

            // Client implementation omitted for clarity sake.
            var client = some client here;

            var validation = new XsdValidationBehavior(new XmlSchemaSet { xmlSchema });

            client.ChannelFactory.Behaviours.Add(validation);

        }
    }
}

这样您就不必每次都重新生成模式，因为它总是会获取最新的模式。

Answer 3

You can configure svcutil to perform serialization with the DataContractSerializer：

/serializer:DataContractSerializer

生成使用Data Contract Serializer进行序列化和反序列化的数据类型。

_{简表：/ ser：DataContractSerializer}

如果遇到错误排序的元素（有时是painfully strict about element ordering）或其他问题，

DataContractSerializer将抛出异常。

Answer 4

现在，我对此并不是100％肯定，但我相信派对正在XmlSerializerOperationFormatter.cs（System.ServiceModel）文件中进行，

即DeserializeBody：

private object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, XmlSerializer serializer, MessagePartDescription returnPart, MessagePartDescriptionCollection bodyParts, object[] parameters, bool isRequest)
{
  try
  {
    if (reader == null)
      throw DiagnosticUtility.ExceptionUtility.ThrowHelperError((Exception) new ArgumentNullException("reader"));
    if (parameters == null)
      throw DiagnosticUtility.ExceptionUtility.ThrowHelperError((Exception) new ArgumentNullException("parameters"));
    object obj = (object) null;
    if (serializer == null || reader.NodeType == XmlNodeType.EndElement)
      return (object) null;
    object[] objArray = (object[]) serializer.Deserialize((XmlReader) reader, this.isEncoded ? XmlSerializerOperationFormatter.GetEncoding(version.Envelope) : (string) null);
    int num = 0;
    if (OperationFormatter.IsValidReturnValue(returnPart))
      obj = objArray[num++];
    for (int index = 0; index < bodyParts.Count; ++index)
      parameters[((Collection<MessagePartDescription>) bodyParts)[index].Index] = objArray[num++];
    return obj;
  }
  catch (InvalidOperationException ex)
  {
    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError((Exception) new CommunicationException(System.ServiceModel.SR.GetString(isRequest ? "SFxErrorDeserializingRequestBody" : "SFxErrorDeserializingReplyBody", new object[1]
    {
      (object) this.OperationName
    }), (Exception) ex));
  }

正如你所看到的，没有人会把自己挂进XmlSerializer.UnknownElement。但是，我们再说不过，因为XmlSerializer是通过参数传递的。长话短说;它来自replyMessageInfo.BodySerialize r或属于requestMessageInfo.BodySerializer的{{1}}属性，它们来自XmlSerializerOperationFormatter构造函数。

进一步的步骤，以及..进一步，因为源代码是疯狂的20983832972389步骤。基本上，它导致我没有看到任何应用于XmlSerializer的事实，这有点表明你刚才所说的。

可能的解决方案：

1）使用XmlSerializerOperationFormatter.cs作为基础并编写自己的＆＃34;自定义序列化程序＆＃34;。这是如何编写自定义序列化程序的完美示例：http://code.google.com/p/protobuf-net/source/browse/trunk/protobuf-net/ServiceModel/

您可以重用XmlSerializerOperationBehavior中的某些部分。也许添加某种错误报告。

2）我从未成为通过XmlSerializer进行Xml验证的粉丝。

XmlSerializer用于序列化/反序列化对象。部分构造的对象是一场噩梦。我强烈建议（以及我一直遵循XmlSerializerOperationBehavior用法），实际上是根据模式验证XML，然后反序列化。

除了所有的东西，@ CodeCaster建议很好。

使用Web服务客户端/ ClientBase检测无效的XML响应

4 个答案: