delegate_delegates - CSDN
精华内容
参与话题
  • c# delegate知识

    万次阅读 2018-08-30 11:18:29
    一、引用方法 委托是寻址方法的.NET版本。...如:delegate int ReturnIntHandler(int a,int b);//int是返回类型,a和b是引用类型,这是委托执行的方法必须满足如下格式:int method(int param1,int p...

    一、引用方法

    委托是寻址方法的.NET版本。委托是类型安全的类,它定义了返回类型和参数的类型。委托是对方法的引用,也可以对多个方法进行引用,委托可以理解为指向方法地址的指针。

    如:delegate int ReturnIntHandler(int a,int b);//int是返回类型,a和b是引用类型,这是委托执行的方法必须满足如下格式:int method(int param1,int param2);

     

    二、委托

    当要把方法传递给其它方法时,需要使用委托。委托是一种特殊类型的对象,其特殊之处在于,我们以前定义的所有对象都包含数据,而委托包含的只是一个或多个方法的地址。

     

    1、声明委托

    委托使用关键字 delegate 进行定义。

    定义委托基本上就是定义一个新类,所以可以在定义类的任何相同地方定义委托。可以在委托定义上应用常见的访问修饰符:public、private、protected等。其访问作用域也雷同于类。

     

    2、使用委托

    为了减少输入量,只需要委托实例,就可以只传递地址的名称。这称为委托推断。

    delegate int CalculateMethodInvoker(int x, int y);
        class Program
        {
            static void Main(string[] args)
            {
                //创建委托对象
                CalculateMethodInvoker calculateMethodInvoker = CalculateHelper.Sum;
                //等同于CalculateMethodInvoker calculateMethodInvoker = new CalculateMethodInvoker(CalculateHelper.Sum);//委托的实例化,指向Sum方法,其实委托也是可以定义,实例化调用的,不只是lambda表达式的调用方式
                int x = 100, y = 200;
                Console.WriteLine("x,y相加:{0}", Calculate(calculateMethodInvoker, x, y));
                calculateMethodInvoker = CalculateHelper.Multiply;
                Console.WriteLine("x,y相乘:{0}", Calculate(calculateMethodInvoker, x, y));
                Console.ReadKey();
            }
            public static int Calculate(CalculateMethodInvoker calculateMethodInvoker, int x, int y)
            {
                //return calculateMethodInvoker(x, y);
                //return calculateMethodInvoker.Invoke(x, y);//是不是当前线程都可以
                IAsyncResult result = calculateMethodInvoker.BeginInvoke(x, y, null, calculateMethodInvoker);//异步,这里只是做展示,EndInvoke类似于async中的await,这里不能实现异步效果
                return calculateMethodInvoker.EndInvoke(result);
            }
    
        }
        public class CalculateHelper
        {
            public static int Sum(int x, int y)
            {
                return x + y;
            }
            public static int Multiply(int x, int y)
            {
                return x * y;
            }
        }

     

    3、Action<T>和Func<T>委托

    除了为每个参数和返回类型定义一个新的委托类型外,还可以使用Action<T>和Func<T>委托。

    泛型Action<T>委托表示引用一个void返回类型的方法,没有泛型参数的Action类可调用没有参数的方法,如Action 等价于 delegate void mydelegate;  Action<int,int>等价于delegate void mydelegate(int param1,int param2);

    泛型Func<T>委托表示引用一个有返回值的方法,泛型的最后一个参数时Func的返回值类型,如Func<int,int,bool>,等价于delegate bool mydelegate(int param1,int param2);

     

    4、多播委托

    委托也可以包含多个方法。这种委托成为多播委托。如果调用多播委托,就可以按顺序连续调用多个方法。为此,委托的签名就必须返回void;否则,就只能得到委托调用的最后一个方法的结果。多播委托识别运算符“-”、“+”、“-=”、“+=”以从委托中增加或删除方法调用。

    如:

    class Program
        {
            static void Main(string[] args)
            {
                Action<int, int> calFunc = CalculateHelper.Sum;
                calFunc += CalculateHelper.Multiply;//多播加
                int x = 100, y = 200;
                Calculate(calFunc, x, y);
                calFunc =calFunc- CalculateHelper.Multiply;//多播减
                Calculate(calFunc, x, y);
                Console.ReadKey();
            }
            public static void Calculate(Action<int, int> calculateMethodInvoker, int x, int y)
            {
                Console.WriteLine("运行结果:");
                //calculateMethodInvoker(x, y);
                foreach (Action<int, int> item in calculateMethodInvoker.GetInvocationList())//遍历,这里需要转为为当前类型委托
                {
                    try
                    {
                        item(x, y);//执行委托指向方法
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                }
            }
        }

    如果通过委托调用的其中一个方法抛出异常,整个迭代就会停止。解决的方法是,使用Delegate类中定义的GetInvocationList()方法获取Delegate对象数组,再使用循环遍历执行,在过程中捕获异常,来继续下一次迭代。

     

    5、匿名方法

    匿名方法是用作委托的参数的一段代码。

    如:

    Action<int, int> calFunc = delegate (int i, int j)
    {
        Console.WriteLine("x,y相加:{0}", i + j);
    };

    在匿名方法中不可使用跳转语句(break、goto或continue),在匿名方法内部不能访问不安全代码,不能访问在匿名方法外部使用的ref和out参数。

     

    三、lambda表达式

    C#3.0后,可以使用lambda把实现代码赋予委托,只要有委托参数类型的地方,就可以使用lambda表达式。

    如:

    Action<int, int> calFunc = (i, j) =>
    {
        Console.WriteLine("x,y相加:{0}", i + j);
    };

     

    1、参数

    lambda表达式有几种定义参数的方式。如果只有一个参数,只写出参数名就足够了。如果除一个参数以外,需要圆括号把参数名括起来。

    例子:

    Action<int> one = i =>
    {
        //method body
    };
    Action<int, int> two = (i, j) =>
    {
        //method body
    };

     

    2、多行代码

    如果lambda表示只有一条语句,在方法块内就不需要花括号和return语句,因为编译器会隐式添加return。

    如:

    Func<int> lambdaOne = () => 0;

    如果实现代码超过一行,就需要使用return语句显式返回。

    如:

    {
        int i = 0;
        i++;
        ++i;
        return i;
    };

     

    3、闭包

    通过lambda表达式可以访问lambda表达式块外部的变量。这称为闭包。

    如:

    int param = 10;
    Action<int> lambdaSecond = (i) =>
    {
        Console.WriteLine(i + param);
    };
    lambdaSecond(3);
    Console.ReadKey();

     

    四、事件

    事件基于委托,为委托提供了一种发布/订阅机制。

    如:

    class Program
        {
            static void Main(string[] args)
            {
                AlarmClock alarmClock = new AlarmClock();
                Student zsStudent = new Student("张三");
                alarmClock.ItsGetUpClockEvent += zsStudent.ItsGetUpClock;
                alarmClock.ItsGetUpClock();
                Student lsStudent = new Student("李四");
                //WeakEventManager<AlarmClock, EventArgs>.AddHandler(alarmClock, "ItsGetUpClockEvent", lsStudent.ItsGetUpClock);
                弱事件,System.Windows,WPF中经常用到
                //alarmClock.ItsGetUpClock();
                Console.ReadKey();
            }
    
        }
        //事件发布类
        public class AlarmClock
        {
            public event EventHandler<EventArgs> ItsGetUpClockEvent;
            public void ItsGetUpClock()
            {
                Console.WriteLine("时间到,起床了!");
                ItsGetUpClockEvent?.Invoke(this, new EventArgs());//判断是否订阅事件
            }
        }
        //事件侦听类
        public class Student
        {
            public string Name { get; set; }
            public Student(string name)
            {
                this.Name = name;
            }
            public void ItsGetUpClock(object sender, EventArgs e)
            {
                Console.WriteLine("{0}关掉闹钟,起床了。", Name);
            }
        }

    事件最常用的地方是Winform和Wpf窗体中,而Invoke的经典使用场景如下(非当前线程更改窗体文本):

     private void ShowExecLog(string log)
            {
                if (this.richTextBox1.InvokeRequired)//判断是否是当前线程
                {
                    this.richTextBox1.Invoke(new ShowLogHandler(ShowLog), log);
                }
                else
                {
                    this.richTextBox1.Text += log;
                }
            }
    
            public void ShowLog(string log)
            {
                this.richTextBox1.Text += log;
            }
    
    
            public delegate void ShowLogHandler(string log);

     

    展开全文
  • c#里面委托(delegate)的讲解

    万次阅读 2018-06-23 22:16:52
    在c#里面,有的时候一些代码的实现必须用到委托,比如:线程...这时候,就需要使用到委托(delegate)。委托其实是这样的,为某些实现写一个函数,并将其赋值给委托(相当于函数指针),在使用 的时候直接通过委托名来

           在c#里面,有的时候一些代码的实现必须用到委托,比如:线程里面修改某个textBox的值,如果直接在线程里面写修改的代码,执行时候,编译器会报错,因为c#不允许这样写。还有在单独写的类里面,修改某个form里面某个控件的属性值等等,也是不被允许的。这时候,就需要使用到委托(delegate)。委托其实是这样的,为某些实现写一个函数,并将其赋值给委托(相当于函数指针),在使用 的时候直接通过委托名来调用。

    声明和定义委托分为4个步骤:


    1.声明一个委托(函数指针)

    2. 创建委托对象

    3. 创造符合委托格式的函数。(指针指向的函数)
    4. 将函数名称赋值给委托。
    下面是一个简单的例子:
    我使用vs2013新建了一个windows窗体应用程序,默认新建的窗口名字为Form1,双击窗口进入form1的代码编写页面,如图:
    接下来进行第1步+第2步:委托的声明和委托对象的定义(要写在与form1的默认构造函数并列的位置)
    然后在form1里面拖入两个控件,一个是button1,一个是label1,现在自己写一个函数reFresh(),用来修改label1的text,这就是
    第3步创造符合委托格式的函数。然后在form1_load里面进行第4步将函数名称赋值给委托。如图:
    接下来的步骤是我自己写的一个调用,我自己写了一个类dele(不知道怎么自定义写类的自行百度),内容如下:
    现在开始写button1的函数,让我们可以运行出执行完的效果;函数内容如下:
    然后就可以开心的运行了;以下是运行截图,点击button1一次,就会实现label1数据的一次自增;
    下面是我对代码的粘贴,试验的时候可以自行拷贝;
    Form1.cs:
    namespace Delegate
    {
        public partial class Form1 : Form
        {
            public delegate void RefreshLable();  //委托的声明,我取的名字是RefreshLable,返回值类型自主定义;
            public RefreshLable refL1;   //创建委托对象;
            public Form1()
            {
                InitializeComponent();
            }
            int i = 0;     //声明一个int值,用来作为文本框的值;
            public void reFresh()   //创造符合委托格式的函数。(i自增,在文本框里显示);
            {
                i++;
                label1.Text = i.ToString();
            }
            private void Form1_Load(object sender, EventArgs e)
            {
                refL1 = reFresh;  //将函数名称赋值给委托;
                dele.frm = this;  //这句是一定要写的,用来告诉编译器dele类里的对象frm指的是这个from1;
            }
            private void button1_Click(object sender, EventArgs e)
            {
                dele de = new dele();   //实例化一个dele类的对象;
                de.useDelegate();     //调用类的函数,实现委托的使用;
            }
        }
    }
    
    dele.cs
    public class dele
        {
            public static Form1 frm;    //定义一个from类的对象;
            public void useDelegate()  //写这个函数,来调用委托;
            {
                frm.Invoke(frm.refL1);    //调用委托一定得使用这种方式;
            }
        }
    

    展开全文
  • Delegate委托的使用

    2018-07-17 19:11:13
    Delegate委托的使用 委托的说明 委托(delegate)是Cocoa的一个术语,表示将一个对象的部分功能转交给另一个对象。 比如对象A希望对象B知道将要发生或已经发生某件事情,对象A可以把对象B的引用存为一个实例变量...

    Delegate委托的使用

    委托的说明

    委托(delegate)是Cocoa的一个术语,表示将一个对象的部分功能转交给另一个对象。

    比如对象A希望对象B知道将要发生或已经发生某件事情,对象A可以把对象B的引用存为一个实例变量。这个对象B称为委托。当事件发生时,它检查委托对象是否实现了与该事件相适应的方法。如果已经实现,则调用该方法。

    由于松耦合的原因,一个对象能成为多个对象的委托。某些情况下,相较于通过继承让子类实现相关的处理方法,可以有效减少代码复杂度。所以iOS中也大量的使用了委托。

    委托的实例

    //定义个协议
    protocol loadingDeleagte {
        func didLoading(text: String)
    }
    class HomeViewController: UIViewController {
    
        @IBOutlet weak var textFlied: UITextField!
    
        //2.声明一个委托代理
        var delegate: loadingDeleagte?
    
        override func viewDidLoad() {
            super.viewDidLoad()
    
        }
    
        @IBAction func backBtnClick(_ sender: AnyObject) {
    
            print("点击了")
            //3实例一个 ViewController类
            let loading = ViewController()
            //指定委托代理是 loading 的实例
            delegate = loading
            //调用委托实现的协议方法
            delegate?.didLoading(text: textFlied.text!)
        }
    
        override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    
            UIApplication.shared.keyWindow?.endEditing(true)
        }
        override func didReceiveMemoryWarning() {
            super.didReceiveMemoryWarning()
            // Dispose of any resources that can be recreated.
        }
    
    
    
    }
    import UIKit
    
    class ViewController: UIViewController {
    
    
        @IBOutlet weak var textLable: UILabel!
        @IBOutlet weak var NextBtn: UIButton!
        override func viewDidLoad() {
            super.viewDidLoad()
    
    
    
        }
    
    }
    
    //4实现LoadingDelegate协议
    extension ViewController : loadingDeleagte {
    
        func didLoading(text: String) {
    
            print(text)
    
            //值已经传过来了
    
        }
    }

    实际开发中容易遇到的问题

    • 实际开发中容易遇到的问题
      1.新建的另一个页面的的controller对象,不是要跳转的页面的controller。
      2.delegate没有设置好,导致获取不到对应controller的控件
    • 关键解决方法:
    //获取到对应页面的controller
    let secondView = self.storyboard?.instantiateViewController(withIdentifier: "second") as! addTagsViewController
            //设置secondView中的代理为当前ViewController自身
            secondView.delegate=self
            self.navigationController!.pushViewController(secondView,animated:true)

    secondView中传值回去

    if((delegate)) != nil{
                delegate?.didLoading(text: "传值回去")
                self.navigationController?.popViewController(animated: true)

    参考资料

    http://www.hangge.com/blog/cache/detail_810.html

    https://www.cnblogs.com/ningmengcao-ios/p/5952872.html

    展开全文
  • 谈C#中的Delegate

    千次阅读 2017-11-08 16:57:40
     Delegate是Dotnet1.0的时候已经存在的特性了,但由于在实际工作中一直没有机会使用Delegate这个特性,所以一直没有对它作整理。这两天,我再度翻阅了一些关于Delegate的资料,并开始正式整理这个C#中著名的特性。...

    引言

        Delegate是Dotnet1.0的时候已经存在的特性了,但由于在实际工作中一直没有机会使用Delegate这个特性,所以一直没有对它作整理。这两天,我再度翻阅了一些关于Delegate的资料,并开始正式整理这个C#中著名的特性。本文将由浅入深的谈一下Delegate这个特性。

    一.Delegate是什么?

        Delegate中文翻译为“委托”。Msdn中对Delegate的解释如下:

        C#中的委托类似于C或C++中的函数指针。使用委托使程序员可以将方法引用封装在委托对象内。然后可以将该委托对象传递给可调用所引用方法的代码,而不必在编译时知道将调用哪个方法。与C或C++中的函数指针不同,委托是面向对象、类型安全的,并且是安全的。

        如果你是第一次接触Delegate这个概念,你可能会对上面这段文字感觉不知所云,不过不要紧,你可以先把Delegate认为就是一个函数指针。

        而当你面对一个虚无的概念时,最好的应对方法就是直接看实例。下面一个简单的Delegate使用例子。

    class Program
        {
            static void OtherClassMethod(){
                Console.WriteLine("Delegate an other class's method");
            }
    
            static void Main(string[] args)
            {
                var test = new TestDelegate();
                test.delegateMethod = new TestDelegate.DelegateMethod(test.NonStaticMethod);
                test.delegateMethod += new TestDelegate.DelegateMethod(TestDelegate.StaticMethod);
                test.delegateMethod += Program.OtherClassMethod;
                test.RunDelegateMethods();
            }
        }
    
        class TestDelegate
        {
            public delegate void DelegateMethod();  //声明了一个Delegate Type
    
            public DelegateMethod delegateMethod;   //声明了一个Delegate对象
    
            public static void StaticMethod()   
            {
                Console.WriteLine("Delegate a static method");
            }
    
            public void NonStaticMethod()   
            {
                Console.WriteLine("Delegate a non-static method");
            }
    
            public void RunDelegateMethods()
            {
                if(delegateMethod != null){
                    Console.WriteLine("---------");
                    delegateMethod.Invoke();    
                       Console.WriteLine("---------");
                }
            }
        }

    上面是一个Delegate的使用例子,运行看看结果吧。下面我稍微解释一下:

    【1】public delegate void DelegateMethod();这里声明了一个Delegate的类型,名为DelegateMethod,这种Delegate类型可以搭载:返回值为void,无传入参数的函数。

    【2】public DelegateMethod delegateMethod;这里声明了一个DelegateMethod的对象(即,声明了某种Delegate类型的对象)。

    区分:DelegateMethod是类型,delegateMethod是对象。

    【3】为什么上面说Delegate可以看做是函数指针呢?看下面这段代码:

    test.delegateMethod = new TestDelegate.DelegateMethod(test.NonStaticMethod); 
    test.delegateMethod += new TestDelegate.DelegateMethod(TestDelegate.StaticMethod); 
    test.delegateMethod += Program.OtherClassMethod; 
    

    这里delegateMethod搭载了3个函数,而且可以通过调用delegateMethod.Invoke();运行被搭载的函数。这就是Delegate可以看作为函数指针的原因。上面这段代码中,delegateMethod只能搭载:返回值为void,无传入参数的函数(见:NonStaticMethod,StaticMethod,OtherClassMethod的定义),这和Delegate类型声明有关(见DelegateMethod的声明:public delegate void DelegateMethod())。

    【4】Delegate在搭载多个方法时,可以通过+=增加搭载的函数,也可以通过-=来去掉Delegate中的某个函数。

    二.Delegate和C++中函数指针的区别

        Delegate和C++中的函数指针很像,但如果深入对比,发现其实还是有区别的,区别主要有三个方面(参考Stanley B. Lippman的一篇文章)

          1) 一个 delegate对象一次可以搭载多个方法(methods),而不是一次一个。当我们唤起一个搭载了多个方法(methods)的delegate,所有方法以其“被搭载到delegate对象的顺序”被依次唤起。

          2) 一个delegate对象所搭载的方法(methods)并不需要属于同一个类别。一个delegate对象所搭载的所有方法(methods)必须具有相同的原型和形式。然而,这些方法(methods)可以即有static也有non-static,可以由一个或多个不同类别的成员组成。

          3) 一个delegate type的声明在本质上是创建了一个新的subtype instance,该 subtype 派生自 .NET library framework 的 abstract base classes Delegate 或 MulticastDelegate,它们提供一组public methods用以询访delegate对象或其搭载的方法(methods) ,与函数指针不同,委托是面向对象、类型安全并且安全的

        看完上面关于Delegate的介绍,相信大家对它也有所了解了,下面我们将进行更深入地讨论!

    三.Delegate什么时候该用?

        看完上面的介绍,你可以会有一些疑问,为什么会有Delegate?实际中什么时候会用到?什么时候应该去用? 在回答这些问题之前,大家可以先看看下面这段代码:

        class Program
        {
            static void Main(string[] args)
            {
                var car = new Car(15);
                new Alerter(car);
                car.Run(120);
            }
        }
    
        class Car
        {
            public delegate void Notify(int value);
            public event Notify notifier;
    
            private int petrol = 0;
            public int Petrol
            {
                get { return petrol; }
                set
                {
                    petrol = value;
                    if (petrol < 10)  //当petrol的值小于10时,出发警报
                    {
                        if (notifier != null)
                        {
                            notifier.Invoke(Petrol);
                        }
                    }
                }
            }
    
            public Car(int petrol)
            {
                Petrol = petrol;
            }
    
            public void Run(int speed)
            {
                int distance = 0;
                while (Petrol > 0)
                {
                    Thread.Sleep(500);
                    Petrol--;
                    distance += speed;
                    Console.WriteLine("Car is running... Distance is " + distance.ToString());
                }
            }
        }
    
        class Alerter
        {
            public Alerter(Car car)
            {
                car.notifier += new Car.Notify(NotEnoughPetrol);
            }
    
            public void NotEnoughPetrol(int value)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("You only have " + value.ToString() + " gallon petrol left!");
                Console.ResetColor();
            }
        }

    看完了上面的代码后,你可能会问:为什么不在public int Petrol中直接调用Alerter.NotEnoughPetrol呢?因为Car模块和Alerter模块本身是两个独立的子系统,如果直接调用,耦合性就会增加,这不是我们愿意看到的。

        其实以上的代码是设计模式中的观察者模式(观察者模式又称Source/Listener模式)的实现,当汽车在运行中汽油量<10时,警报器便会发出警报。在上面代码中,Delegate相当于一个存放回调函数的函数指针,使用Delegate,我们可以非常方便地实现观察者模式。而其实,在需要使用回调函数时,我们都可以考虑使用Delegate

        不知道你有没有发现在上面的代码中还有一个问题呢?

    public event Notify notifier;

    上面的代码中,我们定义了一个Event,而事实上:

    public Notify notifier;

    这样写,也完全可以满足我们的需求,这就引出了我们的另一个问题,Delegate和Event!

    四.Delegate与Event

    【1】Delegate和Event的关系

        看微软的代码时,我们会发现Delegate和Event这两个关键字经常会一起出现!究竟他们是什么关系呢?

        在Msdn中,有一段话描述Delegate和Event之间的关系,其实很简单:

            声明事件:若要在类内声明事件,首先必须声明该事件的委托类型。

    【2】Delegate和Event配合使用的效果

        看下面几幅图,这是我从一个C#的Application程序截下来的:

     

    从上图看到,在响应图形界面的操作中,我们用到了Event和Delegate,相信这也我们使用Event和Delegate最频繁的地方了。这里我还想罗嗦一下,平时需要我们自己写代码的界面事件响应函数,如:button_Click(…),其实都是回调函数,在自动生成的文件Form1.Designer.cs中,VS把事件和其对应的回调函数(即:button_Click(…)等)关联起来,当触发某事件时,对应的回调函数便会执行。

    【3】“public Notify notifier”和“public event Notify notifier”的区别

        关于这个问题,我们直接ildasm看看IL代码吧:>

    “public Notify notifier”的IL代码,如图:

     

    “public event Notify notifier”的IL代码,如图:

     

    差别其实已经很明显了,“public Notify notifier”相当于Class里面的Field,访问级别是public,而“public event Notify notifier”则相当于Property,访问级别是private!由于以上的差别,他们在某些使用上,会稍有不同,详细的可参考shensr写的《delegate vs. event》。

    五.Delegate中的Invoke与BeginInvoke方法

       简单说一下,Invoke与BeginInvoke都是执行Delegate里的搭载函数,而不同的是:Invoke是一个同步方法,BeginInvoke是一个异步方法。关于这个,有一篇文章《Invoke and BeginInvoke》,对此介绍的比较详细,这里就不多说了。

    六.小结   

        回顾一下,到底什么时候我们可能会用到Delegate:

    【1】.当我们在C#中需要类似函数指针这样东西时。

    【2】.当我们需要使用回调函数的时候。

    【3】.需要异步调用的时候。

    【4】.实现观察者模式的时候。

    【5】.处理事件响应的时候。

        以上内容均为个人看法,如果有错漏,请各位及时指出:>

        转载请说明出处,谢谢![hyddd(http://www.cnblogs.com/hyddd/)]

    参考资料

    【1】Msdn委托教程Msdn事件教程

    【2】《深入探索面向对象事件(Delegate)机制

    【3】《对.net事件的看法

    【4】《Invoke and BeginInvoke

    【5】《delegate vs. event

    【6】《C#事件(event)解析

    【7】《C# Delegate 简介

    展开全文
  • C#中delegate详解

    千次阅读 2018-06-28 11:31:21
    首先,delegate是什么?有过C语言或者C++基础的同学可以把他当做C语言和C#的函数的指针。委托(Delegate) 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。委托是一个类型安全的对象,它指向...
  • [C#-2] delegateDelegate的区别

    千次阅读 2015-05-13 17:15:03
    问题:delegateDelegate的区别 分析: 相信很多朋友开发过程中都遇到过上述疑问,为了解开这个疑问,最近查阅了不少帖子,最终在msdn的官方文档找到了答案。 下面是delegateDelegate的官方文档链接地址 ...
  • 快速理解C#高级概念(一) Delegate委托

    万次阅读 2012-12-19 17:45:55
    做.NET开发很久,最近重新温习《C#高级编程》一书。发现很多曾经似懂非懂的问题,其实也是能够慢慢钻研慢慢理解的。 所以,打算开写《C#高级编程系列》博文。...Delegate委托,在.NET中应用的非常广泛。
  • 在 C/C++ 中实现委托(delegate

    千次阅读 2019-02-05 13:18:09
    相信使用过C#语言的人们,对于委托应该是记忆深刻,委托具有很多不错的特性,但最令人感到兴奋的是它可以简化很多复杂的开发同时具有低耦合与对象闭包的特性。  委托在C/C++中可以解决最直观的就有问题,一个是...
  • C#中delegate用法(带参数)

    千次阅读 2017-10-25 19:24:15
    近期写了几个C#客户端软件,其中,上传数据时另开线程,同时要...public delegate void delegate1(string str); //方法 private void showUpdateProgress(string content) { //... rtbxUploadLog.Text += content;
  • 描述墙内的搜索不给力,最近经常使用代理翻墙搜索,然而这时不时Eclipse启动Tomcat时却时常...尝试也曾尝试按照 Eclipse 中 Tomcat启动卡100%(preparing launch delegate…) 来解决,然而这样的文章对我的情形不适用
  • 在自定义的delegate实现中注意 判断delegate有没有实现响应的@protocol方法  我们在自定义的delegate实现中,会判断delegate是否为空,然后如果不是为空,就调用相应的delegate的函数:  例如:  if...
  • 如何删除SceneDelegate

    千次阅读 2020-07-06 07:46:12
    Xcode11之后新创建的工程会多出两个文件SceneDelegate。那么我们如何让它变回之前的那样的工程呢。 一、将这两个文件删除。 会报错There is no scene delegate set. A scene delegate class must be specified to ...
  • iOS中block和delegate的区别(面试必问)

    千次阅读 2017-08-28 10:03:08
    作为非常常见,且不出不在的block和delegate,理解它们,是我们掌握iOS开发必备知识点。 1.从源头上理解和区别block和delegate delegate运行成本低,block的运行成本高。 block出栈需要将使用的数据从栈内存拷贝...
  • C#语法小知识(四)委托delegate

    千次阅读 2017-05-11 15:58:05
    delegate 是一种可用于封装命名或匿名方法的引用类型。  委托类似于 C++ 中的函数指针;但是,委托是类型安全和可靠的。  有关委托的应用,请参见委托和泛型委托。 这里我们就介绍一下委托的几种用法。
  • Eclipse 中 Tomcat启动卡100%(preparing launch delegate...)

    万次阅读 多人点赞 2016-06-24 15:50:16
    如果Win7 Eclipse tomcat启动卡在preparing launch delegate... 100%的话,很可能是代理问题,打开IE浏览器,选择 internet选项 -〉连接 -〉局域网设置 -〉选中“跳过本地地址的代理服务器”,重启tomcat就可以了。
  • iOS arc和mrc下重写set方法

    千次阅读 2014-12-03 12:50:27
    @property (nonatomic, weak/assign) id delegate; 相当于 - (void)setDelegate:(id)delegate {  if (_delegate != delegate) {  _delegate = delegate;  } } MRC下 @property (nonat
  • JS动态加载数据绑定事件-委托delegate() 方法W3C规范定义定义和用法delegate() 方法为指定的元素(属于被选元素的子元素)添加一个或多个事件处理程序,并规定当这些事件发生时运行的函数。使用 delegate() 方法的...
  • Delegate.Combine

    千次阅读 2013-08-29 11:53:48
    今天看到了Delegate.Combine静态方法,就随手测试了下。本以为只要是参数和返回类型相同的 就可以了,如下所示Delegate d3 = Delegate.Combine(newtext1(method1), newtext2(method2));结果报错, “委托必须具有...
  • UE4的delegate

    千次阅读 2015-09-05 13:06:54
    首先,UE4中的delegate和C#里边是一样的,delegate的本质是一个特殊类的对象,它可以储存(一个或多个)函数指针和payload数据(就是除了函数指针,还能存些你调用时候的额外参数)UE4中的delegate类名字中都有...
  • QML ListView以及delegate使用例子

    千次阅读 2017-01-08 12:43:46
    import QtQuick 2.4 import QtQuick.Controls 1.3 import QtQuick.Window 2.2 import QtQuick.Dialogs 1.2 Window{ visible:true width:200; height:200 ListModel{ //数据模型 id:listM
1 2 3 4 5 ... 20
收藏数 250,985
精华内容 100,394
关键字:

delegate