//通知者接口
    interface Subject
    {
        void Attach(Observer observer);
        void Detach(Observer observer);
        void Notify();
        string SubjectState
        {
            get;
            set;
        }
    }

 //具体的通知者（病人名单）这只是其中一个通知的方法，也可以实现其他的方法，所有可以让此实现通知者接口
    class Roster:Subject
    {
        //病人
        private IList<Observer> observers = new List<Observer>();
        private string action;
        //增加
        public void Attach(Observer observer)    //针对抽象编程，减少了与具体类的耦合
        {
            observers.Add(observer);
        }
        //减少
        public void Detach(Observer observer)     //针对抽象编程，减少了与具体类的耦合
        {
            observers.Remove(observer);
        }
        //通知
        public void Notify()
        {
            foreach (Observer o in observers)
                o.Update();
        }
        //名单状态，看看叫到哪个名字了
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
    }

  //抽象观察者
    abstract class Observer
    {
        protected string name;
        protected Subject sub;

        public Observer (string name,Subject sub)  //抽象通知者，代替具体通知者对象
        {
            this.name = name;
            this.sub = sub;
        }
        public abstract void Update();
    }

//检查身体的病人
    class Patient:Observer
    {
        public Patient (string name,Subject sub):base(name ,sub )  //抽象通知者取代具体通知者Subject sub
        {

        }
        public override void Update()
        {
            Console.WriteLine("{0} {1}来病房进行检查！", sub.SubjectState, name);  //抽象通知者状态代替可能出现的具体通知状态，如病人名单
        }
    }

static void Main(string[] args)
        {
            //金秀贤名字通知
            Roster mingdan= new Roster();


            //等待中的金秀贤
            Patient bingren1 = new Patient("金秀贤", mingdan);


           mingdan.Attach(bingren1);


            //通知到
            mingdan.SubjectState = "金秀贤同志！";
            //发出通知
           mingdan.Notify();
        }

static void Main(string[] args)
        {
            //金秀贤名字通知
            Roster mingdan= new Roster();

            //等待中的金秀贤
            Patient bingren1 = new Patient("金秀贤", mingdan);
            //等待中的淑敏君
            Patient bingren2 = new Patient("淑敏君", mingdan);

           mingdan.Attach(bingren1);
           mingdan.Attach(bingren2);
           mingdan.Detach(bingren2);   //没有被通知到
            //通知到
            mingdan.SubjectState = "金秀贤同志！";
            //发出通知
           mingdan.Notify();
        }
    }

结果显示：

事件委托

  class Roster : Subject
    {
        //声明一事件Update，类型为委托EventHandler
        public event EventHandler Update;   //声明一“EventHandler"的委托事件，名称叫Update

        private string action;
        
        //通知
        public void Notify()
        {
            Update();
        }
        //名单状态，看看叫到哪个名字了
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
    }

 //金秀贤名字通知
            Roster mingdan = new Roster();

            //等待中的金秀贤
            PatientHeadache bingren1 = new PatientHeadache("金秀贤", mingdan);
            //等待中的淑敏君
            PatientHaveFever bingren2 = new PatientHaveFever("淑敏君", mingdan);

            mingdan.Update += new EventHandler(bingren1.IntoHeadache);
            mingdan.Update += new EventHandler(bingren2.IntoHaveFever);
            //将看“头痛的病人”和看“发烧的病人”和“分别进入病房的方法”都挂钩到“名单”的“更新”上了，也就是将量不同类的不同方法委托给名单类的“更新”了
            //通知到
            mingdan.SubjectState = "病人名单通知：";
            //发出通知
            mingdan.Notify();

实现结果：

结果出来了，委托与事件的机制几乎消除了这两个模块之间的耦合，灵活性提高了很多。如果需要增加观察者，则只需要覆盖基类抽象方法及把观察目标传递给基类。委托和事件处理事情的能力真的是令人佩服啊！