Dart 工厂正在等待将来构造对象

我如何使工厂内的未来同步？我在这里向客户返回null

  factory Project.retrieve(String hash, CompetencesService service) {
    Project project;
    service.dbRef.child("project").once("value").then((snapshot) {
      Map val = snapshot.val();
      project = toObservable(new Project.fromJson(val));

      if(project != null) {
        project.listen(service);
        print("listening1");
      } else {
        project = toObservable(new Project.newHash(hash));
        service.dbRef.child("project").update(project.toJson()).then((error) {
          if(error) {
            //
          } else {
            project.listen(service);
            print("listening2");
          }
        });
      }
    });
    return project;
  }

---

有人对此表示感谢，但我正在寻找解决方法的示例。

目前，无法创建异步构造函数或工厂，也无法同步等待

未来

后者有一个明显的原因：如果您将停止并同步等待某个依赖于当前隔离本身的事件（而不是像文件i/o这样的外部事件），它将永远不会发生，因为
isolate
处于单个线程中，该线程在等待状态下停止

因此，这里唯一的方法是使用静态方法返回带有
Project
实例的
Future
，就像您提供的链接中提到的那样：

static Future<Project> retrieve() async {
  var snapshot = await service.dbRef.child("project").once("value");
  Project project = toObservable(new Project.fromJson(snapshot.val()));

  ...

  return project; // Note you're actually returning a Future here
}

static Future retrieve（）异步{
var snapshot=await service.dbRef.child（“项目”）.once（“值”）；
Project=toObservable（newproject.fromJson（snapshot.val（））；
...
return project；//注意，您实际上是在返回一个未来
}
我尝试实现
Future
接口，然后工厂和构造器可以返回
Future
并可以
等待

@proxy
class AsyncFact implements Future {
  factory AsyncFact() {
    return new AsyncFact._internal(new Future.delayed(
        const Duration(seconds: 1), () => '[Expensive Instance]'));
  }

  AsyncFact._internal(o) : _mirror = reflect(o);

  final InstanceMirror _mirror;
  @override
  noSuchMethod(Invocation invocation) => _mirror.delegate(invocation);
}

@proxy
class AsyncConst implements Future {
  AsyncConst() : _mirror = reflect(new Future.delayed(
          const Duration(seconds: 1), () => '[Expensive Instance]'));

  final InstanceMirror _mirror;
  @override
  noSuchMethod(Invocation invocation) => _mirror.delegate(invocation);
}

main() async {
  print(await new AsyncFact()); // [Expensive Instance]
  print(await new AsyncConst()); // [Expensive Instance]
}

最后，我提出了一个解决方案，避免了这一切。我没有尝试替换整个
项目
对象，而是替换了部分对象。我将
Project.fromJson（）
从一个工厂更改为一个方法。一个缺点是这会将问题提升到一个层次。这不是@Mike答案的一个更一般的例子吗？这个例子实现了近似的异步工厂/构造函数特性，而不仅仅是异步静态工厂方法。对我来说，这与未来泛型类中的构造函数相同，因为它不是我们需要实现的类，而是它的未来。