ScriptIgnore标签被忽略，即使ApplyToOverrides = true..它在LinqPad上也能工作

好吧，一天后我进一步挖掘了这个问题，并找到了原因:与[ScriptIgnore(ApplyToOverrides = true)]的事情没有关系。它与实体框架为每个实体创建的EntityProxy子类有关。我的ResupplyForm实际上并没有在我的测试中用作ResupplyForm…相反，它是一个EntityProxy子类。

这个EntityProxy子类增加了一个新成员_entityWrapper。如果EntityProxy包装了一个没有导航属性的类，那么_entityWrapper就不包含任何循环…但是一旦添加了导航属性，_entityWrapper就会包含循环，这会破坏序列化。

模糊的错误信息破坏一切。如果JavaScriptSerializer告诉我哪个字段是坏的，我可以节省很多时间。

无论如何，我应该考虑切换到NewtonSoft，但这产生了自己的问题(另一个帖子)，但我创建了一个非常粗糙的解决方案:

public static class JsonSerializerExtensions
    {
        /// <summary>
        /// Convert entity to JSON without blowing up on cyclic reference.
        /// </summary>
        /// <param name="target">The object to serialize</param>
        /// <param name="entityTypes">Any entity-framework-related types that might be involved in this serialization.  If null, it will only use the type of "target".</param>
        /// <param name="ignoreNulls">Whether nulls should be serialized or not.</param>
        /// <returns>Json</returns>
        /// <remarks>This requires some explanation: all POCOs used by entites aren't their true form.  
        /// They're subclassed proxies of the object you *think* you're defining.  These add a new member
        /// _EntityWrapper, which contains cyclic references that break the javascript serializer.
        /// This is Json Serializer function that skips _EntityWrapper for any type in the entityTypes list.
        /// If you've a complicated result object that *contains* entities, forward-declare them with entityTypes.
        /// If you're just serializing one object, you can omit entityTypes.
        ///</remarks>
        public static string ToJsonString(this object target, IEnumerable<Type> entityTypes = null, bool ignoreNulls = true)
        {
            var javaScriptSerializer = new JavaScriptSerializer();
            if(entityTypes == null)
            {
                entityTypes = new[] { target.GetType() };
            }
            javaScriptSerializer.RegisterConverters(new[] { new EntityProxyConverter(entityTypes, ignoreNulls) });
            return javaScriptSerializer.Serialize(target);
        }
    }
    public class EntityProxyConverter : JavaScriptConverter
    {
        IEnumerable<Type> _EntityTypes = null;
        bool _IgnoreNulls;
        public EntityProxyConverter(IEnumerable<Type> entityTypes, bool ignoreNulls = true) : base()
        {
            _EntityTypes = entityTypes;
            _IgnoreNulls = ignoreNulls;
        }
        public override IEnumerable<Type> SupportedTypes
        {
            get
            {
                return _EntityTypes;
            }
        }
        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }
        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            var result = new Dictionary<string, object>();
            if (obj == null)
            {
                return result;
            }
            var properties = obj.GetType().GetProperties(
                System.Reflection.BindingFlags.Public 
                | System.Reflection.BindingFlags.Instance 
                | System.Reflection.BindingFlags.GetProperty
            );
            foreach (var propertyInfo in properties.Where(p => Attribute.GetCustomAttributes(p, typeof(ScriptIgnoreAttribute), true).Length == 0))
            {
                if (!propertyInfo.Name.StartsWith("_"))
                {
                    var value = propertyInfo.GetValue(obj, null);
                    if (value != null || !_IgnoreNulls)
                    {
                        result.Add(propertyInfo.Name, propertyInfo.GetValue(obj, null));
                    }
                }
            }
            return result;
        }
    }

您必须传入类(让我们记住，这些类是动态生成的代理类)才能使用它，很遗憾，因此对于任何合理的对象图来说，它可能都失败得很惨，但对于简单的单个对象和数组之类的东西，它可以工作。使用JsonResult也会失败，因为这些覆盖不能在那里使用。