C# 重写.NETMVC'；s使用ServiceStack自动反序列化JSON

我试图在.NETMVC4应用程序中实现ServiceStack的使用，以加快JSON序列化/反序列化

对于反序列化AJAX请求，我有以下方法：

Global.asax.cs:

//  Remove and JsonValueProviderFactory and add JsonServiceStackValueProviderFactory
ValueProviderFactories.Factories.Remove(ValueProviderFactories.Factories.OfType<JsonValueProviderFactory>().FirstOrDefault());
ValueProviderFactories.Factories.Add(new JsonServiceStackValueProviderFactory());

public sealed class JsonServiceStackValueProviderFactory : ValueProviderFactory
{
    public override IValueProvider GetValueProvider(ControllerContext controllerContext)
    {
        if (controllerContext == null)
            throw new ArgumentNullException("controllerContext");

        if (!controllerContext.HttpContext.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))
            return null;

        var reader = new StreamReader(controllerContext.HttpContext.Request.InputStream).BaseStream;

        return new DictionaryValueProvider<object>(
                ServiceStack.Text.JsonSerializer.DeserializeFromStream<Dictionary<string, object>>(reader).AsExpandoObject(),
                CultureInfo.CurrentCulture);
    }
}

//  http://nine69.wordpress.com/2013/02/02/asp-net-mvc-series-high-performance-json-parser-for-asp-net-mvc/
public static class CollectionExtensions
{
    public static ExpandoObject AsExpandoObject(this IDictionary<string, object> dictionary)
    {
        var epo = new ExpandoObject();
        var epoDic = epo as IDictionary<string, object>;

        foreach (var item in dictionary)
        {
            bool processed = false;

            if (item.Value is IDictionary<string, object>)
            {
                epoDic.Add(item.Key, AsExpandoObject((IDictionary<string, object>) item.Value));
                processed = true;
            }
            else if (item.Value is ICollection)
            {
                var itemList = new List<object>();
                foreach (object item2 in (ICollection) item.Value)
                    if (item2 is IDictionary<string, object>)
                        itemList.Add(AsExpandoObject((IDictionary<string, object>) item2));
                    else
                        itemList.Add(AsExpandoObject(new Dictionary<string, object> {{"Unknown", item2}}));

                if (itemList.Count > 0)
                {
                    epoDic.Add(item.Key, itemList);
                    processed = true;
                }
            }

            if (!processed)
                epoDic.Add(item);
        }

        return epo;
    }
}

Global.asax.cs：
//删除并删除JsonValueProviderFactory并添加JsonServiceStackValueProviderFactory
valueProviderFactorys.Factories.Remove（valueProviderFactorys.Factories.OfType（）.FirstOrDefault（））；
valueProviderFactorys.Factories.Add（新的JsonServiceStackValueProviderFactory（））；
公共密封类JsonServiceStackValueProviderFactory:ValueProviderFactory
{
公共覆盖IValueProvider GetValueProvider（ControllerContext ControllerContext）
{
如果（controllerContext==null）
抛出新ArgumentNullException（“controllerContext”）；
if（！controllerContext.HttpContext.Request.ContentType.StartsWith（“application/json”，StringComparison.ordinallingorecase））
返回null；
var reader=newstreamreader（controllerContext.HttpContext.Request.InputStream）.BaseStream；
返回新的DictionaryValueProvider(
ServiceStack.Text.JsonSerializer.DeserializeFromStream（reader）.AsExpandooObject（），
文化信息（当前文化）；
}
}
//  http://nine69.wordpress.com/2013/02/02/asp-net-mvc-series-high-performance-json-parser-for-asp-net-mvc/
公共静态类集合扩展
{
公共静态ExpandoObject作为ExpandoObject（此IDictionary字典）
{
var epo=新的ExpandoObject（）；
var epoDic=epo作为索引；
foreach（字典中的变量项）
{
bool-processed=false；
if（item.Value是IDictionary）
{
Add（item.Key，asexpandooobject（（IDictionary）item.Value））；
已处理=真；
}
else if（item.Value为ICollection）
{
var itemList=新列表（）；
foreach（ICollection）item.Value中的对象item2）
如果（第2项是索引项）
添加（asexpandooobject（（IDictionary）item2））；
其他的
Add（asexpandooobject（新字典{{“未知”，item2}））；
如果（itemList.Count>0）
{
epoDic.Add（item.Key，itemList）；
已处理=真；
}
}
如果（！已处理）
epoDic.Add（项目）；
}
返回epo；
}
}

我正在尝试反序列化一个对象，该对象如下所示：

[DataContract]
public class PlaylistItemDto
{
    [DataMember(Name = "playlistId")]
    public Guid PlaylistId { get; set; }

    [DataMember(Name = "id")]
    public Guid Id { get; set; }

    [DataMember(Name = "sequence")]
    public int Sequence { get; set; }

    //  Store Title on PlaylistItem as well as on Video because user might want to rename PlaylistItem.
    [DataMember(Name = "title")]
    public string Title { get; set; }

    [DataMember(Name = "video")]
    public VideoDto Video { get; set; }

    [DataMember(Name = "cid")]
    public string Cid { get; set; }

    public PlaylistItemDto()
    {
        Id = Guid.Empty;
        Title = string.Empty;
    }

    public static PlaylistItemDto Create(PlaylistItem playlistItem)
    {
        PlaylistItemDto playlistItemDto = Mapper.Map<PlaylistItem, PlaylistItemDto>(playlistItem);
        return playlistItemDto;
    }

    public static List<PlaylistItemDto> Create(IEnumerable<PlaylistItem> playlistItems)
    {
        List<PlaylistItemDto> playlistItemDtos = Mapper.Map<IEnumerable<PlaylistItem>, List<PlaylistItemDto>>(playlistItems);
        return playlistItemDtos;
    }
}

[DataContract]
public class VideoDto
{
    [DataMember(Name = "id")]
    public string Id { get; set; }

    [DataMember(Name = "title")]
    public string Title { get; set; }

    [DataMember(Name = "duration")]
    public int Duration { get; set; }

    [DataMember(Name = "author")]
    public string Author { get; set; }

    [DataMember(Name = "highDefinition")]
    public bool HighDefinition { get; set; }

    public VideoDto()
    {
        Id = string.Empty;
        Title = string.Empty;
        Author = string.Empty;
    }

    /// <summary>
    /// Converts a Domain object to a DTO
    /// </summary>
    public static VideoDto Create(Video video)
    {
        VideoDto videoDto = Mapper.Map<Video, VideoDto>(video);
        return videoDto;
    }

    public static List<VideoDto> Create(IEnumerable<Video> videos)
    {
        List<VideoDto> videoDtos = Mapper.Map<IEnumerable<Video>, List<VideoDto>>(videos);
        return videoDtos;
    }
}

[DataContract]
公共类播放项DTO
{
[DataMember（Name=“playlyid”）]
公共Guid播放ID{get；set；}
[数据成员（Name=“id”）]
公共Guid Id{get；set；}
[DataMember（Name=“sequence”）]
公共整数序列{get；set；}
//将标题存储在PlayItem和视频上，因为用户可能希望重命名PlayItem。
[DataMember（Name=“title”）]
公共字符串标题{get；set；}
[DataMember（Name=“video”）]
公共视频到视频{get；set；}
[数据成员（Name=“cid”）]
公共字符串Cid{get；set；}
公共播放列表项dto（）
{
Id=Guid.Empty；
Title=string.Empty；
}
要创建的公共静态播放项（播放项播放项）
{
playlitemdto playlitemdto=Mapper.Map（playlitem）；
返回playlitemdto；
}
公共静态列表创建（IEnumerable播放列表项）
{
List playlitemdtos=Mapper.Map（playlitems）；
返回播放列表项DTO；
}
}
[数据合同]
公开课录像
{
[数据成员（Name=“id”）]
公共字符串Id{get；set；}
[DataMember（Name=“title”）]
公共字符串标题{get；set；}
[DataMember（Name=“duration”）]
公共整数持续时间{get；set；}
[DataMember（Name=“author”）]
公共字符串作者{get；set；}
[DataMember（Name=“highDefinition”）]
公共布尔高清{get；set；}
公共录影带
{
Id=string.Empty；
Title=string.Empty；
Author=string.Empty；
}
/// 
///将域对象转换为DTO
/// 
要创建的公共静态视频（视频）
{
VideoDto VideoDto=Mapper.Map（视频）；
返回videoDto；
}
公共静态列表创建（IEnumerable视频）
{
列出videoDtos=Mapper.Map（视频）；
返回视频数据；
}
}

第一级已正确反序列化，但视频对象为空。我一直在网上搜寻其他文档，但没有找到多少。我发现这些文章似乎是相关的：

但第一个并没有提供示例——只提到了对ServiceStack新版本的一些更改。第二个演示如何反序列化，但不处理流或ExpandoObjects。第一个提示是ExpandoObjects可能不完全受支持

我觉得我正在尝试反序列化一个非常简单的对象。ServiceStack中是否支持对象的嵌套级别？谢谢

如果有帮助，您可以在GitHub上查看完整的源代码：

---

您的源JSON来自哪里？你能举个例子吗？ServiceStack肯定支持嵌套类型，等等——我们在一个内部项目中广泛使用它，效果很好。@Nicholas我添加了一个屏幕截图，显示了为创建请求发送的整个数据列表。当我试图保存PlayItem对象时，它有一个空视频，但其他所有内容都在那里。JSON在哪里生成？我猜你的Chrome分机？我将使用ServiceStack来实际序列化JSON，并查看它与您发送给反序列化的JSON有何不同。好主意。我会在几分钟后回到办公室，看看是否有差异