标签: observer-pattern

我正在修复一个遗留应用程序，该应用程序存在对象被实现 Observable 的类中的观察者列表保留的问题。正确地删除观察者将是一项漫长的任务，所以我想我可以用来WeakReference克服这个问题。问题是，由于没有实现观察者，所以调用Observable.addObserver(new WeakReference(something))是不可能的。WeakReference所以我想到创建WeakObserver这样的类：

public class WeakObserver<T> extends WeakReference<T> implements Observer {
private T observer;

public WeakObserver(final T observer){
    super(observer);
    this.observer = observer;
}

@Override
public void update(Observable o, Object arg) {
    ((Observer)observer).update(o, arg);
}
}

这里的问题非常明显 - 除了方法中的不安全转换之外update，我正在创建另一个对我想要垃圾收集的对象的引用。

这样的事情有可能吗，还是我想做一些愚蠢的事情？

我正在准备考试，目前正在阅读有关观察者模式的内容。然后我想知道观察者模式遵循或违反了哪些SOLID原则？

我需要在我的项目中添加观察，但是由于与我一起工作的经理不允许我在函数中使用@objc，无论如何我可以在不使用@objc的情况下使用这个函数吗？

   func createObservers() {
      NotificationCenter.default.addObserver(self, selector: #selector(self.updatedata(notification:)),
                                             name: Notification.Name(rawValue: updateNotificationKey), object: nil)

    }

   @objc dynamic func updatedata(notification: NSNotification) {
         updateDataIcon()
     }

我们将不胜感激您的帮助。

我是 RXJS 库的新手用户，正在尝试弄清楚如何正确使用 Observable 和subjects。我试图将其与模式设计观察者进行比较。在某些时候，我有一个问题，RXJS 库中的 Observable 实例是否是观察者模式设计的特例？

我已经创建了一个通用的Observer接口和一个Observable类,但由于一些泛型问题而无法编译我的类.我不知道为什么我要做的事情是被禁止的.代码如下:

public class Observable<U> {

    private List<Observer<Observable<U>, U>> _observers = 
            new ArrayList<Observer<Observable<U>, U>>();

    public void addObserver(Observer<? extends Observable<U>, U> obs) {
        if (obs == null) {
            throw new IllegalArgumentException();
        }
        if (_observers.contains(obs)) {
           return;
        }
        _observers.add(obs); // This line does not compile
    }

    public void notifyObservers(U data) {
        for (Observer<? extends Observable<U>, U> obs : _observers) {
            // After correction of the list declaration, this line will not compile
            obs.update(this, data); 
        }        
    }
}

interface Observer<T, U> {
    public void …

我读过Russ Olsen的"Ruby模式设计", 如何在Ruby中实现Observer模式.我注意到这种模式的Ruby实现比C#实现简单得多,例如Jesse Liberty和Alex Horovitz在"Programming .NET 3.5"中显示的实现.

因此,我使用"Ruby中的设计模式"算法重写了"Programming .NET 3.5"Observer模式示例(pdf版本的第251页),两种实现的源代码都可以从上述网站下载.

下面是重写的例子,告诉我你的想法是什么？
我们真的需要使用事件和委托来使用C#中的Observer模式吗？

更新 阅读评论后,我想问一下这个问题:
除了使代码缩短之外,还有其他理由使用委托和事件吗？我不谈论GUI编程.

Update2 我终于明白了,委托只是一个函数指针,事件是委托的更安全版本,它只允许两个操作+ =和 - =.

我重写了"Programming .NET 3.5"示例:

using System;
using System.Collections.Generic;

namespace MyObserverPattern
{
    class Program
    {
        static void Main()
        {
            DateTime now = DateTime.Now;

            // Create new flights with a departure time and add from and to destinations
            CarrierSchedule jetBlue = new CarrierSchedule("JetBlue", now);
            jetBlue.Attach(new AirTrafficControl("Boston"));
            jetBlue.Attach(new AirTrafficControl("Seattle"));

            // ATCs will be notified of delays in departure time …

我有一个包含多个DropDowns的菜单.我添加了代码,但目前,它完全驻留在代码隐藏文件中.我想使用任何设计模式以简单和整洁的方式处理各种选择.

报告生成标准准备如下:

报告类型DropDown选项包括:

1. 方案类型
2. 方案明智
3. 区明智
4. 逐块
5. 所有

默认情况下,仅启用第一个DropDown.从此DropDown中选择一个选项,可启用相应的DropDowns.

当使用AJAX从任何DropDowns或DropDown中选择一个项目时Scheme,不仅这个,值District和BlockDropDowns也会发生变化.Scheme Type

它涉及各种SQL查询和经常启用/禁用DropDowns.我现在的代码已经成为充斥着许多IF和EndIfs.

我想知道是否使用Observer pattern或使用任何方法Classes来简化此操作.任何方式使这个多项选择和填充DropDowns易于管理和简单？

编辑如下以明确要求

让我进一步澄清.

第一个DropDown是键DropDown,默认情况下在页面打开时启用.默认情况下禁用所有其他DropDowns.但这并不意味着Cascading DropDown是正确的选择,因为来自DropDowns的孩子的选择是随机的.

整个计划是为每个DropDown以可理解的形式简化代码.根据选择,有许多Ifs和ElseIfs用于选择正确的查询.

例如:用户District-wise report从"报告类型"主DropDown中选择.在这种情况下,启用了三个子DropDowns,即.

Scheme Type

Scheme

District

如果用户从Scheme Types List中选择"ALL",则所有类别中的所有类型的方案都会在Scheme DropDown中填充.

如果用户从选项中选择特定的方案类型:Urban,Rural或Other,则Scheme DropDown会过滤方案的名称.

现在,Scheme DropDown也有一​​个ALL选项.用户可以选择ALL或选择任何特定方案.

与区相同.如果选择了ALL,则Scheme DropDown中的方案将采用所有区域中的所有方案,但如果选择了特定区域,则Scheme DropDown必须填充此区域的过滤方案.

请注意,在这种情况下,我们现在以相反的顺序移动,因为District DropDown再次过滤Scheme DropDown.

Block DropDown也是如此.

其他所选选项需要检查各种条件.假设用户没有选择任何选项或用户选择ALL.

我想用每个DropDown的名称创建单独的类.对于DropDown中的任何更改,这些类应保持听力通知(Observer).

我想我能澄清一下.

我有一个Model,其中有method_1对method_10.我也有ModelObserver.我想ModelObserver在调用method1之前注意method_9,但不是method_10.

是否有一种干燥的方式来编写它,而不是在所有9种方法中重复notify_observers(:after_something)？

我最近不得不用Java面包装一个C/C++库.其中一个方法接受函数作为参数.这基本上是Observer(aka listener)模式:

void setLogFunction(const std::function<void(std::string&, std::string&)> &callback)
{
  _callback = callback;
}

在Java端,您无法传递函数,但可以使用log()方法传递对象.

interface Observer {
  public void log(String prefix, String message);
}

class MyLibrary {
  public MyLibrary() {
    initCpp();
  }
  public native void initCpp();
  ...
  public native void setObserver(Observer observer);
}

你如何在JNI中实现setObserver()？

所以,我已经阅读了Boost.Siganl2的文档,我做了一些谷歌,我只是还没有找到我需要的东西.我所拥有的是控制器和视图概念.Controller将数据发送到View以进行渲染.我想要的是在我的控制器中调用Controller :: Update并在视图中触发OnUpdate函数.

• 控制器和视图应该是不相交的
• 可以发出控制器上的信号以执行视图中的插槽

这是我到目前为止尝试过的代码:

class Listener {
public:
    virtual void OnUpdate() {};
};

class View :Listener
{
public:
    View(void);
    ~View(void);
    virtual void OnUpdate() override;
};

void View::OnUpdate()
{
    std::cout << "Updating in View";
}

class Controller
{
public:
    Controller(void);
    ~Controller(void);
    void Update();
};

Controller::Controller(void)
{
    // Signal with no arguments and a void return value
    boost::signals2::signal<void ()> sig;
    sig.connect(boost::bind(&Listener::OnUpdate, this, _1));
    // Call all of the slots
    sig();
    system("pause");
}

这不编译.我得到错误C2825:'F':当后跟'::'时必须是一个类或命名空间,但这只是因为我正在使用绑定错误.

有人知道如何使用带升压的信号/插槽来实现我想要的功能吗？