Question

有没有办法使用Breeze创建类型化实体，就像JaySvcUtil为JayData工作一样？这是否包括Typescript支持 - 在Breeze框架中是否也有一般的Typescript支持？

Answer 1

这个要点包含T4TS的修改版本，其中包含一些初始支持，用于为Breeze生成“每个实体的设计时Javascript类”。

https://gist.github.com/alexdresko/5393155

到目前为止，它符合我的需求。我非常确定您需要在解决方案中使用DefinitelyTyped Breeze定义才能使其正常工作。

也许这是可以永久添加到T4TS的东西？也许这是Breeze团队需要考虑的事情？或者它可能只是愚蠢而且对我以外的任何人都没有用。 :)

在我的数据服务中，我可以做类似的事情：

    createOrganization() : T4TS.Organization {
        return <T4TS.Organization>this.manager.createEntity("Organization");
    }

然后，在我的VM中，所有这些代码都非常类型安全..

    organizationSubmit() {
        this.editingOrganization(false);
        var newOrganization = this.dataservice.createOrganization();

        newOrganization.Name(this.organizationNameInput());
        if (newOrganization.entityAspect.validateEntity()) {
            this.extendOrganization(newOrganization);
            this.organizations.push(newOrganization);
            this.dataservice.saveChanges();
            this.organizationNameInput("");
        } else {
            this.handleItemErrors(newOrganization);

        }
    };

我真的不知道从这里去哪里。我尝试过分T4TS，但没有时间弄清楚他的构建系统。因此，要点。意见当然是受欢迎的。

Answer 2

我们计划使用TypeScript做更多事情，但还没有提交到特定的时间范围。（鲍里斯的作品，在约翰的帖子中提到，肯定是一个很好的开始）。

更新：自v 0.84.4起，Breeze提供完整的TypeScript支持。

为每个实体自动生成设计时Javascript类;我们已就此进行了多次内部讨论，但他们真的在等待社区的投票。我们几乎肯定会在某个时候绕过这个问题，但是你的投票结果却是如此 UserVoice肯定可以加快这一过程。

Answer 3

下面是您可以放入网站以生成打字稿界面定义的页面。页面获取breeze元数据，然后遍历所有类型，并为每种类型输出typescript接口声明。然后可以将此页面的输出粘贴到任何打字稿文件（* .ts）或打字稿定义文件（* .d.ts）中。如果要对接口进行命名空间，请将结果包含在模块声明中：declare module northwind { ... paste interfaces here... }。

在使用页面之前，您需要进行一次编辑：从＆＃34; api / northwind＆＃34;更改实体管理器的控制器网址。无论你的微风控制器的网址是什么。

生成的接口依赖于Knockout.js打字稿定义，您可以在此处获取：https://github.com/borisyankov/DefinitelyTyped/tree/master/knockout/

使用learn.breezejs.com中的northwind示例，此定义生成器页面的输出将如下所示：

export interface Employee extends breeze.Entity {
    FirstName: KnockoutObservable<string>;
    LastName: KnockoutObservable<string>;
}

然后，您可以使用breeze执行查询，并将结果转换为一系列员工，如下所示：

var manager = new breeze.EntityManager('api/northwind');

var query = new breeze.EntityQuery()
    .from("Employees");

manager.executeQuery(query).then(data => {
    // ***cast the results to a strongly typed array of Employee***
    var employees = <Employee[]>data.results;
}).fail(e => {
    alert(e);  
});

下面是定义生成器页面 - 将新的html文件添加到名为＆＃34; definitions.html＆＃34;的项目中，运行项目并导航到该页面。

<html>
<head>
    <title>Typescript Definition Generator</title>
    <style>
        code {
            white-space: pre;
        }
    </style>
    <script src="//code.jquery.com/jquery-2.1.0.min.js"></script>
    <script src="//ajax.aspnetcdn.com/ajax/knockout/knockout-3.0.0.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/q.js/1.0.0/q.min.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/breezejs/1.4.4/breeze.min.js"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            var entityManager = new breeze.EntityManager('api/northwind');
            entityManager.fetchMetadata()
                .then(function () {
                    var html = '',
                        types = entityManager.metadataStore.getEntityTypes(),
                        type,
                        i,
                        j,
                        property,
                        crlf = String.fromCharCode(13),
                        code = document.createElement('code'),
                        script = document.createElement('script');

                    function getJSType(metadataType) {
                        if (/(Int64)|(Int32)|(Int16)|(Byte)|(Decimal)|(Double)|(Single)|(number)/.test(metadataType))
                            return 'number';
                        else if (/(DateTime)|(DateTimeOffset)|(Time)|(Date)/.test(metadataType))
                            return 'Date';
                        else if (/(Boolean)/i.test(metadataType))
                            return 'boolean';
                        return 'string';
                    }

                    for (i = 0; i < types.length; i++) {
                        // type declaration
                        var type = types[i];
                        html += 'export interface ' + type.shortName;

                        // base type
                        html += ' extends ';
                        if (type.hasOwnProperty('baseEntityType')) {
                            html += type.baseEntityType.shortName;
                        } else {
                            html += 'breeze.Entity';
                        }
                        html += ' {' + crlf;

                        // data properties
                        for (j = 0; j < type.dataProperties.length; j++) {
                            property = type.dataProperties[j];
                            if (type.baseEntityType && type.baseEntityType.dataProperties.filter(function (p) { return p.name === property.name; }).length > 0)
                                continue;
                            html += '    ' + property.name;
                            //if (property.isNullable)
                            //    html += '?';
                            html += ': KnockoutObservable&lt;';
                            html += getJSType(property.dataType.name);
                            html += '&gt;; //' + property.dataType.name + crlf;
                        }

                        // navigation properties
                        for (j = 0; j < type.navigationProperties.length; j++) {
                            property = type.navigationProperties[j];
                            if (type.baseEntityType && type.baseEntityType.navigationProperties.filter(function (p) { return p.name === property.name; }).length > 0)
                                continue;
                            html += '    ' + property.name;
                            //if (property.isNullable)
                            //    html += '?';
                            if (property.isScalar)
                                html += ': KnockoutObservable&lt;';
                            else
                                html += ': KnockoutObservableArray&lt;';
                            html += property.entityType.shortName;
                            html += '&gt;;' + crlf;
                        }

                        html += '}' + crlf + crlf;
                    }

                    code.innerHTML = html;

                    $(code).addClass('prettyprint');

                    document.body.appendChild(code);

                    script.setAttribute('src', '//google-code-prettify.googlecode.com/svn/loader/run_prettify.js');
                    document.body.appendChild(script);
                })
                .fail(function (reason) {
                    alert(reason);
                });
        });
    </script>
</head>
<body>
</body>
</html>

Answer 4

对于微风TypeScript定义，请使用NuGet包breeze.TypeScript.DefinitelyTyped。要为实体创建定义，可以使用TypeLITE。它将创建一个.d.ts文件，其界面如下：

declare module MyProject.Models {
interface Customer {
  Id: number;
  AccountNumber: string;
  ...

虽然这些界面完全描述了您的实体，但它们并未扩展breeze.Entity。要很好地使用Breeze API类型定义，从这些接口派生自己的接口，如下所示：

import Models = MyProject.Models;
interface Customer extends Models.Customer, breeze.Entity { }
...

这仍然涉及一些手动编码，但至少它只是每种类型，而不是每个属性。

Answer 5

关于打字稿，它肯定在我们的雷达上。我们至少会创建一个TypeScript'declare'文件，在使用Breeze时可以提供更好的智能感知。

您可以在UserVoice上投票。

在那之前你可能想要使用支持Breeze的Boris Yankov的DefinitelyTyped。

Answer 6

我的两分钱......

我一直在使用definatelytyped定义文件进行微风，它看起来效果很好。

创建一个T4脚本为.edmx中的所有实体生成.d.ts文件然后你得到你想要的智能感知是相当简单的。如果Ward喜欢，我可以在某处发布一个示例T4脚本。

Breeze.js键入实体

6 个答案: