2

通过 HttpResponseMessage MVC4 成功发送了一个 AngularJs 控制器 $scope 的 GetAllFolders()。

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

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

从 MVC4 端调试显示一切正常，并返回了正确的详细信息。

但是通过 Angular/Json，某些属性是 $ref 标签，看不到，例如：

在此处输入图像描述

当我知道图像名称已经在第一个响应中发送时，我不太关心在 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; 
    }

在此处输入图像描述

4

3 回答 3

8

来自 OP 的解析（housecleaning - 标记所以可以标记已回答）此代码已添加到 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; 
}
于 2013-01-17T20:50:37.447 回答
1

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

这是一个三部分的答案。第一部分是禁用集合引用并仅保留对象。

就我而言，我想不出我会共享集合引用并且附加代码很混乱的情况。如果您需要收集参考，请编写消费 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();

第二部分在这里。我从另一个答案中得到了这个，并添加了一个缺少的调整。（这是来自 JSON 对象的原始 Resolve 循环引用）：

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 库并将它们分开以找出处理对象图的顺序，这样我就可以在反序列化后消除空引用。

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

于 2016-10-14T22:49:16.957 回答
0

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

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

感谢 digger69 的这个。

于 2015-10-02T08:42:02.607 回答