我已经研究这个问题很长时间了，以下是我的发现和要求:
我们有两个端点:
- 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中调用，从而调整格式以适应我们的格式？
我们觉得我们走在正确的道路上，但有些地方缺失了。
最佳答案
您几乎走在正确的轨道上 - 拥有仅适用于 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();
}
}
关于c# - 仅针对 webHttpBinding 更改 XML 和 JSON 中的响应输出格式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36918281/