进入快速委托通道

笨拙的委托语法

C#1中，先写好一连串事件处理程序，然后写new EventHandler。

#region 5-1
            Button button = new Button();
            button.Text = "Click me";
            button.Click += new EventHandler(LogPlainEvent);//点击触发
            button.KeyPress += new KeyPressEventHandler(LogKeyEvent);
            button.KeyPress += LogKeyEvent;//隐式转换
            button.MouseClick += new MouseEventHandler(LogMouseEvent);//鼠标单击时触发
            #endregion

 #region 5-1
        static void LogPlainEvent(object sender, EventArgs e)
        {
            MessageBox.Show("LogPlain");
 
        }
 
        static void LogKeyEvent(object sender, KeyPressEventArgs e)
        {
            MessageBox.Show("LogKey");
 
        }
 
        static void LogMouseEvent(object sender, MouseEventArgs e)
        {
            MessageBox.Show("LogMouse");
 
        }
        #endregion

方法组转换

C#2支持从方法组到一个兼容类型的隐式转换。方法组就是一个方法名，它可以添加一个目标。

协变性和逆变性

委托参数的逆变性

            Button button2 = new Button();
            button2.Click += LogPlainEvent;
            button2.KeyPress += LogPlainEvent;//转换和逆变性
            button2.MouseClick += LogPlainEvent;

        static void LogPlainEvent(object sender, EventArgs e)//处理所有事件
        {
            MessageBox.Show("LogPlain");
 
        }

委托返回类型的协变性

            #region 5-3演示委托返回类型的协变性
            StreamFactory factory = GenerateSampleData;//利用协变性转换方法组
            using (Stream stream = factory())
            {
                int data;
                while ((data = stream.ReadByte()) != -1)//调用委托以获得Stream
                {
                    Console.WriteLine(data);
                }
            }
            #endregion

#region 5-3
        static MemoryStream GenerateSampleData()//声明返回MemoryStream的方法
        {
            byte[] buffer = new byte[16];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = (byte)i;
            }
            return new MemoryStream(buffer);
        }
        #endregion

不兼容风险

 #region 5-4
    public class Derived : Snippet
    {
        public void CandidateAction(object x)
        {
            Console.WriteLine("Derived.CandidateAction");
        }
    }
    public class Snippet
    {
        public void CandidateAction(string x)
        {
            Console.WriteLine("Snippet.CandidateAction");
        }
    }
    #endregion

   #region 5-4C#1和C#2的重大变化
            Derived x = new Derived();
            SampleDelegate factory = new SampleDelegate(x.CandidateAction);
            factory("text");
            #endregion

使用匿名方法的内联委托操作

#region 5-5将匿名方法用于Action<T>委托类型
            Action<string> printReverse = delegate(string text)//使用匿名方法创建Action<string>
            {
                char[] chars = text.ToCharArray();
                Array.Reverse(chars);
                Console.WriteLine(new string(chars));
            };
 
            Action<int> printRoot = delegate(int number)
            {
                Console.WriteLine(Math.Sqrt(number));
            };
 
            Action<IList<double>> printMean = delegate(IList<double> numbers)
            {
                double total = 0;
                foreach (double value in numbers)
                {
                    total += value;
                }
                Console.WriteLine(total / numbers.Count);
            };
            printReverse("Hello world");
            printRoot(2);
            printMean(new double[] { 1.5, 2.5, 3, 4.5 });
            #endregion

逆变性不适用匿名方法：必须指定和委托类型完全匹配的参数类型。

在值类型中编写匿名方法时，不能在内部引用this，引用类型中则没有这个限制。

IL为源代码中的每个匿名方法都创建了一个方法：编译器将在已知类（匿名方法所在类）内部生成一个方法，并创建委托实例时操作

 #region 5-6代码精简的极端例子
            List<int> x = new List<int>();
            x.Add(5);
            x.ForEach(delegate(int n)
            { Console.WriteLine(Math.Sqrt(n)); }
            );
 
            x.ForEach(delegate(int n)
            { Console.WriteLine(Math.Sqrt(n)); }
            );
            #endregion

匿名方法的返回值

  #region 5-7从匿名方法返回一个值
            Predicate<int> isEven = delegate(int x) { return x % 2 == 0; };
            Console.WriteLine(isEven(1));
            #endregion

编译器只需要检查所有返回类型都兼容于委托类型声明的返回类型

 #region 5-8用匿名方法简单的排序文件
            SortAndShowFiles("Sorted by name:", delegate(FileInfo f1, FileInfo f2)
            { return f1.Name.CompareTo(f2.Name); });
 
            SortAndShowFiles("Sorted by Length:", delegate(FileInfo f1, FileInfo f2)
            { return f1.Length.CompareTo(f2.Length); });
            #endregion

 #region 5-8
        static void SortAndShowFiles(string title, Comparison<FileInfo> sortOrder)
        {
            FileInfo[] files = new DirectoryInfo(@"c:\").GetFiles();
 
            Array.Sort(files, sortOrder);
            Console.WriteLine(title);
            foreach (FileInfo file in files)
            {
                Console.WriteLine(" {0} ({1} bytes)", file.Name, file.Length);
            }
        }
        #endregion

忽略委托参数

            #region 5-9使用忽略了参数的匿名方法来订阅事件
            Button button = new Button();
            button.Text = "Click me";
            button.Click += delegate { MessageBox.Show("LogPlain"); };
            button.KeyPress += delegate { MessageBox.Show("LogKey"); };
            button.MouseClick += delegate { MessageBox.Show("LogMouse"); };
            #endregion

匿名方法中捕获变量

定义闭包和不同类型的变量

闭包：一个函数除了能通过提供给它的参数交互之外，还能痛环境进行更大程度的互动

外部变量：指作用域内包括匿名方法的局部变量或参数。在类的实例成员的匿名方法中，this引用也被认为是一个外部变量。

捕获外部变量：在匿名方法内部使用的外部变量。

 #region 5-10不同种类的变量和匿名方法的关系
        void EnclosingMethod()
        {
            int outerVariable = 5;//外部变量
            string capturedVariable = "captured";//被匿名方法捕获的外部变量
 
            if (DateTime.Now.Hour == 23)
            {
                int normalLocalVariable = DateTime.Now.Minute;//普通方法的局部变量,不是外部变量，作用域中没有匿名方法
                Console.WriteLine(normalLocalVariable);
            }
 
            MethodInvoker x = delegate()
            {
                string anonLocal = "local to anonymous method";//匿名方法的局部变量
                Console.WriteLine(capturedVariable + anonLocal);//捕获外部变量
            };
            x();
        }
        #endregion

捕获变量的行为

被匿名方法捕获到的是变量，而不是创建委托类型时该变量的值。

  #region 5-11从匿名方法内外访问一个变量
            string captured = "before x is created";
            MethodInvoker x = delegate//创建委托实例不会导致执行
            {
                MessageBox.Show(captured);//directly before x is invoked
                captured = "changed by x";
            };
 
            captured = "directly before x is invoked";
            x();//changed by x
 
            MessageBox.Show(captured);
 
            captured = "defore second invocation";
            x();//defore second invocation
            #endregion

捕获变量的用处

能简化避免专门创建一些类来储存一个委托需要处理的信息

捕获变量的延长生存期

 #region 5-12
        static MethodInvoker CreateDelegateInstance()//拥有对该类的一个实例引用
        {
            int counter = 5;
            MethodInvoker ret = delegate//拥有对该类的一个实例引用
            {
                MessageBox.Show(Convert.ToString(counter));
                counter++;//用一个额外的类来捕获变量,捕获变量的实例
            };
            ret();
            return ret;
        }
        #endregion

 
            #region 5-12捕获变量的生存期延长
            MethodInvoker x = CreateDelegateInstance();
            x();
            x();
            #endregion

局部变量实例化

#region 5-13使用多个委托来捕捉多个变量实例
            List<MethodInvoker> list = new List<MethodInvoker>();
 
            for (int index = 0; index < 5; index++)
            {
                int counter = index * 10;//实例化counter
                list.Add(delegate//创建5个委托实例
                {
                    MessageBox.Show(Convert.ToString(counter));//直接打印index * 10结果都为50，初始化变量只被实例化一次
                    counter++;
                }
                );
            }
 
            foreach (MethodInvoker t in list)
            {
                t();//执行5个委托实例
 
            }
            list[0]();//1
            list[0]();//2
            list[0]();//3
 
            list[1]();//11
            #endregion

共享和非共享的变量混合使用。

生成一个额外类，它包含外部变量，还生成另一个额外类，它包含内部变量和对第一个额外类的引用。根本上，包含一个捕获变量的每个作用域都有它自己的类型。

posted on 2016-01-29 15:44 Mr.Tan& 阅读(202) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Tan_Sir

进入快速委托通道

导航

公告