Modèle de conception C# - un exemple alternatif de résumé de code du modèle d'observateur

Modèle d'abonnement-distribution, également appelé Modèle observateur, alors quel est le mécanisme de mise en œuvre de ce modèle ? Comment peut-il être utilisé concrètement dans le développement de produits ? Lorsque nous apprenons un modèle, il est préférable de ne pas l’apprendre de manière rigide, mais de transformer progressivement le pseudo-code en code réel en fonction des besoins de l’entreprise. Dessinez des images, codez et expérimentez vous-même ce mécanisme. Ce n'est qu'après l'avoir pleinement pratiqué que vous pourrez réellement l'utiliser dans le développement de produits futurs.

Après avoir écrit, dessinez le diagramme de classe :

Tout d'abord, comme vous pouvez le voir d'après le nom, vous devez d'abord vous abonner. Ensuite, après que l'expéditeur, ou l'organisateur, ait écrit quelque chose, comme une actualité sportive, les derniers points chauds, cliquez sur envoyer, et c'est tout. sera envoyé à tous ceux qui s'abonnent au programme.

On voit donc que cette relation est une relation un-à-plusieurs typique. Par exemple, on fait référence à l'organisateur, et many fait référence aux individus qui se sont abonnés à ce journal. , qui peut être supérieur à 10 Un, ou à des milliers ou des centaines. Parmi ces abonnés, l’un peut être un amateur de sport et l’autre un membre de l’administration.

On construit donc d'abord un modèle de l'organisateur :

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

Il faut aussi avoir un modèle des personnes qui souhaitent s'abonner à ces journaux :

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

Et, attention Ici, il peut y avoir plusieurs personnes abonnées au journal ! Tous créent une classe de collection de personnes qui s'abonnent à ces journaux :

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;
       }
    }

}

D'accord, nous avons l'organisateur objet étagère, l'objet abonné, l'objet de collection abonné, utilisé Gérer les abonnés. L'étagère de modèles un-à-plusieurs a été mise en place. Ensuite, nous devons implémenter les comportements respectifs de ces objets !

Nous savons que l'organisateur doit savoir à qui il doit être distribué avant de le distribuer. En plus de savoir à qui l'envoyer, l'organisateur doit aussi penser au manuscrit, c'est-à-dire après le contenu ou le thème. est terminé, envoyez ensuite le contenu ou le sujet à tous vos abonnés !

Alors comment ce comportement de l'organisateur se transforme-t-il en codes ? Sur la base de l'étagère existante, modifiez le thème de distribution

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;
}

Modèle sujet en :

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

Une fois chaque modèle d'objet et leurs comportements respectifs écrits, nous pouvons utiliser ces objets .

Tout d'abord, l'organisateur définit deux sujets,

            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 = "十九大，即将召开，请前来参会！"
            };

ajoute l'interface d'un abonné, deux types d'objets d'abonné Lorsque l'événement UpdateEvent est déclenché, le rappel est effectué. le comportement de divers abonnés après avoir reçu le sujet. Par exemple, après avoir vu le sujet selon lequel l'équipe nationale de football joue un match ce soir, Hao Haidong regardera le match.

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)
        {

        }
}

Puis ajoutez 2 abonnés

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

Déterminez le comportement des abonnés après l'envoi de l'organisateur. Ici, on adopte la méthode d'inscription d'abord, puis d'envoi du sujet, et. puis rappelant pour déclencher le comportement de l'abonné :

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

L'organisateur commence à envoyer des sujets aux abonnés :

sender.Notify();

De cette façon, après avoir reçu le message envoyé par l'organisateur, l'abonné appelle retournez leur méthode WillDo, afin que tout le processus d'abonnement-distribution-rappel soit fermé ! ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!