Design patterns 观察员执行

我想要一个按钮，当它被按下时，一个新的字符串显示在文本框中

我做错了什么

有人能启发我吗？为什么这个代码不起作用

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public event Startdelegate StartEvent;
        myButton button;
        newTb[] tb;
        public Form1()
        {
            InitializeComponent();

            button = new myButton();
            button.Parent = this;
            button.Location = new Point(120, 0);
            button.Text = "click on me!!!";
            tb = new newTb[8];

            for (int i = 0; i <= 80; i += 15)
            {
                tb[i / 15] = new newTb();
                tb[i / 15].Parent = this;
                tb[i / 15].Location = new Point(i + i, i + i);
               // button.Subscribe(tb[i / 15]);
            }

            button.Click += new EventHandler(button_Click);

        }
        private void button_Click(object sender, EventArgs e)
        {
            button.s = "this is clicking";
            //button.Notify();
        }
    }

    public class myButton : Button, IObservable<newTb>
    {
        public string s;
        private List<IObserver<newTb>> observers;

        public myButton()
        {
            observers = new List<IObserver<newTb>>();
        }

        public IDisposable Subscribe(IObserver<newTb> observer)
        {
            if (!observers.Contains(observer))
            {
                observers.Add(observer);           
            }
            return new Unsubscriber(observers, observer);  
        }

        protected void Notify(newTb tb)
        {
            foreach (IObserver<newTb> observer in observers)
            {
                observer.OnNext(tb);
            }
        }

        #region Unsubscriber
        private class Unsubscriber : IDisposable
        {
            private List<IObserver<newTb>> observers;
            private IObserver<newTb> observer;

            public Unsubscriber(List<IObserver<newTb>> observers, IObserver<newTb> observer)
            {
                this.observers = observers;
                this.observer = observer;
            }

            public void Dispose()
            {
                if (observer != null && observers.Contains(observer))
                {
                    observers.Remove(observer);
                }
            }
        }
        #endregion 

        class newTb : TextBox, IObserver<string>
        {
            string s;
            public void OnCompleted() { }
            public void OnError(Exception error) { }
            public void OnNext(string value)
            {
                this.Text = value;
            }
        }
    }
}

命名空间窗口窗体应用程序1
{
公共部分类Form1:Form
{
公共事件开始事件；
我的按钮；
新结核[]结核；
公共表格1（）
{
初始化组件（）；
按钮=新的myButton（）；
button.Parent=this；
按钮位置=新点（120，0）；
button.Text=“点击我！！！”；
tb=新的新的B[8]；
对于（int i=0；i根据

IObserver和IObservable接口为基于推送的通知提供了通用机制，
也称为观察者设计模式。IObservable接口表示发送通知的类（提供者）；
IObserver接口表示接收它们的类（观察者）

T表示提供通知信息的类

在您的情况下，您传递的信息是一条消息（字符串）。
在您的样本中，您通过了控制newTB

声明如下：

   public class ObservableButton : Button,  IObservable<string>   {}
   public class ObserverTextBox  : TextBox, IObserver<string>     {}

public-class-observeButton:Button，IObservable{}
公共类ObserverTextBox:TextBox，IObserver{}

每件事都有规律

classObservableButton的Notify方法可以这样编写

    public void Notify(string text)
    {
        foreach (IObserver<string> observer in _Observers)
        {                
            observer.OnNext(text);
        }
    }

公共作废通知（字符串文本）
{
foreach（IObserver观察员在_观察员中）
{                
OnNext观察员（文本）；
}
}

这里是完整的源代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace ObservableDemo
{
    public class ObservableButton : Button, IObservable<string>
    {
        private List<IObserver<string>> _Observers;

        public ObservableButton()
        {
            _Observers = new List<IObserver<string>>();
        }
        IDisposable IObservable<string>.Subscribe(IObserver<string> observer)
        {
            if (!_Observers.Contains(observer))
            {
                _Observers.Add(observer);
            }
            return new Unsubscriber(_Observers, observer);
        }
        public void Notify(string text)
        {
            foreach (IObserver<string> observer in _Observers)
            {                
                observer.OnNext(text);
            }
        }
        private class Unsubscriber : IDisposable
        {
            private List<IObserver<string>>     observers;
            private IObserver<string>           observer;

            public Unsubscriber(List<IObserver<string>> observers, IObserver<string> observer)
            {
                this.observers = observers;
                this.observer  = observer;
            }
            public void Dispose()
            {
                if (observer != null && observers.Contains(observer))
                {
                    observers.Remove(observer);
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace ObservableDemo
{    
    public class ObserverTextBox : TextBox,  IObserver<string>
    {
        private IDisposable unsubscriber;

        void IObserver<string>.OnCompleted()
        {
        }
        void IObserver<string>.OnError(Exception error)
        {

        }
        void IObserver<string>.OnNext(string value)
        {
            this.Text = value;
            this.Refresh();
        }
        public virtual void Subscribe(IObservable<string> provider)
        {
            if (provider != null)
                unsubscriber = provider.Subscribe(this);
        }
        public virtual void Unsubscribe()
        {
            unsubscriber.Dispose();
        }
    }    
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace ObservableDemo
{
    public partial class Form1 : Form
    {
        ObservableButton button;

        public Form1()
        {
            InitializeComponent();

            button          = new ObservableButton();
            button.Parent   = this;
            button.Location = new Point(120, 0);
            button.Text     = "click on me!!!";
            button.Click   += new EventHandler(button_Click);

            for (int i = 0; i < 8; i++)
            {
                ObserverTextBox tb  = new ObserverTextBox();
                tb.Parent           = this;
                tb.Location         = new Point(0 , 30+(i*30));
                tb.Width            = 300;
                tb.Subscribe(button);
            }
        }
        private void button_Click(object sender, EventArgs e)
        {
            button.Notify(String.Format("{0} this is the message", DateTime.Now));
        }
        void Form1_Load(object sender, System.EventArgs e)
        {
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用系统组件模型；
使用系统数据；
使用系统图；
使用System.Linq；
使用系统文本；
使用System.Windows.Forms；
命名空间可观察对象
{
公共类可观察按钮：按钮，IObservable
{
私人名单(观察员),；
公共可观察按钮（）
{
_观察员=新名单（）；
}
IDisposable IObservable.Subscribe（IObserver-observer）
{
如果（！\u observer.Contains（observer））
{
_添加观察员（观察员）；
}
返回新的退订者（_observators，observator）；
}
公共作废通知（字符串文本）
{
foreach（IObserver观察员在_观察员中）
{                
OnNext观察员（文本）；
}
}
私人类取消订阅者：IDisposable
{
非公开名单观察员；
私有IObserver-observer；
公共取消订阅者（列表观察员、IObserver观察员）
{
这个。观察员=观察员；
this.observer=观察者；
}
公共空间处置（）
{
if（observer！=null&&observer.Contains（observer））
{
观察员。移除（观察员）；
}
}
}
}
}
使用制度；
使用System.Collections.Generic；
使用系统组件模型；
使用系统数据；
使用系统图；
使用System.Linq；
使用系统文本；
使用System.Windows.Forms；
命名空间可观察对象
{    
公共类observer文本框：文本框，IObserver
{
私人IDisposable退订者；
void IObserver.OnCompleted（）
{
}
void IObserver.OnError（异常错误）
{
}
void IObserver.OnNext（字符串值）
{
这个.Text=值；
这个。刷新（）；
}
公共虚拟空订阅（IObservable提供程序）
{
if（提供程序！=null）
unsubscriber=provider.Subscribe（此）；
}
公共虚拟无效取消订阅（）
{
Dispose（）；
}
}    
}
使用制度；
使用System.Collections.Generic；
使用系统组件模型；
使用系统数据；
使用系统图；
使用System.Linq；
使用系统文本；
使用System.Windows.Forms；
命名空间可观察对象
{
公共部分类Form1:Form
{
可观察按钮；
公共表格1（）
{
初始化组件（）；
按钮=新的可观察按钮（）；
button.Parent=this；
按钮位置=新点（120，0）；
button.Text=“点击我！！！”；
单击+=新建事件处理程序（单击按钮）；
对于（int i=0；i<8；i++）
{
observertextb=新的ObserverTextBox（）；
tb.Parent=this；
tb.位置=新点（0,30+（i*30））；
tb.宽度=300；
订阅（按钮）；
}
}
私有无效按钮\u单击（对象发送者，事件参数e）
{
Notify（String.Format（“{0}这是消息”，DateTime.Now））；
}
void Form1\u加载（对象发送方，System.EventArgs e）
{
}
}
}
我相信这可能是您的问题：

class newTb : TextBox, IObserver<string>

class newTb:TextBox，IObserver

因为根据这个样本，你想要观察的是：

observers = new List<IObserver<newTb>>();

observer=新列表（）；

实际上是IObserver，它的类型与IObserver不同。您的newTb类没有实现第一个接口，它只实现后者。不确定为什么要编译（如果它实现了），不过。
谢谢你，它能帮我解释一些事实吗？我不明白我哪里弄错了。事实上，我对IObserver/IObservable模式也有一个问题。今晚我将尝试从头开始写你的问题。我可能会用这段时间回答一些有意义的+1，这样你就可以获得一些分数来开启另一个悬赏：-）如果答案是正确的，那么你应该标记q