• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

C#委托（3）

原作者: [db:作者] 来自: [db:来源] 收藏 邀请


匿名方法其实是将方法定义与委托变量赋值两个步骤结合在一起

如果一个方法拥有一个委托类型的参数，则调用此方法时，可以直接将一个匿名方法作为方法实参：      


public delegate int AddDelegate(int val1,int val2);        
void Cal(AddDelegate del,int i,int j)        
{       
     label1.Text=string.Format("10+22={0}",del(i,j));        
}        
void MainFormLoad(object sender,EventArgs e)        
{        
    Cal(delegate(int i,int j){return i+j;},10,22);        
}

Lambda表达式：
Lambda在C#3.0中引入，是匿名方法的进一步简化，可以用于定义一个匿名函数，并将其传送给一个委托变量。示例代码：     


public delegate string SomeDelegateType(int arguments);        
SomeDelegateType del=arguments=>{return arguments.ToString();};        
void MainFormLoad(object sender, EventArgs e)       
 {            label1.Text=del(5);        }


委托变量赋值语句可进一步简化为：

 

SomeDelegateType del=arguments=>arguments.ToString();


Lambda表达式的两种基本格式：
(1)(input parameters)=>表达式
(2)(input parameters)=>{语句1;语句2;……}
下面是一些Lambda表达式的编写方法： 


public delegate TResult Func<TResult>();        
public delegate TResult Func<T,TResult>(T arg);        
public delegate TResult Func<T1,T2,TResult>(T1 arg1,T2 arg2);        
void MainFormLoad(object sender, EventArgs e)        
{       
     Func<string> del1=()=>"Func delegate1";     
     Func<int,string> del2=(str)=>str.ToString();        
     Func<double, double, int> del3=(d1,d2)=>{return (int)(d1+d2);};      
     StringBuilder strBuilder=new StringBuilder();    
     strBuilder.AppendLine(string.Format("Func<string>:{0}",del1()));       
     strBuilder.AppendLine(string.Format("FFunc<int 5,string>:{0}",del2(5)));        
    strBuilder.AppendLine(string.Format("Func<double 33,double 12,int>:{0}",del3(33,12)));        
    label1.Text=strBuilder.ToString();        
}


 



回调：
回调可以解决“延迟调用对象方法”问题，例如希望在某个场景或满足某些条件时菜调用此对象的方法

.NET中实现回调的典型方法：基于接口的回调、利用委托实现回调、定时回调、多线程回调

 

基于接口的回调：
先创建一个回调对象，然后创建一个控制器对象，将回调对象需要被调用的方法告诉控制器对象。控制器对象负责检查某个场景是否出现或是否满足某个条件。当此场景出现或此条件满足时，自动调用回调对象的方法。
示例代码： 

    public partial class MainForm : Form
    {
        void MainFormLoad(object sender, EventArgs e)
        {
            Controler c=new Controler(new CallBackClass());
            Timer t=new Timer();
            t.Interval=1000;
            t.Tick+= delegate { c.Begin();};
            t.Start();
        }
    }
    interface ICallBack
    {
        void Run();
    }
    class CallBackClass:ICallBack
    {
        public void Run()
        {
            MessageBox.Show(string.Format("second:{0}", DateTime.Now.Second));
        }
    }
    class Controler
    {
        private ICallBack CallBackObject=null;
        public Controler(ICallBack obj)
        {this.CallBackObject=obj;}
        public void Begin()
        {
            if(DateTime.Now.Second%3==0)
            {
                CallBackObject.Run();
            }
        }
    }
上述代码中定义了一个接口ICallBack，类CallBackClass继承了此接口并写入了Run()方法，类Controler用来定义回调实现方案，如果此时秒数是3的倍数，就触发回调对象
这是单个回调的实现例子

利用委托实现回调：
实现回调最直观的方法是使用委托，示例代码： 


 1 public delegate void ShowTimeDelegate();        
 2  class A
 3 {        
 4     public void AShowTime()     
 5     { MessageBox.Show("A:"+DateTime.Now.ToLongTimeString());}   
 6 }        
 7  class B
 8 {
 9     public static void BShowTime()        
10     {MessageBox.Show("B:"+DateTime.Now.ToLongTimeString());}   
11 }     
12  class Controler
13 {
14     private ShowTimeDelegate d;        
15     public void RegisterDelegateForCallBack(ShowTimeDelegate method)        
16     {d+=method;}       
17      public void UnregisterDelegateForCallBack(ShowTimeDelegate method)            {d-=method;}       
18      public void CallBack()      
19       {          
20       if(d!=null)        
21             d.Invoke();    
22       }   
23 }        
24 void MainFormLoad(object sender, EventArgs e)        
25 {      
26       A a=new A();      
27       Controler c=new Controler();    
28        c.RegisterDelegateForCallBack(a.AShowTime);            c.RegisterDelegateForCallBack(B.BShowTime);     
29        Timer t=new Timer();    
30         t.Interval=1000;     
31         t.Tick+= delegate {if(DateTime.Now.Second%3==0)c.CallBack(); };      
32       t.Start();    
33 }

 

定义需要回调的对象AB，Controler类用来添加删除回调对象，有一个触发方法CallBack()，当满足条件秒数为3的倍数时调用所有的回调方法d.Invoke()

定时回调：
如果需要以固定的时间间隔调用某个方法，可以利用.NET Framework提供的Timer类，它可以定时回调一个满足TimerCallBack委托要求的方法，此委托定义如下：

 

public delegate void TimerCallback(Object state);


参数Object类型的state作为回调方法的实参传递
利用System.Threading命名空间的Timer类实现定时回调

public System.Threading.Timer(TimerCallback callBack,Object state,int dueTime,int period)

callBack:要定时回调的方法
state：要传递的参数
dueTime：调用延迟
period：调用间隔

此委托定义了一个Object类型的方法参数，此参数将作为回调方法的实参传递，例子：     


static void ShowTime(Object ti)
{       
     TaskInfo obj=ti as TaskInfo;     
      obj.count++;       
     MessageBox.Show(obj.count.ToString());        
}        
class TaskInfo
{       
public int count=0;        
}       
void MainFormLoad(object sender, EventArgs e)        
{       
     TaskInfo t=new TaskInfo();       
     System.Threading.Timer timer=new System.Threading.Timer(ShowTime,t,0,1000);        
}

无须多解释，代码够简洁

多线程回调：
在多线程环境中，应用程序主线程通常都会启动一些辅助线程在后台完成特定的工作，这就带来了一个“主线程在辅助线程工作结束后如何取回其结果”的问题。这是就用到了多线程回调。
先看一个多线程回调的代码： 

        static int[] CreateIntArray()
        {
            int[] arrs=new int[10];
            Random r=new Random();
            for(int i=0;i<10;i++)
                arrs[i]=r.Next(0,100);
            return arrs;
        }
        static void ShowArray(int[] arr)
        {
            string str="";
            for(int i=0;i<10;i++)
                str+=string.Format("({0})={1}  ",i,arr[i]);
            MessageBox.Show(str);
        }
        class MyThread{
            public Func<int[]> createArr;
            public Action<int[]> showArr;
            //threading function
            public void SortArray(){
                int[] arr=createArr();
                showArr(arr);
                //sort array
                //ShowArray(arr);
            }
        }
        void MainFormLoad(object sender, EventArgs e)
        {
            MyThread t=new MainForm.MyThread();
            t.createArr=CreateIntArray;
            t.showArr=ShowArray;
            Thread thread=new Thread(t.SortArray);
            thread.Start();
   }

先定义了两个待回调的方法，然后定义了一个MyThread类，里面有两个委托和数据处理方法，作为线程处理方法，然后启动线程
MyThread方法用来查看线程处理结果，即辅助线程工作结束后应该返回的结果

作者注：MyThread类中有两个委托类型的字段用于接受外界传入的方法，然后在该线程函数SortArray中使用这两个字段。
SoryArray方法并不知道也不关心外界传入的方法，她只是简单的通过委托调用这两个方法，这正是使用“回调”的典型代码


还涉及到异步回调的问题，后面再理解吧。

做笔记的好处是可以比较细的过书上写的东西，预留了思考空间，就像上面的“回调”的典型代码，使用委托回调更方便程序改动。

下期预告：事件及事件驱动
同样取自：《.NET4.0面向对象编程漫谈 基础篇》
当然最好各取所长，同事看看MSDN、其他书上的。

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
C#ToString总结发布时间：2022-07-10
下一篇：
C#HttpWebRequesthttpclientHttpClientFactory发布时间：2022-07-10
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap