Angular 在Typescript中创建子类

我想在我的服务类中创建一个子类，在其中我可以声明具有相同名称但使用不同用法的函数

我想能够写：

httpWrapper.get //default is observables. returns observable
httpWrapper.promise.get //returns promise-variant

我目前的服务：

export class HttpWrapperService {
    constructor(@Inject(HttpClient) private readonly http: HttpClient) { }

    public get<T>(endpoint: string, options?: any): Observable<HttpEvent<T>> {
        return this.http.get<T>(endpoint, options);
    }
    public post<T>(endpoint: string, data: any, options?: any): Observable<HttpEvent<T>> {
        return this.http.post<T>(endpoint, data, options);
    }
    public delete<T>(endpoint: string, options?: any): Observable<HttpEvent<T>> {
        return this.http.delete<T>(endpoint, options);
    }
}

export namespace HttpWrapperService {
    export class Promise {
        constructor(@Inject(HttpClient) private readonly http: HttpClient) { }
        public get<T>(endpoint: string, options?: any) {
            return this.http.get<T>(endpoint, options).toPromise();
        }
        public post<T>(endpoint: string, data: any, options?: any) {
            return this.http.post<T>(endpoint, data, options).toPromise();
        }
        public delete<T>(endpoint: string, options?: any) {
            return this.http.delete<T>(endpoint, options).toPromise();
        }
    }
}

当我选择了

httpWrapper.promise.

：

httpWrapper.promise.get
httpWrapper.promise.post
httpWrapper.promise.delete

---

您可以在

可观察的

上使用

toPromise

方法。 就这样

例子

httpWrapper.get//default是可观察的。返回可观察的

httpWrapper.get.toPromise（）//返回承诺变量

我这样解决它：

@Injectable()
export class HttpWrapperService {
    constructor(@Inject(HttpClient) private readonly http: HttpClient) { }

    public get<T>(endpoint: string, options?: any): Observable<HttpEvent<T>> {
        return this.http.get<T>(endpoint, options);
    }
    public post<T>(endpoint: string, data: any, options?: any): Observable<HttpEvent<T>> {
        return this.http.post<T>(endpoint, data, options);
    }
    public delete<T>(endpoint: string, options?: any): Observable<HttpEvent<T>> {
        return this.http.delete<T>(endpoint, options);
    }

    // tslint:disable-next-line:max-classes-per-file
    public promise = new class {
        constructor(private wrapper: HttpWrapperService) { }
        public get<T>(endpoint: string, options?: any) {
            return this.wrapper.get<T>(endpoint, options).toPromise();
        }
        public post<T>(endpoint: string, data: any, options?: any) {
            return this.wrapper.post<T>(endpoint, data, options).toPromise();
        }
        public delete<T>(endpoint: string, options?: any) {
            return this.wrapper.delete<T>(endpoint, options).toPromise();
        }
    }(this);

}

@Injectable（）
导出类HttpWrapperService{
构造函数（@Inject（HttpClient）私有只读http:HttpClient）{}
公共get（端点：字符串，选项？：任意）：可观察{
返回this.http.get（端点，选项）；
}
公共帖子（端点：字符串，数据：任意，选项？：任意）：可观察{
返回this.http.post（端点、数据、选项）；
}
公共删除（端点：字符串，选项？：任意）：可观察{
返回this.http.delete（端点，选项）；
}
//tslint:禁用下一行：每个文件的最大类数
公共承诺=新课程{
构造函数（私有包装器：HttpWrapperService）{}
公共获取（端点：字符串，选项？：任意）{
返回此.wrapper.get（端点，选项）.toPromise（）；
}
公共帖子（端点：字符串，数据：任意，选项？：任意）{
返回此.wrapper.post（端点、数据、选项）.toPromise（）；
}
公共删除（端点：字符串，选项？：任意）{
返回此.wrapper.delete（端点，选项）.toPromise（）；
}
}（本条）；
}

我现在可以通过以下方式调用这些函数：

//different service
constructor(@Inject(HttpWrapperService) private readonly httpWrapper: HttpWrapperService) {}

public letsUseHttpRequests(machine: Machine){
    this.httpWrapper.post<Machine>(endpoint, machine); //observable
    this.httpWrapper.get<Machine>(endpoint); //observable
    this.httpWrapper.delete<Machine>(endpoint); //observable
    this.httpWrapper.promise //classContainer
    this.httpWrapper.promise.get<Machine>(endpoint); //promise
    this.httpWrapper.promise.post<Machine>(endpoint, machine); //promise
    this.httpWrapper.promise.delete<Machine>(endpoint); //promise
}

//不同的服务
构造函数（@Inject（HttpWrapperService）私有只读httpWrapper:HttpWrapperService）{}
公共租赁使用前传（机器：机器）{
this.httpWrapper.post（端点，机器）；//可观察
this.httpWrapper.get（端点）；//可观察
this.httpWrapper.delete（端点）；//可观察
this.httpWrapper.promise//classContainer
this.httpWrapper.promise.get（端点）；//promise
this.httpWrapper.promise.post（端点，机器）；//promise
this.httpWrapper.promise.delete（端点）；//promise
}

我正要提出类似的建议：）@TitianCernicova Dragomir，尽管我自己解决了——我很想看看你的想法，我看过你的其他一些帖子，我真的很喜欢你的工作。可能还有其他人也希望有不同的解决方案。：）它实际上是同一个匿名类，实例化为一个字段。名称空间类将名称空间中的内容与类的静态部分合并，这是我本应添加的额外信息：）@TitianCernicova Dragomir Sidenote：出于某种原因，我需要在observable中使用

HttpEvent

。但我的其他电话不喜欢这样。如果不使用

observable

，我如何执行可观察函数。可观察的工作不应该吗？奇怪…？为什么不简单的

httpWrapper.getPromise

而不是

httpWrapper.promise.get

？此外，

httpWrapper.promise.get

的重复性比

httpWrapper.get.toPromise（）

？另一个提示：您的包装服务有错误的方法签名。只要您没有传递

选项

参数或没有键的参数，请观察：“事件”和

报告进度：true

，返回类型是可观察的，如果您将一个与对一起传递，则返回类型将是可观察的。等一下，我会尽力回答你所有的问题<代码>1和

2

：可读性和首选性（另外，我认为如果包装中的功能发生变化，则更容易折射）<代码>3：不确定这是什么意思。选项参数是可选的吗<代码>3：您所说的签名参数是什么意思<代码>4：你把我弄丢了：/。如果您有办法帮助我解决当前解决方案中可能出现的任何问题，我很乐意批准它作为答案。

//different service
constructor(@Inject(HttpWrapperService) private readonly httpWrapper: HttpWrapperService) {}

public letsUseHttpRequests(machine: Machine){
    this.httpWrapper.post<Machine>(endpoint, machine); //observable
    this.httpWrapper.get<Machine>(endpoint); //observable
    this.httpWrapper.delete<Machine>(endpoint); //observable
    this.httpWrapper.promise //classContainer
    this.httpWrapper.promise.get<Machine>(endpoint); //promise
    this.httpWrapper.promise.post<Machine>(endpoint, machine); //promise
    this.httpWrapper.promise.delete<Machine>(endpoint); //promise
}