WCF Json反序列化保存多态集合类型

Question

WCF Json反序列化。

我正在WCF中使用Dotnet 4.5构建一个中间件webservice，该服务器返回一个多态类型。

[DataContract] 
[KnownType(typeof(SomethingA))] 
[KnownType(typeof(SomethingB))] 
public class Something 
{ 
    [DataMember] 
    public int Item1 { get; set; } 

    [DataMember] 
    public string Item2 { get; set; } 
} 

[DataContract] 
public class SomethingA : Something 
{ } 

[DataContract] 
public class SomethingB : Something 
{ } 


/// <summary> 
/// Contract for a service for testing various web operations. 
/// </summary> 
[ServiceContract] 
[ServiceKnownType(typeof(SomethingA))] 
[ServiceKnownType(typeof(SomethingB))] 
public interface ITesting 
{ 
    /// <summary> 
    /// Test passing in and returning an object using POST and json. 
    /// </summary> 
    [OperationContract] 
    [WebInvoke(
     RequestFormat = WebMessageFormat.Json, 
     ResponseFormat = WebMessageFormat.Json, 
     BodyStyle = WebMessageBodyStyle.Bare, 
     UriTemplate = "use-polymorphic-somethings", 
     Method = "POST")] 
    List<Something> UsePolymorphicSomethings(); 
} 

/// <summary> 
/// Implementation of the ITesting service contract. 
/// </summary> 
public class Testing : ITesting 
{ 
    public List<Something> UsePolymorphicSomethings() 
    { 
     List<Something> retVal = new List<Something>(); 
     retVal.Add(new SomethingA { Item1 = 1, Item2 = "1" }); 
     retVal.Add(new SomethingB { Item1 = 1, Item2 = "1" }); 
     return retVal; 
    } 
} 

在客户端，我试图反序列化这种方式来保存集合中的不同类型。 MSDN文档对我来说似乎非常薄弱。我遇到的第一个问题是添加一个对System.Web.Http的引用，在第三方开源组件Newtonsoft.Json上创建了一个未公开的动态依赖关系，我必须从Web上下载它。

前两种反序列化方法失败，但我发现了第三种方法。

我想知道的是为什么前两种方法失败？理想情况下，我希望得到第一种工作方式，因为这是最简化的。

[TestMethod] 
public void UsePolymorphicSomethings_Test1() 
{ 
    using (HttpClient http = new HttpClient()) 
    { 
     http.BaseAddress = new Uri("http://localhost:8733/"); 

     HttpResponseMessage response = http.PostAsJsonAsync(
     "Design_Time_Addresses/InSite8WebServiceLib2/Testing/use-polymorphic-somethings", 
     new StringContent(string.Empty)).Result; 

     List<Something> ret = response.Content.ReadAsAsync<List<Something>>().Result; 

     // FAILS. 
     Assert.AreEqual(typeof(SomethingA), somethings[0].GetType()); 
     Assert.AreEqual(typeof(SomethingB), somethings[1].GetType()); 
    } 
} 

[TestMethod] 
public void UsePolymorphicSomethings_Test2() 
{ 
    using (HttpClient http = new HttpClient()) 
    { 
     http.BaseAddress = new Uri("http://localhost:8733/"); 

     HttpResponseMessage response = http.PostAsJsonAsync(
     "Design_Time_Addresses/InSite8WebServiceLib2/Testing/use-polymorphic-somethings", 
     new StringContent(string.Empty)).Result; 

     string ret1 = response.Content.ReadAsStringAsync().Result; 
     Newtonsoft.Json.JsonSerializerSettings s = new Newtonsoft.Json.JsonSerializerSettings(); 
     s.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.All; 
     List<Something> r = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Something>>(ret1, s); 

     // FAILS. 
     Assert.AreEqual(typeof(SomethingA), somethings[0].GetType()); 
     Assert.AreEqual(typeof(SomethingB), somethings[1].GetType()); 
    } 
} 

[TestMethod] 
public void UsePolymorphicSomethings_Test3() 
{ 
    using (HttpClient http = new HttpClient()) 
    { 
     http.BaseAddress = new Uri("http://localhost:8733/"); 

     HttpResponseMessage response = http.PostAsJsonAsync(
     "Design_Time_Addresses/InSite8WebServiceLib2/Testing/use-polymorphic-somethings", 
     new StringContent(string.Empty)).Result; 

     Stream stream = response.Content.ReadAsStreamAsync().Result; 
     DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(List<Something>)); 
     List<Something> somethings = (List<Something>)serializer.ReadObject(stream); 

     // SUCCEEDS. 
     Assert.AreEqual(typeof(SomethingA), somethings[0].GetType()); 
     Assert.AreEqual(typeof(SomethingB), somethings[1].GetType()); 
    } 
} 

Answer 1

根据我的理解，您对您编写的代码的流内容感到“担心”。看到你的代码在你的最后一个方法中工作，并且我希望我的理由能够工作，而其他人不会让你满意。我们仍然可以使用一个简单的帮助程序对您的方法进行流式处理。

public T Deserialize<T>(Stream stream) where T : class 
    { 
     var serializer = new DataContractJsonSerializer(typeof(T)); 
     return (T)serializer.ReadObject(stream); 
    } 

然后你可以简单地调用这个方法，像这样

List<Something> somethings = Deserialize<List<Something>>(stream); 

要在某种意义上使事情也许更容易，你可以写辅助方法为扩展方法， 像这样

public static class Helpers 
{ 
    public static T Deserialize<T>(this Stream stream) where T : class 
    { 
     var serializer = new DataContractJsonSerializer(typeof(T)); 
     return (T)serializer.ReadObject(stream); 
    } 
} 

然后，您可以调用这个方法这样

var result = stream.Deserialize<List<Something>>(); 

要一路走下去，你可以对HttpResponseMessage创建扩展方法

public static class Helpers 
{ 
    public static T Deserialize<T>(this HttpResponseMessage response) where T : class 
    { 
     var stream = response.Content.ReadAsStreamAsync().Result; 
     var serializer = new DataContractJsonSerializer(typeof(T)); 
     return (T)serializer.ReadObject(stream); 
    } 
} 

你可以调用这个方法这样

var result = response.Deserialize<List<Something>>(); 

至少你的代码将现在又是一个班轮，如果你将来改变你的序列化程序，你只需要在一个地方改变你的客户代码。您可能需要检查代码，因为我目前没有打开Visual Studio为您测试它。但对我来说看起来不错。

我在这里添加了一个新的帮助程序示例，因此有更多的选项/修复程序供您选择。

public static class Helpers 
{ 
    public static Task<T> ReadAsAsyncCustom<T>(this HttpContent content) 
    { 
     var formatters = new MediaTypeFormatterCollection(); 
     formatters.Clear(); 
     formatters.Add(new JsonMediaTypeFormatter { UseDataContractJsonSerializer = true }); 
     return content.ReadAsAsync<T>(formatters); 
    } 
} 

和如下

List<Something> ret = response.Content.ReadAsAsyncCustom<List<Something>>().Result; 

我之所以呼吁在辅助方法格式化变量明确这一个可以被使用，是因为MediaTypeFormatterCollection的构造函数创建默认格式化，我们是不是对这些内容感兴趣，所以我清除它们并添加一个我们知道适用于您的解决方案的格式化程序。

我一般尽量坚持到干燥的原则，这是我努力保持“定制”分离只是一个单一的地方，所以，当事情发生变化，我并不需要经过所有的源代码并试着记住的原因或搜索可能已被使用的所有实例。

把东西用另一种方式为好，而框架并支持你的情况下，它当然需要，如果你将一个设置更改。如果你不使用你所谓的多态类型，那么标准的开箱即用方法将会很好。我今天早上写了一个模拟你的解决方案，我看不到一个快速的方法，可以帮助你在客户端没有改变的情况下离开。

Answer 2

在我看来，方法1和2实例化一个T类型的对象，然后通过读取流来设置它的属性。换句话说，这些方法只知道类型“Something”，因此它们只能实例化“Something”。第三种方法也使用属性DataContract和KnownType，因此它能够实例化已知类型“Something”，“SomethingA”和“SomethingB”。