使用 EntityObjects 进行 Ajax 绑定的 Telerik MVC Grid 出现循环引用异常

Question

我已经使用 Telerik MVC Grid 有一段时间了。这是一个很好的控件，但是，与使用网格和 Ajax 绑定到从实体框架创建和返回的对象相关的一件烦人的事情不断出现。实体对象具有循环引用，当您从 Ajax 回调返回 IEnumerable 时，如果存在循环引用，它会从 JavascriptSerializer 生成异常。发生这种情况是因为 MVC 网格使用 JsonResult，而后者又使用不支持序列化循环引用的 JavaScriptSerializer。

我对此问题的解决方案是使用 LINQ 创建没有相关实体的视图对象。这适用于所有情况，但需要创建新对象并将数据复制到实体对象或从实体对象复制到这些视图对象。工作量虽然不大，但就是工作。

我终于弄清楚了如何一般地使网格不序列化循环引用（忽略它们），并且我想向公众分享我的解决方案，因为我认为它是通用的，并且可以很好地插入环境中。

该解决方案由几个部分组成

1. 将默认网格序列化器替换为自定义序列化器
2. 安装 Newtonsoft 提供的 Json.Net 插件（这是一个很棒的库）
3. 使用 Json.Net 实现网格序列化器
4. 修改Model.tt 文件在导航属性前面插入 [JsonIgnore] 属性
5. 覆盖 Json.Net 的 DefaultContractResolver 并查找 _entityWrapper属性名称以确保这也被忽略（由 POCO 类或实体框架注入包装器）

所有这些步骤本身都很简单，但如果没有所有这些步骤，您就无法利用此技术。

一旦正确实现，我现在可以轻松地将任何实体框架对象直接发送到客户端，而无需创建新的视图对象。我不推荐对每个对象都这样做，但有时它是最好的选择。同样重要的是要注意，任何相关实体在客户端都不可用，因此不要使用它们。

以下是所需的步骤

1. 在您的应用程序中的某个位置创建以下类。此类是网格用于获取 JSON 结果的工厂对象。这将很快添加到 global.asax 文件中的 telerik 库中。

    公共类 CustomGridActionResultFactory ：IGridActionResultFactory
    {
        公共System.Web.Mvc.ActionResult创建（对象模型）
        {
            //返回将使用 Json.Net 库的自定义 JSON 结果
            返回新的 CustomJsonResult
            {
                数据=模型
            };
        }
    }
   

2. 实现自定义ActionResult。这段代码大部分都是样板代码。唯一有趣的部分是在底部调用 JsonConvert.SerilaizeObject 并传入 ContractResolver 的地方。 ContactResolver 按名称查找名为 _entityWrapper 的属性，并将它们设置为忽略。我不太确定是谁注入了这个属性，但它是实体包装对象的一部分，并且具有循环引用。

    公共类 CustomJsonResult : ActionResult
    {
        const string JsonRequest_GetNotAllowed = "此请求已被阻止，因为在 GET 请求中使用此请求时，敏感信息可能会泄露给第三方网站。要允许 GET 请求，请将 JsonRequestBehavior 设置为 AllowGet。";
   
        公共字符串内容类型{获取;放; }
        公共 System.Text.Encoding ContentEncoding { 获取；放; }
        公共对象数据{获取;放; }
        公共 JsonRequestBehavior JsonRequestBehavior { 获取；放; }
        公共 int MaxJsonLength { 获取；放; }
   
        公共 CustomJsonResult()
        {
            JsonRequestBehavior = JsonRequestBehavior.DenyGet;
            MaxJsonLength = int.MaxValue; // 默认情况下限制设置为 int.maxValue
        }
   
        公共覆盖 void ExecuteResult（ControllerContext 上下文）
        {
            如果（上下文==空）
            {
                抛出新的ArgumentNullException（“上下文”）；
            }
   
            if ((JsonRequestBehavior == JsonRequestBehavior.DenyGet) && string.Equals(context.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
            {
                抛出新的 InvalidOperationException(JsonRequest_GetNotAllowed);
            }
   
            var 响应 = context.HttpContext.Response;
            if (!string.IsNullOrEmpty(ContentType))
            {
                响应.ContentType = ContentType;
            }
            别的
            {
                响应.ContentType =“应用程序/json”;
            }
            if (内容编码！= null)
            {
                响应.ContentEncoding = ContentEncoding;
            }
            如果（数据！=空）
            {
                响应.Write（JsonConvert.SerializeObject（数据，Formatting.None，
                                                           新的 JsonSerializerSettings
                                                               {
                                                                   NullValueHandling = NullValueHandling.忽略，
                                                                   ContractResolver = new PropertyNameIgnoreContractResolver()
                                                               }));
            }
        }
    }
   

3. 将工厂对象添加到 Telerik 网格中。我在 global.asax Application_Start() 方法中执行此操作，但实际上它可以在任何有意义的地方完成。

    DI.Current.Register(() => new CustomGridActionResultFactory());
   

4. 创建用于检查 _entityWrapper 并忽略该属性的 DefaultContractResolver 类。解析器被传递到第 2 步中的 SerializeObject() 调用中。

    公共类 PropertyNameIgnoreContractResolver : DefaultContractResolver
    {
        protected override JsonProperty CreateProperty(System.Reflection.MemberInfo 成员，MemberSerialization 成员Serialization)
        {
            var property = base.CreateProperty(member, memberSerialization);
   
            if (member.Name == "_entityWrapper")
                属性.忽略= true;
   
            返还财产；
        }
    }
   

5. 修改 Model1.tt 文件以注入忽略 POCO 对象的相关实体属性的属性。必须注入的属性是[JsonIgnore]。这是添加到本文中最难的部分，但在 Model1.tt（或项目中的任何文件名）中添加并不难。此外，如果您首先使用代码，则可以手动将 [JsonIgnore] 属性放置在创建循环引用的任何属性前面。

   在 .tt 文件中搜索 region.Begin("Navigation Properties")。这是生成所有导航属性代码的地方。有两种情况需要注意“xxx 的多数”和“单数”引用。有一个 if 语句检查属性是否为

    关系多重性.Many
   

   在该代码块之后，您需要在该行之前插入 [JSonIgnore] 属性

    <#=PropertyVirtualModifier(Accessibility.ForReadOnlyProperty(navProperty))#> ICollection<<#=code.Escape(navProperty.ToEndMember.GetEntityType())#>> <#=code.Escape(navProperty)#>
   

   它将属性名称注入到生成的代码文件中。

   现在查找处理 Relationship.One 和 Relationship.ZeroOrOne 关系的这一行。

    <#=PropertyVirtualModifier(Accessibility.ForProperty(navProperty))#>; <#=code.Escape(navProperty.ToEndMember.GetEntityType())#> <#=code.Escape(navProperty)#>
   

   在此行之前添加 [JsonIgnore] 属性。

   现在剩下的唯一一件事就是确保 NewtonSoft.Json 库在每个生成的文件的顶部“已使用”。在 Model.tt 文件中搜索对 WriteHeader() 的调用。此方法采用一个字符串数组参数，该参数添加额外的使用 (extraUsings)。不要传递 null，而是构造一个字符串数组并将“Newtonsoft.Json”字符串作为数组的第一个元素发送。调用现在应该如下所示：

    WriteHeader(fileManager, new [] {"Newtonsoft.Json"});
   

这就是所有要做的事情，并且对于每个对象来说，一切都开始工作。

现在对于免责声明，

• 我从未使用过 Json.Net，所以我对它的实现可能不是 最佳的。
• 我已经测试了大约两天，还没有发现该技术失败的情况。
• 我还没有发现 JavascriptSerializer 和 JSon.Net 序列化器之间存在任何不兼容性，但这并不意味着 唯一需要
• 注意的是，我正在测试名称为“_entityWrapper”的属性，以将其忽略的属性设置为 true。这显然不是最佳的。

我欢迎任何有关如何改进此解决方案的反馈。我希望它对其他人有帮助。

Answer 1

第一个解决方案适用于网格编辑模式，但是我们对已经具有循环引用的对象行的网格的负载有同样的问题，为了解决这个问题，我们需要创建一个新的 IClientSideObjectWriterFactory 和一个新的 IClientSideObjectWriter。
这就是我所做的：

1- 创建一个新的 IClientSideObjectWriterFactory：

public class JsonClientSideObjectWriterFactory : IClientSideObjectWriterFactory
{
    public IClientSideObjectWriter Create(string id, string type, TextWriter textWriter)
    {
        return new JsonClientSideObjectWriter(id, type, textWriter);
    }
}

2- 创建一个新的 IClientSideObjectWriter，这次我不实现该接口，我继承了 ClientSideObjectWriter 并重写了 AppendObject 和 AppendCollection 方法：

public class JsonClientSideObjectWriter : ClientSideObjectWriter
{
    public JsonClientSideObjectWriter(string id, string type, TextWriter textWriter)
        : base(id, type, textWriter)
    {
    }

    public override IClientSideObjectWriter AppendObject(string name, object value)
    {
        Guard.IsNotNullOrEmpty(name, "name");

        var data = JsonConvert.SerializeObject(value,
            Formatting.None,
            new JsonSerializerSettings
                {
                    NullValueHandling = NullValueHandling.Ignore,
                    ContractResolver = new PropertyNameIgnoreContractResolver()
                });

        return Append("{0}:{1}".FormatWith(name, data));
    }

    public override IClientSideObjectWriter AppendCollection(string name, System.Collections.IEnumerable value)
    {
    public override IClientSideObjectWriter AppendCollection(string name, System.Collections.IEnumerable value)
    {
        Guard.IsNotNullOrEmpty(name, "name");

        var data = JsonConvert.SerializeObject(value,
            Formatting.Indented,
            new JsonSerializerSettings
                {
                    NullValueHandling = NullValueHandling.Ignore,
                    ContractResolver = new PropertyNameIgnoreContractResolver()
                });

        data = data.Replace("<", @"\u003c").Replace(">", @"\u003e");

        return Append("{0}:{1}".FormatWith((object)name, (object)data));
    }
}

注意：替换它是因为grid 在编辑模式下为客户端模板呈现 html 标签，如果我们不编码，那么浏览器将呈现标签。如果不使用“从字符串对象替换”，我还没有找到解决方法。

3-在 Global.asax.cs 上的 Application_Start 上，我像这样注册了我的新工厂：

DI.Current.Register<IClientSideObjectWriterFactory>(() => new JsonClientSideObjectWriterFactory());

它适用于 Telerik 拥有的所有组件。我唯一没有更改的是 PropertyNameIgnoreContractResolver，它与 EntityFramework 类相同。

Answer 2

我将新调用放入 Application_Start 中以实现 CustomGridActionResultFactory 但从未调用过创建方法...

Answer 3

我采取了一种稍微不同的方法，我相信这种方法可能更容易实施。

我所做的就是将扩展的 [Grid] 属性应用于网格 json 返回方法，而不是普通的 [GridAction] 属性

public class GridAttribute : GridActionAttribute, IActionFilter
  {    
    /// <summary>
    /// Determines the depth that the serializer will traverse
    /// </summary>
    public int SerializationDepth { get; set; } 

    /// <summary>
    /// Initializes a new instance of the <see cref="GridActionAttribute"/> class.
    /// </summary>
    public GridAttribute()
      : base()
    {
      ActionParameterName = "command";
      SerializationDepth = 1;
    }

    protected override ActionResult CreateActionResult(object model)
    {    
      return new EFJsonResult
      {
       Data = model,
       JsonRequestBehavior = JsonRequestBehavior.AllowGet,
       MaxSerializationDepth = SerializationDepth
      };
    }
}

，并将

public class EFJsonResult : JsonResult
  {
    const string JsonRequest_GetNotAllowed = "This request has been blocked because sensitive information could be disclosed to third party web sites when this is used in a GET request. To allow GET requests, set JsonRequestBehavior to AllowGet.";

    public EFJsonResult()
    {
      MaxJsonLength = 1024000000;
      RecursionLimit = 10;
      MaxSerializationDepth = 1;
    }

    public int MaxJsonLength { get; set; }
    public int RecursionLimit { get; set; }
    public int MaxSerializationDepth { get; set; }

    public override void ExecuteResult(ControllerContext context)
    {
      if (context == null)
      {
        throw new ArgumentNullException("context");
      }

      if (JsonRequestBehavior == JsonRequestBehavior.DenyGet &&
          String.Equals(context.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
      {
        throw new InvalidOperationException(JsonRequest_GetNotAllowed);
      }

      var response = context.HttpContext.Response;

      if (!String.IsNullOrEmpty(ContentType))
      {
        response.ContentType = ContentType;
      }
      else
      {
        response.ContentType = "application/json";
      }

      if (ContentEncoding != null)
      {
        response.ContentEncoding = ContentEncoding;
      }

      if (Data != null)
      {
        var serializer = new JavaScriptSerializer
        {
          MaxJsonLength = MaxJsonLength,
          RecursionLimit = RecursionLimit
        };

        serializer.RegisterConverters(new List<JavaScriptConverter> { new EFJsonConverter(MaxSerializationDepth) });

        response.Write(serializer.Serialize(Data));
      }
    }

其与我的序列化器 序列化实体框架问题，你有一个简单的避免循环引用的方法，但也可以选择序列化多个级别（我需要）

注意：Telerik 最近为我添加了这个虚拟 CreateActionResult，因此您可能必须下载最新版本（不确定，但我认为也许1.3+）

Answer 4

另一个好的模式是不避免从模型创建ViewModel。
包含 ViewModel 是一个很好的模式。它使您有机会在最后一刻对模型进行 UI 相关调整。例如，您可以调整布尔值以使其具有关联的字符串 Y 或 N 来帮助使 UI 看起来更漂亮，反之亦然。
有时，ViewModel 与 Model 完全相同，复制属性的代码似乎没有必要，但该模式是一个很好的模式，坚持使用它是最佳实践。