当前位置：文江博客话题详情

C# 观察者模式：仍然紧密相连？

发布于 2024-09-25 12:28:38 字数 305 浏览 2 评论 0原文

好吧，所以我在这里陷入了观察者模式，我读过的几乎所有教程都告诉主题类订阅观察者。

但考虑到封装，这怎么会不紧密耦合呢？他们仍然互相依赖，不是吗？

我的意思是说，主体类必须知道观察者对象才能将其添加到要通知的对象列表中。

因此创建了依赖关系，对吗？

我犯了什么错误？

谢谢！

谢谢大家的回复，

现在我有一些新问题。如果我理解正确的话，处理这个问题的最佳方法是使用接口。所以我会这样做；）

但是，为什么总是谈论代表和事件？事件是代表的一种形式。那么他们为什么不只说事件呢？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

羁拥 2024-10-02 12:28:38

当你说“知道”时，你是对的，发布者必须了解观察者才能向其发布信息。

然而，它不需要“知道”它，因为它是硬编码的：

观察者总是这个特定的类
总是有这些特定的观察者可用

在其基本形式中，事件是发布者/observer 正在运行，因此您可以轻松地仅使用事件来执行此操作：

public class Observer
{
}

public class Publisher
{
    public event EventHandler SomethingHappened;
}

然后您可以让观察者处理该事件：

public class Observer
{
    public Observer(Publisher pub)
    {
        pub.SomethingHappened += Publisher_SomethingHappened;
    }

    private void Publisher_SomethingHappened(object sender, EventArgs e)
    {
    }
}

public class Publisher
{
    public event EventHandler SomethingHappened;
}

每当发布者引发此事件时，观察者都会收到通知。意识到挂钩事件的行为是“告诉”该类有关观察者的信息，但发布者没有任何有关发布者的硬编码信息，除了有人在听之外。

另一种方法是使用接口：

public class Observer : IObserver
{
    public Observer(Publisher pub)
    {
        pub.Observers.Add(this);
    }

    void IObserver.SomethingHappened()
    {
    }
}

public class Publisher
{
    public List<IObserver> Observers { get; private set; }
}

public interface IObserver
{
    void SomethingHappened();
}

同样，发布者将“知道”观察者，因为它有对观察者的引用，但同样它没有关于哪个类或有多少实例的硬编码信息。

只是警告一下：上面的代码非常有缺陷，至少您应该确保观察者在完成后与发布者“脱钩”，否则系统将出现泄漏。如果您不明白我的意思，请发表评论，我将在示例中进行编辑。

When you say "know", you're right that the publisher must know about the observer in order to publish information to it.

However, it doesn't need to "know" about it in the sense that it is hardcoded that:

The observer is always going to be this particular class
There is always going to be these particular observers available

In its basic form, events are publisher/observer in play, so you can easily do this just with events:

public class Observer
{
}

public class Publisher
{
    public event EventHandler SomethingHappened;
}

You would then make the observer handle that event:

public class Observer
{
    public Observer(Publisher pub)
    {
        pub.SomethingHappened += Publisher_SomethingHappened;
    }

    private void Publisher_SomethingHappened(object sender, EventArgs e)
    {
    }
}

public class Publisher
{
    public event EventHandler SomethingHappened;
}

Whenever this event is raised from the publisher, the observer is informed about it. Realize that the act of hooking into an event is to "tell" that class about the observer, but the publisher doesn't have any hardcoded information about the publisher, except that there is someone out there listening.

A different way would be using interfaces:

public class Observer : IObserver
{
    public Observer(Publisher pub)
    {
        pub.Observers.Add(this);
    }

    void IObserver.SomethingHappened()
    {
    }
}

public class Publisher
{
    public List<IObserver> Observers { get; private set; }
}

public interface IObserver
{
    void SomethingHappened();
}

Again, the publisher will "know" about the observer in the sense that it has a reference to it, but again it has no hardcoded information about which class or how many instances there will be.

Just a word of warning: The code above is very flawed, at a minimum you should ensure that the observer "unhooks" from the publisher when you're done, otherwise you're going to have leaks in the system. If you don't understand what I mean by that, leave a comment and I'll edit in an example.

回复收藏 0 原文