C#委托和事件

C#委托，我看了很长时间的资料和帖子，

以前对委托的理解就是委托其实就是将一个方法作为参数传递给第一个方法。

现在对委托的认识则变了一些的，委托可以实现：

                    1.在两个不能直接调用的方法之间做为桥梁

                    2.当不知具体实现什么的时候适用委托（如事件）

使用一个委托时，需要两个步骤：

1.定义一个委托，就像是定义一个类一样；

2.实例化一个或多个该委托。

3.为委托注册方法。

在定义委托的时候，往往会在某类的外部创建，并且是public（相当于全局变量，因为声明委托的目的就是为了把它暴露在类的客户端进行方法的注册,如果是private，客户端对它根本不可见，就无用了）

下面用实例来讲一下委托的使用

第一个实例：
场景是这样的：1.我叫朋友和朋友的女朋友出来玩  2.我叫朋友出来玩，再带上她女朋友
这个场景（我们看第二种）里我没有权限叫朋友的女朋友出来玩！！！（你懂的），但是我们可以委托朋友让他叫他女朋友出来。
代码如下
<span style="white-space:pre">	</span>#region myOwnExmple
        public delegate void delegate_Exmple();
        public static void TestExmple() {
            Me me = new Me();
            me.Name = "richard【我的名字】";
            Friend f = new Friend();
            f.Name = "neil【我朋友的名字】";
            f.GFName = "leo【我朋友女朋友的名字】";
            //Me没有权限叫f的GF
            me.delegate2 = f.callGF;//注册方法
            me.callFriend(f);
        }

        public class Me
        {
            public delegate_Exmple delegate2;
            public string Name { get; set; }
            public void callFriend(Friend f)
            {
                Console.WriteLine(Name + "自己肯定先来了");
                Console.WriteLine(f.Name + "已经来了");
                if (delegate2 != null)
                {
                    delegate2();
                }
            }
        }
        public class Friend
        {
            public string Name { get; set; }
            public string GFName { get; set; }
            public void callGF()
            {
                Console.WriteLine(GFName + "已经来了");
            }
        }
        #endregion

第二个实例：

观察者模式（分两种：1.只用委托（在每个region内，注销的部分）2.将委托和事件结合起来）
<span style="white-space:pre">	</span>#region 观察者模式
        public delegate void delegate_Observe(int temperature);
        public static void TestObserve() {
            Heater heater = new Heater();
            #region 委托   如果使用委托，则必须将委托写在外面（类似于全局变量）
            //heater.delegate1 = new Alarm().MakeAlert;
            //heater.delegate1 += new Monitor().ShowMessage;
            //heater.Boil();
            #endregion

            #region 事件
            heater.eventTellOther += (new Alarm()).MakeAlert;//匿名委托
            heater.eventTellOther += new Monitor().ShowMessage;
            heater.Boil();//先注册方法再执行
            #endregion
        }

        //观察者模式 热水器被委托（所以要在热水器方法内添加委托）去告诉警示器和显示器去做事情
        public class Heater
        {
            public int Temperature { get; set; }

            #region 使用委托，但是需要全局变量
            //public delegate_Observe delegate1;
            #endregion

            #region 使用事件
            public delegate void TellOther(int Temperature);
            public event TellOther eventTellOther;
            #endregion
            public void Boil()
            {
                for (int i = 0; i <= 100; i++)
                {
                    Temperature = i;
                    if (Temperature % 10 == 0)
                    {
                        #region 使用委托，但是需要全局变量
                        //if (delegate1 != null)  //如果有方法注册委托变量 
                        //联想到其实这个委托定义就是一个全局变量，只有任何地方将其实例化，并且为其注册方法
                        //{
                        //    delegate1(Temperature);  //通过委托调用方法
                        //}
                        #endregion

                        #region 使用事件
                        if (eventTellOther != null)
                        {
                            eventTellOther(Temperature);
                        }
                        #endregion
                    }
                }
            }
        }

        public class Alarm
        {
            public void MakeAlert(int temperature)
            {
                Console.WriteLine("水温已经{0}度，发出呜呜呜的鸣叫声~", temperature);
            }
        }

        public class Monitor
        {
            public void ShowMessage(int temperature)
            {
                Console.WriteLine("水温已经{0}度，显示出信息", temperature);
            }
        }

        #endregion
从第一个例子我们可以稍微感觉到委托的好处。但是无奈接触后不多，不能给出更好的例子，望各位大牛指点。