Question

通过HttpResponseMessage MVC4成功发送一个AngularJs控制器$范围的GetAllFolders（）。

该集合中的文件夹除其他外与Photo类有关联。

文件夹可以是其他文件夹的文件夹（自我引用）。

来自MVC4的调试节目一切都很好，并且返回了正确的详细信息。

但是通过Angular / Json，某些属性是$ ref tag并且无法看到，例如：

enter image description here

我不太关心在FkPhotoId上创建一个方法调用，并且当我知道它已经在第一个响应中发送时，它会在服务器上找到图像名称。

有什么想法吗？

更新：解决方案

此代码已添加到global.asax :(确保在start方法中引用它）

    public static void ConfigureApi(HttpConfiguration config)
    {
        var json = config.Formatters.JsonFormatter;
        config.Formatters.Remove(config.Formatters.XmlFormatter);
        config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore; 
    }

enter image description here

Answer 1

来自OP的决议（清理房屋 - 标记可以标记回答）此代码已添加到global.asax中:(确保在start方法中引用它）

public static void ConfigureApi(HttpConfiguration config)
{
    var json = config.Formatters.JsonFormatter;
    config.Formatters.Remove(config.Formatters.XmlFormatter);
    config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore; 
}

Answer 2

我厌倦了看到这个答案“只是禁用它并解决它。”这是懒惰的，这是错误的，并且保留这些数据的有用性令人难以置信地减少了。

这是三部分答案。第一部分是禁用集合引用，只保留对象。

在我的情况下，我想不出一个场景，我将分享收集引用，而其他代码是混乱的。如果您需要收集参考编写消费FE逻辑。不要只是禁用它。碰巧我不需要它。

config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize;
config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

第二部分在这里。我从另一个答案得到了这个，并添加了一个失踪的调整。（这是原始Resolve circular references from JSON object）：

function resolveReferences(json) {
    if (!json)
        return json;

    if (typeof json === 'string')
        json = JSON.parse(json);

    var byid = {}, // all objects by id
        refs = []; // references to objects that could not be resolved
    json = (function recurse(obj, prop, parent) {
        if (typeof obj !== 'object' || !obj) // a primitive value
            return obj;
        if (Object.prototype.toString.call(obj) === '[object Array]') {
            for (var i = 0; i < obj.length; i++)
                // check also if the array element is not a primitive value
                if (typeof obj[i] !== 'object' || !obj[i]) // a primitive value
                    continue;
                else if ("$ref" in obj[i])
                    obj[i] = recurse(obj[i], i, obj);
                else
                    obj[i] = recurse(obj[i], prop, obj);
            return obj;
        }
        if ("$ref" in obj) { // a reference
            var ref = obj.$ref;
            if (ref in byid)
                return byid[ref];
            // else we have to make it lazy:
            refs.push([parent, prop, ref]);
            return;
        } else if ("$id" in obj) {
            var id = obj.$id;
            delete obj.$id;
            if ("$values" in obj) // an array
                obj = obj.$values.map(recurse);
            else // a plain object
                for (var prop in obj)
                    obj[prop] = recurse(obj[prop], prop, obj);
            byid[id] = obj;
        }
        return obj;
    })(json); // run it!

    for (var i = 0; i < refs.length; i++) { // resolve previously unknown references
        var ref = refs[i];
        ref[0][ref[1]] = byid[ref[2]];
        // Notice that this throws if you put in a reference at top-level
    }
    return json;
}

第二部分是在重新发送数据之前重新处理和重新建立循环依赖关系。我的FE是一个有角度的应用程序，所以我个人在ajax帖子之前在一个注入的HTTP拦截器中调用它。（注意我正在检查名为“typeName”的属性，因为具有该属性的所有对象都被假定为将是的对象在后端反序列化。）

function processReferenceEstablishment(data) {
    if (!data || typeof (data) === 'function')
        return undefined;

    var processData = [];
    var tiers = {};
    var refKey = 1;
    if (Array.isArray(data)) {
        data = jQuery.extend([], data);
    } else {
        data = jQuery.extend({}, data);
    }


   

    var retVal = (function recurse(obj, tier) {
        tiers[tier] = tiers[tier] || {};
        tiers[tier].width = tiers[tier].width ? tiers[tier].width + 1 : 1;
        if (obj) {
            if (typeof obj !== 'object' || typeof (obj) === 'function') {
                return obj;
            }

            for (var key in data) {
                var val = data[key];
                if (key.indexOf("$") > -1 || typeof(val) === 'function') {
                    delete data[key];
                }
            }
            if (Array.isArray(obj)) {
                obj = jQuery.extend([], obj);
                for (var ix = 0; ix < obj.length; ix++) {
                    obj[ix] = recurse(obj[ix], tier);
                }
            }
            else if ('typeName' in obj) {
                if (obj.skipSend) {
                    return undefined;
                }
                obj = jQuery.extend({}, obj);
                var found = false;
                for (var pdIx = 0; pdIx < processData.length; pdIx++) {
                    var item = processData[pdIx];
                    if (item.id === obj.id && item.typeName === obj.typeName) {
                        found = true;
                        if (!item.jsonTier || item.jsonTier > tier) {
                            item.jsonTier = tier;
                            item.jsonWidth = tiers[tier].width;
                        }
                        if (tier === item.jsonTier && item.jsonWidth > tiers[tier].width) {
                            item.jsonWidth = tiers[tier].width;
                        }
                        if (tier > item.jsonTier || (tier === item.jsonTier && item.jsonWidth < tiers[tier].width)) {
                            return { $ref: item.$id.toString() };
                        }
                        break;
                    }
                }
                if (!found) {
                    obj.$id = refKey;
                    refKey++;
                    processData.push({$id:obj.$id, id: obj.id, typeName: obj.typeName, jsonTier: tier, jsonWidth: tiers[tier].width });
                }
                var keys = Object.keys(obj);
                keys.sort();
                for (var key in keys) {
                    key = keys[key];
                    obj[key] = recurse(obj[key], tier + 1);
                }
            }
        }
        return obj;
    })(data, 1);

    retVal = (function recurse(obj, tier) {
        tiers[tier] = tiers[tier] || {};
        tiers[tier].destWidth = tiers[tier].destWidth ? tiers[tier].destWidth + 1 : 1;
        if (typeof obj !== 'object' || !obj) {
            return obj;
        }
        if (Array.isArray(obj)) {
            for (var ix = 0; ix < obj.length; ix++) {
                obj[ix] = recurse(obj[ix], tier);
            }
        }
        else if ('typeName' in obj) {
            var found = false;
            for (var pdIx = 0; pdIx < processData.length; pdIx++) {
                var item = processData[pdIx];
                if (item.id === obj.id && item.typeName === obj.typeName) {
                    found = true;
                    if (item.jsonTier < tier || (item.jsonTier === tier && item.jsonWidth < tiers[tier].destWidth)) {
                        return { $ref: item.id.toString() };
                    }
                }
            }
            var keys = Object.keys(obj);
            keys.sort();
            for (var key in keys) {
                key = keys[key];
                obj[key] = recurse(obj[key], tier + 1);
            }
        }
        return obj;
    })(retVal, 1);
    return retVal;
}

现在，要明确。我重新建立$ ref和$ id经常发生乱序，我得到后端的奇数集合对象引用或导航属性对象引用返回null。我还在努力。我真的需要下拉NewtonSoft.JSON库并将它们分开以找出处理对象图的顺序，这样我可以在反序列化后消除空引用。

对我来说，这是一个真正的解决方案，而不是因为懒惰而放弃并禁用循环引用。

Answer 3

加上我的两分钱。我的代码中有这个额外的行也导致了这个问题

config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;

感谢digger69这个。

AngularJS，MVC4，Web API，Json反序列化$ ref

3 个答案: