在Dart中实现观察者模式 [英] Implement an Observer pattern in Dart

问题描述

我想在Dart中实现一个观察者模式，但我不知道该如何去做。

假设我有一个类：

  class MyClass {
 
 String obser_field; 
 
} 
  

现在，每当我更改字段，打印observe_field changed字符串到控制台。使用自定义安装程序很简单：

  class MyClass {
 
 String _observed_field; 
 
 get obser_field => _observed_field; 
 set observe_field（v）{
 _observed_field = v; 
 print（observed_field changed）; 
} 
 
} 
  

现在，没有一个，但是许多这些字段，我不想创建所有的getters和setter。明显的理论解决方案是让它们动态地添加到类中这样的东西（不是一个工作代码，只是一个例子，我希望它看起来）：

  class MyClass 
 
 String _observeable_field; 
 String _observeable_field_2; 
 
 observe（#observeable_field，＃obserable_field_2）; 
 
 end 
  

是否可能？此外，如果没有在 observe（）调用之上定义这些字段，而是写下如下内容，将是非常棒的：

  observe（String：#_observeable_field，String：＃_observeable_field_2）; 
  

以便自动声明这些字段。

解决方案

这里有一种使用观察包。该示例取自该软件包中的代码注释（并适用于上面的示例）。基本上，您可以使用 @observable 注释来注释要查看的字段，然后监听更改（通过调用 Observable触发）。首先，在你的 pubspec.yaml 中添加observable包。

  dependencies：
 observe：any 
  
 
 
 
然后创建一个快速测试程序... 
  import'package：observe / observe.dart'; 
 
 class MyClass extends Object with Observable {
 @observable String observeField =Hello; 
 
 toString（）=> observedField.toString（）; 
} 
 
 main（）{
 var obj = new MyClass（）; 
 
 //有变化时执行的匿名函数
 obj.changes.listen（（records）{
 print（'Changes to $ obj are：$ records'）; 
}）; 
 
 
 obj.observedField =Hello World; 
 
 //在我们检查它们之前不会有更改
 Observable.dirtyCheck（）; 
 
 print（'done！'）; 
} 
  
这将产生以下输出：
 对Hello World的更改是：[＃< PropertyChangeRecord Symbol（observedField）from：Hello to：Hello World>] 
 done！ 
  
 更新示例省略 Observable.dirtyCheck（），可以使用setter和 notifyPropertyChanged  code> ChangeNotifier  
 
 
类 
 String _observedField =Hello; 
 
 @reflectable get observeField => _observedField; 
 @reflectable set observedField（v）{
 _observedField = notifyPropertyChange（#observedField，_observedField，v）; 
} 
 
 toString（）=>观察域
 
} 
  

I would like to implement an observer pattern in Dart but I'm not sure how to go about it.

Let's say I have a class:

class MyClass {

  String observed_field;

}

Now, whenever I change the field, I'd like to print "observed_field changed" string into the console. Pretty simple to do with a custom setter:

class MyClass {

  String _observed_field;

  get observed_field    => _observed_field;
  set observed_field(v) {
    _observed_field = v;
    print("observed_field changed");
  }

}

Now, of course, if I have not one, but many of those fields, I wouldn't want to create all those getters and setters. The obvious theoretical solution is to have them dynamically added to the class with something like this (not a working code, just an example of how I wish it looked):

class MyClass

  String  _observeable_field;
  String  _observeable_field_2;

  observe(#observeable_field, #observeable_field_2);

end

Is it even possible? Additionally, it would be super awesome to not have those fields defined above the observe() call, but rather write something like:

observe(String: #_observeable_field, String: #_observeable_field_2);

So that those fields are declared automatically.

解决方案

Here's a way to do it using the Observe package. The example is taken from code comments in that package (and adapted to your example above). Essentially, you annotate fields you want to be observable with the @observable annotation, and then listen for changes (which you trigger with the call to Observable.dirtyCheck();

First, add the observable package in your pubspec.yaml

dependencies:
  observe: any

Then create a quick test program...

import 'package:observe/observe.dart';

class MyClass extends Object with Observable {
  @observable String observedField = "Hello";

  toString() => observedField.toString(); 
}

main() {
  var obj = new MyClass();

  // anonymous function that executes when there are changes
  obj.changes.listen((records) {
    print('Changes to $obj were: $records');
  });


  obj.observedField = "Hello World";

  // No changes are delivered until we check for them
  Observable.dirtyCheck();

  print('done!');
}

This produces the following output:

Changes to Hello World were: [#<PropertyChangeRecord Symbol("observedField") from: Hello to: Hello World>]
done!

Update in response to comments... Updating the example to omit the Observable.dirtyCheck() you can use a setter and notifyPropertyChanged, with the class instead mixing in ChangeNotifier

class MyClass2 extends Object with ChangeNotifier {

  String _observedField = "Hello";

  @reflectable get observedField    => _observedField;
  @reflectable set observedField(v) {
    _observedField = notifyPropertyChange(#observedField, _observedField, v);    
  }

  toString() => observedField;

}

这篇关于在Dart中实现观察者模式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！