Question

更改为StreamEventTransformer后，我必须创建一个行为类似于StreamEventTransformer的包装类，所以这里是代码：

class Transformer implements EventSink, StreamTransformer {
  EventSink rootSink;

  Transformer();
  Transformer._useSink(this.rootSink);

  void handleData(event, EventSink sink) {
    print('inside handleData');
    sink.add(event);
  }

  void handleError(error, StackTrace stackTrace, EventSink sink) =>
      sink.addError(error, stackTrace);

  void add(event) {
    print('inside add');
    handleData(event, rootSink);
  }


  void addError(error, [StackTrace stackTrace]) =>
      handleError(error, stackTrace, rootSink);

  void close() => rootSink.close();

  Stream bind(Stream source) =>
      new Stream.eventTransformed(source, (EventSink sink) {
        EventSink eventSink = new Transformer._useSink(sink);
        return eventSink;
      });
}

使用这个课程，我只需要从Transformer扩展以适应变化。

但是当我扩展它时：

class PlusOneTransformer extends Transformer {
  void handleData(data, sink) {
    sink.add(data + 1);
  }
}

并测试它：

void main() {
  StreamController controller = new StreamController();
  Stream stream = controller.stream.transform(new PlusOneTransformer());
  stream.listen(print);
  controller.add(10);
}

我期待输出是：

inside add
11

但是：

inside add
inside handleData
10

所以它没有运行被覆盖的handleData，它正在运行旧的Transformer。从调试器我可以看到，当我使用PlusOneTransformer转换流时，执行的类为PlusOneTransformer而不是{{1}}。

我错过了什么吗？

Answer 1

错误在于这一行：

 new Transformer._useSink(sink);

这将分配Transformer而不是子类。

最简单的解决方案：不要分配新的接收器，而是重用已有的接收器：

  Stream bind(Stream source) =>
      new Stream.eventTransformed(source, (EventSink sink) {
        this.rootSink = sink;
        return this;
      });

由于变压器不可重复使用，因此最好检查一下：

  Stream bind(Stream source) =>
      new Stream.eventTransformed(source, (EventSink sink) {
        if (this.rootSink != null) {
          throw new StateError("Transformer already used");
        }
        this.rootSink = sink;
        return this;
      });

执行重写方法会触发未重写的方法

1 个答案: