Asp.net mvc js：如何将微风实体转换为普通JSON对象

我使用来自服务器的元数据创建了一个实体实例：

breeze.NamingConvention.camelCase.setAsDefault();

...

var applicationType = metadataStore.getEntityType('Application');
var application = applicationType.createEntity();

此特定模型中没有对象具有循环依赖关系

在用户对相应的对象进行了一些更改之后，我需要对该实体执行一些自定义验证，因此我需要将该对象转换回其JSON简单形式，并将其发送回验证控制器（ASP.NET MVC4）

问题是如何将实体转换为JSON，以便：

结果对象反映了服务器端使用的命名约定

对象包含简单的属性，而不是剔除可观察对象

并且不包含breeze内部使用的任何其他附加属性或功能

我希望能找到像这样的东西：

var json = application.toJS();

但这种方法并不存在。使用ko.toJS（应用程序）也不起作用，因为（1）、（2）和（3）没有得到满足

我相信这应该很容易做到，但我就是在文档中找不到任何远程相关的东西

更新：你会原谅我的可怕的黑客行为，但因为我很匆忙，我所做的事情暂时解决了我的问题，只是暴露了

entityManager

的

内部函数。我还稍微更改了函数定义（只是为了排除恼人的
entityAspect
）：

由于我的服务中始终提供
entityManager
，因此我能够扩展我的类型定义以执行以下操作：

function createApplicant(initialValues) {
    var applicant = applicantType.createEntity(initialValues);

    applicant.toJS = function () {
        var unwrappedEntities = entityManager.unwrapEntities([applicant], entityManager.metadataStore, false);
        return unwrappedEntities[0];
    };

    return applicant;
}

这正是我需要的：

var json = application.toJS();

这是个好主意！你能把它加到桌子上吗。公开Breeze实体的“展开”非常有意义

只是一个小小的旁注，您编写的“破解”在将来的Breeze版本中可能不起作用，因为我们目前正在重构其中一些代码，但我将尝试公开一个“更干净”的版本，作为Breeze api的一部分
 这可能是过时的解决方案，但我在我的typescript类中做了一些修改，在没有breeze core帮助的情况下做到了这一点。
我之所以这么做是因为我的breeze版本和键入文件不包含展开方法，而且我现在不想升级它。

另一个好处是，result类完全清除了元数据中未包含的任何额外属性，并且您可以控制是只需要普通实体，还是还需要在结果中嵌入相关实体

只需在typescript类中包含以下代码即可完成此操作：

public unwrapEntity(entity: breeze.Entity, includeRefs: boolean): any {
    var refs = [];
    return this.unwrapEntityInner(entity, refs, includeRefs);
}

private objInArray(obj: any, refs: Array<any>): boolean {
    var ret = false;
    for (var i = 0; i < refs.length; i++) {
        if (obj === refs[i]) {
            ret = true;
            break;
        }
    }
    if (!ret)
        refs.push(obj);
    return ret;
}

private unwrapEntityInner(entity: breeze.Entity, refs: Array<any>, includeRefs: boolean): any {
    var data = {};
    for (var prop in entity) {
        if (entity.hasOwnProperty(prop) && ko.isObservable(entity[prop])) {
            data[prop] = entity[prop]();
            if (typeof data[prop] !== 'undefined' && data[prop] != null) {
                if (typeof data[prop].entityAspect !== 'undefined') {
                    data[prop] = (includeRefs && !this.objInArray(data[prop], refs)) ? this.unwrapEntityInner(data[prop], refs, includeRefs ) : null;
                }
                else if ($.isArray(data[prop])) {
                    if (!includeRefs || this.objInArray(data[prop], refs))
                        data[prop] = [];
                    else {
                        var tmp = data[prop];
                        data[prop] = [];
                        for (var i = 0; i < tmp.length; i++) {
                            data[prop].push(this.unwrapEntityInner(tmp[i], refs, includeRefs));
                        }
                    }
                }
            }
        }
    }
    return data;
}

公共不可见性（实体：breeze.entity，includeRefs:boolean）：任意{
var-refs=[]；
返回此.UnwapentyInner（实体、引用、includeRefs）；
}
私有对象数组（对象：任意，引用：数组）：布尔值{
var-ret=false；
对于（变量i=0；i
我已经做了，这是对的。我将查看变更日志并重构代码，以防建议将其应用到未来的版本中。顺便说一句，你们用Breeze做得很好，我已经用了几个星期了，我认为这绝对是太棒了。
public unwrapEntity(entity: breeze.Entity, includeRefs: boolean): any {
    var refs = [];
    return this.unwrapEntityInner(entity, refs, includeRefs);
}

private objInArray(obj: any, refs: Array<any>): boolean {
    var ret = false;
    for (var i = 0; i < refs.length; i++) {
        if (obj === refs[i]) {
            ret = true;
            break;
        }
    }
    if (!ret)
        refs.push(obj);
    return ret;
}

private unwrapEntityInner(entity: breeze.Entity, refs: Array<any>, includeRefs: boolean): any {
    var data = {};
    for (var prop in entity) {
        if (entity.hasOwnProperty(prop) && ko.isObservable(entity[prop])) {
            data[prop] = entity[prop]();
            if (typeof data[prop] !== 'undefined' && data[prop] != null) {
                if (typeof data[prop].entityAspect !== 'undefined') {
                    data[prop] = (includeRefs && !this.objInArray(data[prop], refs)) ? this.unwrapEntityInner(data[prop], refs, includeRefs ) : null;
                }
                else if ($.isArray(data[prop])) {
                    if (!includeRefs || this.objInArray(data[prop], refs))
                        data[prop] = [];
                    else {
                        var tmp = data[prop];
                        data[prop] = [];
                        for (var i = 0; i < tmp.length; i++) {
                            data[prop].push(this.unwrapEntityInner(tmp[i], refs, includeRefs));
                        }
                    }
                }
            }
        }
    }
    return data;
}