c# - 仅针对 webHttpBinding 更改 XML 和 JSON 中的响应输出格式

Question

我已经研究这个问题很长时间了，以下是我的发现和要求:

我们有两个端点:

• TCP 端点
• WebHttp 端点

通过 WebHttp 端点，我们需要支持 JSON 和 XML，但具有自定义响应格式。这是所需的格式(为清楚起见，仅显示 JSON):

{
    "status": "success",
    "data" : {}
}

我们需要的是让每个返回的对象正常序列化，并放在层次结构中的数据下。假设我们有这个 OperationContract:

ObjectToBeReturned test();

和 ObjectToBeReturned 是:

[DataContract]
class ObjectToBeReturned {
    [DataMember]
    public string A {get; set;}
    [DataMember]
    public string B {get; set;}
}

现在，我们希望通过 TCP 直接交换 ObjectToBeReturned 对象，但通过 WebHttp 将以下格式作为响应:

{
    "status": "success",
    "data": {
        "A": "atest",
        "B": "btest"
    }
}

可能性1

我们考虑了两种可能性。第一个是让一个名为 Response 的对象成为我们所有 OperationContract 的返回对象，它将包含以下内容:

[DataContract]
class Response<T> {
    [DataMember]
    public string Status {get; set;}
    [DataMember]
    public T Data {get; set;}
}

问题是我们也需要通过 TCP 协议(protocol)交换这个对象，但这不是我们理想的场景。

可能性2

我们尝试添加一个自定义 EndpointBehavior 和一个自定义 IDispatchMessageFormatter，它只会出现在 WebHttp 端点。

在这个类中，我们实现了以下方法:

 public Message SerializeReply(
            MessageVersion messageVersion,
            object[] parameters,
            object result)
        {

            var clientAcceptType = WebOperationContext.Current.IncomingRequest.Accept;

            Type type = result.GetType();

            var genericResponseType = typeof(Response<>);
            var specificResponseType = genericResponseType.MakeGenericType(result.GetType());
            var response = Activator.CreateInstance(specificResponseType, result);

            Message message;
            WebBodyFormatMessageProperty webBodyFormatMessageProperty;


            if (clientAcceptType == "application/json")
            {
                message = Message.CreateMessage(messageVersion, "", response, new DataContractJsonSerializer(specificResponseType));
                webBodyFormatMessageProperty = new WebBodyFormatMessageProperty(WebContentFormat.Json);

            }
            else
            {
                message = Message.CreateMessage(messageVersion, "", response, new DataContractSerializer(specificResponseType));
                webBodyFormatMessageProperty = new WebBodyFormatMessageProperty(WebContentFormat.Xml);

            }

            var responseMessageProperty = new HttpResponseMessageProperty
            {
                StatusCode = System.Net.HttpStatusCode.OK
            };

            message.Properties.Add(HttpResponseMessageProperty.Name, responseMessageProperty);

            message.Properties.Add(WebBodyFormatMessageProperty.Name, webBodyFormatMessageProperty); 
            return message;
        }

这看起来很有希望。该方法的问题在于，在使用 DataContractSerializer 进行序列化时，我们会收到以下错误:

Consider using a DataContractResolver if you are using DataContractSerializer or add any types not known statically to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding them to the list of known types passed to the serializer.

我们真的不想在 Response 类之上列出所有已知类型，因为数量太多而且维护将是一场噩梦(当我们列出已知类型时，我们能够获取数据)。请注意，传递给响应的所有对象都将使用 DataContract 属性进行修饰。

我必须指出，我们不关心更改消息格式是否会导致无法通过另一个 C# 项目中的 ServiceReference 访问 WebHttp 端点，他们应该为此使用 TCP。

问题

基本上，我们只想自定义WebHttp的返回格式，所以问题是:

• 有没有比我们正在做的更容易实现这一目标的方法？
• 有没有办法根据 SerializeReply 方法中的 result 参数类型告诉序列化程序已知类型？
• 我们是否应该实现一个自定义的 Serializer，它将在 MessageDispatcherFormatter 中调用，从而调整格式以适应我们的格式？

我们觉得我们走在正确的道路上，但有些地方缺失了。

Answer 1

您几乎走在正确的轨道上 - 拥有仅适用于 JSON 端点的端点行为无疑是正确的选择。但是，您可以使用消息检查器，它比格式化程序简单一些。在检查器上，您可以获取现有响应(如果它是 JSON 响应)并使用您的包装对象包装内容。

请注意，WCF 内部结构都是基于 XML 的，因此您需要使用 Mapping Between JSON and XML ，但这并不太复杂。

下面的代码显示了这个场景的实现。

public class StackOverflow_36918281
{
    [DataContract] public class ObjectToBeReturned
    {
        [DataMember]
        public string A { get; set; }
        [DataMember]
        public string B { get; set; }
    }
    [ServiceContract]
    public interface ITest
    {
        [OperationContract, WebGet(ResponseFormat = WebMessageFormat.Json)]
        ObjectToBeReturned Test();
    }
    public class Service : ITest
    {
        public ObjectToBeReturned Test()
        {
            return new ObjectToBeReturned { A = "atest", B = "btest" };
        }
    }
    public class MyJsonWrapperInspector : IEndpointBehavior, IDispatchMessageInspector
    {
        public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
        {
        }

        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            return null;
        }

        public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
        {
        }

        public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
        {
            endpointDispatcher.DispatchRuntime.MessageInspectors.Add(this);
        }

        public void BeforeSendReply(ref Message reply, object correlationState)
        {
            object propValue;
            if (reply.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out propValue) &&
                ((WebBodyFormatMessageProperty)propValue).Format == WebContentFormat.Json)
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(reply.GetReaderAtBodyContents());
                var newRoot = doc.CreateElement("root");
                SetTypeAttribute(doc, newRoot, "object");

                var status = doc.CreateElement("status");
                SetTypeAttribute(doc, status, "string");
                status.AppendChild(doc.CreateTextNode("success"));
                newRoot.AppendChild(status);

                var newData = doc.CreateElement("data");
                SetTypeAttribute(doc, newData, "object");
                newRoot.AppendChild(newData);

                var data = doc.DocumentElement;
                var toCopy = new List<XmlNode>();
                foreach (XmlNode child in data.ChildNodes)
                {
                    toCopy.Add(child);
                }

                foreach (var child in toCopy)
                {
                    newData.AppendChild(child);
                }

                Console.WriteLine(newRoot.OuterXml);

                var newReply = Message.CreateMessage(reply.Version, reply.Headers.Action, new XmlNodeReader(newRoot));
                foreach (var propName in reply.Properties.Keys)
                {
                    newReply.Properties.Add(propName, reply.Properties[propName]);
                }

                reply = newReply;
            }
        }

        private void SetTypeAttribute(XmlDocument doc, XmlElement element, string value)
        {
            var attr = element.Attributes["type"];
            if (attr == null)
            {
                attr = doc.CreateAttribute("type");
                attr.Value = value;
                element.Attributes.Append(attr);
            }
            else
            {
                attr.Value = value;
            }
        }

        public void Validate(ServiceEndpoint endpoint)
        {
        }
    }
    public static void Test()
    {
        string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
        string baseAddressTcp = "net.tcp://" + Environment.MachineName + ":8888/Service";
        ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress), new Uri(baseAddressTcp));
        var ep1 = host.AddServiceEndpoint(typeof(ITest), new NetTcpBinding(), "");
        var ep2 = host.AddServiceEndpoint(typeof(ITest), new WebHttpBinding(), "");
        ep2.EndpointBehaviors.Add(new WebHttpBehavior());
        ep2.EndpointBehaviors.Add(new MyJsonWrapperInspector());
        host.Open();
        Console.WriteLine("Host opened");

        Console.WriteLine("TCP:");
        ChannelFactory<ITest> factory = new ChannelFactory<ITest>(new NetTcpBinding(), new EndpointAddress(baseAddressTcp));
        ITest proxy = factory.CreateChannel();
        Console.WriteLine(proxy.Test());
        ((IClientChannel)proxy).Close();
        factory.Close();


        Console.WriteLine();
        Console.WriteLine("Web:");
        WebClient c = new WebClient();
        Console.WriteLine(c.DownloadString(baseAddress + "/Test"));

        Console.Write("Press ENTER to close the host");
        Console.ReadLine();
        host.Close();
    }
}