C#-Entwurfsmuster – eine alternative Beispielcode-Zusammenfassung des Beobachtermusters

Abonnement-Verteilungsmodell, auch Beobachtermodell genannt. Was ist also der Implementierungsmechanismus dieses Modells? Wie kann es praktisch in der Produktentwicklung eingesetzt werden? Wenn wir ein Muster lernen, ist es am besten, es nicht starr zu lernen. Stattdessen können wir Pseudocode basierend auf den Geschäftsanforderungen schrittweise in echten Code umwandeln. Zeichnen Sie Bilder, programmieren Sie und erleben Sie diesen Mechanismus selbst. Erst wenn Sie ihn vollständig geübt haben, können Sie ihn in der zukünftigen Produktentwicklung wirklich nutzen.

Zeichnen Sie nach dem Schreiben das Klassendiagramm:

Wie Sie am Namen erkennen können, müssen Sie sich zunächst anmelden. Nachdem der Absender oder der Organisator dann etwas geschrieben hat, z. B. eine Sportnachricht, die neuesten Hotspots, klicken Sie auf „Senden“ und los geht’s wird an alle Abonnenten des Programms verschickt.

Wir sehen also, dass es sich bei dieser Beziehung um eine typische Eins-zu-Viele-Beziehung handelt. Einer bezieht sich beispielsweise auf den Veranstalter, und viele beziehen sich auf die Personen, die diese Zeitung abonniert haben , die mehr als 10 Eins oder Tausender oder Hunderter betragen kann. Einer dieser Abonnenten kann ein Sportfan und der andere ein Beamter sein.

Daher erstellen wir zunächst ein Modell des Veranstalters:

public class Sender 
{   //主办方，此处称为消息发送者}

Wir müssen auch ein Modell der Personen haben, die diese Zeitungen abonnieren möchten:

public class Receiver 
{   //订阅报刊的人，此处称为接受者
   private string _name;   private Subject _sub;   public Receiver(string name, Subject sub)
   {       this._name = name;       this._sub = sub;    
   }
}

Und beachten Sie, dass es hier mehrere Personen geben kann, die die Zeitung abonnieren! Alle erstellen eine Sammlungsklasse von Personen, die diese Zeitungen abonnieren:

public class ReceiverCollection
{   //这个集合维护着订阅报刊的人

   //封装一个订阅人的列表
   private List<Receiver> _receivers = new List<Receiver>();   public List<Receiver> ReceiverList
   {     get
     {       return _receivers;
      }
   }    //管理订阅人:增加一个订阅人，移除一个，统计人数
    public void AddReceiver(Receiver r)
    {       this._receivers.Add(r);
    }    public void RemoveReceiver(Receiver r)
    {       if(this._receivers.Contains(r))           this._receivers.Remove(r);       else 
          throw new ArgumentException("此人未订阅此报刊");
    }    public int ReceiverCount
    {       get
       {          return _receivers.Count;
       }
    }

}

Okay, wir haben das Organizer--Objekt -Regal, das Abonnentenobjekt, das Abonnenten-Sammlungsobjekt und die verwendeten Abonnenten verwalten. Das Eins-zu-viele-Modellregal wurde eingerichtet. Als nächstes sollten wir die jeweiligen Verhaltensweisen dieser Objekte implementieren!

Wir wissen, dass der Organisator vor der Verteilung wissen muss, an wen er das Manuskript senden muss. Außerdem muss er sich Gedanken über das Manuskript machen, also nach dem Inhalt oder Thema abgeschlossen ist, senden Sie als Nächstes den Inhalt oder das Thema an alle Ihre Abonnenten!

Wie wird dieses Verhalten des Veranstalters zu Codes? Ändern Sie auf der Grundlage des vorhandenen Regals das Subjektmodell des

public class Sender 
{   //主办方，此处称为消息发送者

   //要知道分发给哪些人
   private ReceiverCollection _receColl;   public Sender(ReceiverCollection receColl)
   {     this._receColl = receColl;
   }   //主办方确定 分发主题
   public List<Subject> SendingSubjects {get; set;}   //主办方通知多个订阅人
    public void Notify()
    {       //执行更新事件
       UpdateEvent();
    }    //因此需要定义一个主办方在通知订阅人时，执行的更新事件
    //事件搭载各类订阅人在收到主题后的行为！！！
    //当事件触发时，回调搭载的各类订阅人收到主题后的行为！！！
    public delegate void MyEventHandler();    public event EventHandler UpdateEvent;
}

Verteilungsthemas wie folgt:

public class Subject
{   //主题话题
   public string Topic {get;set;}   //主题摘要
   public string SubAbstract {get;set;}   //主题内容
   public string Content {get;set;}
}

Nachdem jedes Objektmodell und sein jeweiliges Verhalten geschrieben wurden, können wir diese Objekte verwenden .

Zuerst definiert der Organisator zwei Themen,

            ReceiverCollection receColl = new ReceiverCollection();
            Sender sender = new Sender(receColl );
            Subject sportSubject = new Subject()
            {
                Topic = "Sport",
                SubAbstract = "篮球，足球，乒乓球",
                Content = "2018年俄罗斯世界杯，今天晚上国足迎来出线的关键争夺战！"
            };
            sender.SendingSubjects.Add(sportSubject);
            Subject newsSubject = new Subject()
            {
                Topic = "News",
                SubAbstract = "国内大事 国际纵横",
                Content = "十九大，即将召开，请前来参会！"
            };

fügt die Schnittstelle eines Abonnenten hinzu, und wenn das UpdateEvent-Ereignis ausgelöst wird, wird der Rückruf durchgeführt das Verhalten verschiedener Abonnenten nach Erhalt des Themas. Nachdem Hao Haidong beispielsweise das Thema gesehen hat, dass die Fußballnationalmannschaft heute Abend ein Spiel hat, wird er sich das Spiel ansehen.

public interface IResponse
{    void WillDo();   
}public class SportsReceiver:Receiver,IResponse
{   public void WillDo()
   {
      Console.WriteLine("I will watch tv tonight, good luck for gays"); 
   }  public SportsReceiver(string name, Subject subject)
            : base(name, subject)
        {

        }
}public class NewsReceiver:Receiver,IResponse
{   public void WillDo()
   {
      Console.WriteLine("I am going to Beijing to meeting"); 
   }   public NewsReceiver(string name, Subject subject)
            : base(name, subject)
        {

        }
}

Dann fügen Sie 2 Abonnenten hinzu

//添加一位体育大牛：郝海东receColl.AddReceiver(new SportReceiver("Hao Haidong", sender.newsSubjects[0]));
//添加县长：钱烈贤receColl.AddReceiver(new NewsReceiver("Qian Liexian", sender.newsSubjects[1]));

Bestimmen Sie das Verhalten der Abonnenten, nachdem der Organisator es gesendet hat. Hier übernehmen wir die Methode, zuerst zu registrieren, dann das Thema zu senden und dann Rückruf, um das Abonnentenverhalten auszulösen:

//要在此处注册订阅者看到消息后的反应foreach(var rece in receColl)
  sender.UpdateEvent += new MyEventHandler(rece.WillDo);

Der Organisator beginnt, Themen an Abonnenten zu senden:

sender.Notify();

Auf diese Weise ruft der Abonnent an, nachdem er die vom Organisator gesendete Nachricht erhalten hat ihre WillDo-Methode zurücksetzen, sodass der gesamte Abonnement-Verteilungs-Rückruf-Prozess geschlossen ist! ! !

Das obige ist der detaillierte Inhalt vonC#-Entwurfsmuster – eine alternative Beispielcode-Zusammenfassung des Beobachtermusters. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!