Problem lösen oder später ablehnen in TypeScript

Question

In einem Angular2/TypeScript-Projekt gibt das System beim Anzeigen eines Dialogs ein Promise-Objekt an den Aufrufer zurück, das aufgelöst wird, nachdem der Dialog vom Benutzer geschlossen wurde.

Die Schnittstelle der Promise-Klasse stellt die Methoden resolve() oder reject() nicht zur Verfügung, daher muss ich Verweise auf diese Methoden speichern, um sie später aufzurufen.

Das sieht nicht richtig aus. Gibt es einen besseren Weg?

class Dialog { 
    private resolve; 
    private reject; 

    show(): Promise<any> { 
     var p = new Promise<any>((resolve, reject) => { 
      //save method references for later use 
      this.resolve = resolve; 
      this.reject = reject; 
     }); 
     return p; 
    } 

    close() { 
     this.resolve(); 
    } 
} 

Answer 1

Ich brauchte so etwas wie dieses, so habe ich diese Zukunft Klasse:

class Future<T> implements PromiseLike<T> { 
    private promise: Promise<T>; 
    private resolveFunction: (value?: T | PromiseLike<T>) => void; 
    private rejectFunction: (reason?: any) => void; 

    constructor(promise?: Promise<T>) { 
     if (!(this instanceof Future)){ 
      return new Future(promise); 
     } 

     this.promise = promise || new Promise(this.promiseExecutor.bind(this)); 
    } 

    public asPromise(): Promise<T> { 
     return this.promise; 
    } 

    public then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Future<TResult>; 
    public then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): Future<TResult>; 
    public then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => any): Future<TResult> { 
     return new Future(this.promise.then(onfulfilled, onrejected)); 
    } 

    public catch(onrejected?: (reason: any) => T | PromiseLike<T>): Future<T>; 
    public catch(onrejected?: (reason: any) => void): Future<T>; 
    public catch(onrejected?: (reason: any) => any): Future<T> { 
     return new Future(this.promise.catch(onrejected)); 
    } 

    public resolve(value?: T | PromiseLike<T>) { 
     this.resolveFunction(value); 
    } 

    public reject(reason?: any) { 
     this.rejectFunction(reason); 
    } 

    private promiseExecutor(resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) { 
     this.resolveFunction = resolve; 
     this.rejectFunction = reject; 
    } 
} 

es wie so verwenden:

let future = new Future<string>(); 

// do what not and then: 
future.resolve("A_VALUE"); 
// or reject it: 
future.reject("MESSAGE"); 

Sie können auch die Zukunft Instanz speichern, zurückgeben, und dann lösen/später ablehnen:

class MyClass { 
    private future: Future<string[]>; 

    constructor() { 
     this.future = new Future<string[]>(); 
    } 

    fetch(url: string): Promise<string[]> { 
     ISSUE_HTTP_REQUEST(url) 
      .then(this.future.resolve.bind(this.future)) 
      .catch(this.future.reject.bind(this.future)); 

     return this.future.asPromise(); 
    } 
}