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

Question

WCF Json 反序列化。

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

[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 的未记录的动态依赖，我必须从网上下载该组件。

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

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

[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;

我在辅助方法中对格式化程序变量调用 clear 的原因是因为 MediaTypeFormatterCollection 的构造函数创建了默认格式化程序，我们对这些不感兴趣，所以我清除它们并仅添加 1 个我们知道可以使用的格式化程序你的解决方案。

我通常会尝试坚持 DRY 规则，这就是我尝试将“定制”隔离在一个地方的原因，这样当事情发生变化时，我就不需要遍历所有源代码并尝试记住或搜索所有可能使用过它的实例。

换一种说法，虽然框架确实支持您的方案，但如果您愿意，它当然需要更改设置。如果您不使用所谓的多态类型，那么标准的开箱即用方法会很好用。我今天早上写了一个模仿你的解决方案，我找不到一种快速的方法可以帮助你在不改变客户端的情况下摆脱困境。

Answer 2

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