Question

我目前正在编写一个必须与现有wsdl匹配的C＃webservice，我的webservice由第三方Web服务调用（我的webservice充当回调）。

但是我传递的是无效值，第三方网络服务不愿意更改他们的网络服务。

我得到：'2010-10-24 12:12:13'在xml中输入字符串作为DateTime，（不符合规范，因为它必须是'2010-10-24T12：12 ：13' ）有没有办法覆盖XML序列化，以便它仍然匹配wsdl但接受“任何”？

 [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
public DateTime createdAt {
    get {
        return this.createdAt;
    }
    set {
        this.createdAtField = value;
    }
}

Answer 1

你可以创建一个SoapExtension，它在框架反序列化之前修改soap xml。如果您使用wcf和服务引用，则需要以不同方式执行。这是我之前为清理消息而创建的一些代码。

在你的app / web.config中（这是为了清理来自soap服务的传入数据）

<system.web>
 <webServices>
  <soapExtensionTypes>
    <add type="mAdcOW.SoapCleanerModule.SOAPCleanerExtension, mAdcOW.SoapCleaner" />
  </soapExtensionTypes>
 </webServices>
</system.web>

以及在我的情况下删除非法SOAP字符的代码

using System;
using System.IO;
using System.Text.RegularExpressions;
using System.Web.Services.Protocols;

namespace mAdcOW.SoapCleanerModule
{
    [AttributeUsage(AttributeTargets.Method)]
    public class SOAPCleaner : SoapExtensionAttribute
    {
        public override Type ExtensionType
        {
            get { return typeof (SOAPCleanerExtension); }
        }
        public override int Priority { get; set; }
    }

    public class SOAPCleanerExtension : SoapExtension
    {
        private static readonly Regex _reInvalidXmlChars = new Regex(@"&#x[01]?[0123456789ABCDEF];",
                                                                     RegexOptions.Compiled |
                                                                     RegexOptions.CultureInvariant);

        private Stream _originalStream;
        private MemoryStream _processStream;

        public override void Initialize(object initializer)
        {
        }

        public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute)
        {
            return null;
        }

        public override object GetInitializer(Type serviceType)
        {
            return null;
        }

        public override Stream ChainStream(Stream stream)
        {
            _originalStream = stream;
            _processStream = new MemoryStream();
            return _processStream;
        }

        public override void ProcessMessage(SoapMessage message)
        {
            switch (message.Stage)
            {
                case SoapMessageStage.BeforeSerialize:
                    {
                        break;
                    }
                case SoapMessageStage.AfterSerialize:
                    {
                        // This is the message we send for our soap call
                        // Just pass our stream unmodified
                        _processStream.Position = 0;
                        Copy(_processStream, _originalStream);
                        break;
                    }
                case SoapMessageStage.BeforeDeserialize:
                    {
                        // This is the message we get back from the webservice
                        CopyAndClean(_originalStream, _processStream);
                        //Copy(_originalStream, _processStream);
                        _processStream.Position = 0;
                        break;
                    }
                case SoapMessageStage.AfterDeserialize:
                    break;
                default:
                    break;
            }
        }

        private void CopyAndClean(Stream from, Stream to)
        {
            TextReader reader = new StreamReader(from);
            TextWriter writer = new StreamWriter(to);
            string msg = reader.ReadToEnd();
            string cleanMsg = _reInvalidXmlChars.Replace(msg, "");
            writer.WriteLine(cleanMsg);
            writer.Flush();
        }

        private void Copy(Stream from, Stream to)
        {
            TextReader reader = new StreamReader(from);
            TextWriter writer = new StreamWriter(to);
            writer.WriteLine(reader.ReadToEnd());
            writer.Flush();
        }
    }
}

覆盖webservice中传入的无效日期时间值

1 个答案: