继承Promise类并按此方式使用是否正确？附C#转JS语法适配需求

Hey there! As someone who’s made the jump from C# to JavaScript, I totally get wanting to bring familiar syntax patterns over to make your workflow more comfortable. Let’s break down your questions about custom Promise handling step by step.

From a JavaScript language specification and syntax perspective, yes, inheriting from Promise is completely valid—as long as you properly call the parent class constructor (super()) in your subclass.

That said, there’s a key detail about Promise behavior you need to keep in mind with your run variable approach:

• Promises are one-shot entities. Once a Promise resolves or rejects, its state is fixed forever. If you’re reusing the same Promise instance stored in run, every subsequent await will just return the same resolved/rejected value—no re-execution of the underlying async logic.
• If this "reuse" is intentional (like caching the result of an async operation to avoid redundant work), then your approach works perfectly. But if you expect each await to trigger fresh async execution, this won’t behave the way you might expect (unlike some C# Task patterns where you can restart or re-run a task).

You’re spot-on about the main issue: most naive extends Promise implementations trigger async logic immediately when the instance is created.

Here’s why that’s a problem, especially for C# devs used to Task patterns:

• JavaScript Promises are "hot" by design. The executor function passed to the Promise constructor runs synchronously as soon as the Promise is instantiated. This is very different from C# where you can create a "cold" Task that only executes when you explicitly start it (e.g., with task.Start() or await).
• Most basic examples don’t account for this—they just inherit Promise and wrap the async logic directly in the constructor. This means your async code runs the second you create the subclass instance, even if you don’t await it or attach a .then() handler. For scenarios where you want to control when the async work starts, this is a major gotcha.

If your goal is to mimic C#’s more controllable Task behavior, you don’t even need to inherit from Promise. Instead, you can create a simple wrapper class that manages a Promise instance internally, giving you control over when execution starts:

class AsyncTask {
  constructor(executor) {
    // Store the async logic without executing it immediately
    this.executor = executor;
    this.promise = null;
  }

  // Explicitly start the task (or reuse the existing promise if already resolved)
  start() {
    if (!this.promise) {
      this.promise = new Promise(this.executor);
    }
    return this.promise;
  }

  // Make the class awaitable by implementing the thenable interface
  then(onResolved, onRejected) {
    return this.start().then(onResolved, onRejected);
  }

  catch(onRejected) {
    return this.start().catch(onRejected);
  }
}

// Usage example
const fetchDataTask = new AsyncTask((resolve) => {
  console.log("Running async logic...");
  setTimeout(() => resolve("Data loaded!"), 1000);
});

// First await triggers execution
await fetchDataTask; // Logs "Running async logic..." and resolves after 1s
// Second await reuses the existing resolved promise (no new log)
await fetchDataTask; // Immediately returns "Data loaded!"

This approach keeps the async logic "cold" until you explicitly trigger it, which feels much closer to C#’s Task behavior.

内容的提问来源于stack exchange，提问作者user9235753