精华内容
下载资源
问答
  • 委托delegate

    2018-10-23 22:21:00
    委托delegate没有函数体。委托可以指向函数(要与指向的函数格式、类型相一致) namespace demo { public delegate double MyDelegate(double a1, double a2); class Program { static double Multiply...

    委托delegate没有函数体。委托可以指向函数(要与指向的函数格式、类型相一致)

    namespace demo
    {
        public delegate double MyDelegate(double a1, double a2);
        class Program
        {
            static double Multiply(double a1, double a2){//乘法
                return a1 * a2;
            }
            static double Add(double a1, double a2){//加法
                return a1 + a2;
            }
            public static void Main(string[] args)
            {
                MyDelegate de;//定义委托变量
                de = Multiply;//指向Multiply函数(都为double类型、都有2个参数)
                Console.WriteLine(de(2.0, 3.0));//赋值并输出
                de = Add;
                Console.WriteLine(de(2.0, 4.0));
                Console.ReadKey();
            }
        }
    }

     

    转载于:https://www.cnblogs.com/xixixing/p/9839844.html

    展开全文
  • 委托 delegate

    2014-01-07 23:02:18
    定义: 委托就像是函数指针。 定义一个委托 = 定义一个新类。...用delegate开头,上面表示定义了一个委托twoLongOp,它带有两个参数first和second和一个double的返回值。 泛型委托,Action 用于没有返回类型的。

    定义:

    委托就像是函数指针。

    定义一个委托 = 定义一个新类。


    delegate double twoLongOp(long first, long second);

    用delegate开头,上面表示定义了一个委托twoLongOp,它带有两个参数first和second和一个double的返回值。


    泛型委托,Action<T1, T2, .........T16> 用于没有返回类型的。

                        Func<T1, T2, .........T16, TResult> 用于有返回类型的,返回值为TResult。

    Func<(long , long, double>twoLongOp; 定义了一个委托变量twoLongOp,它带有两个long型的参数和一个 double型的返回值。

    注意twoLongOp是一个变量,不能用它去实例化对象。


    使用:

    将委托传递给方法;

    委托数组;

    class Program
        {
            delegate double twoLongOp(long first, long second);
            static double funcPlus(long first, long second)
            {
                return first + second;
            }
            static double funcChen(long first, long second)
            {
                return first * second;
            }
            static void Main(string[] args)
            {
                twoLongOp[] FuncList = { funcPlus, funcChen};
                /*twoLongOp[] FuncList = new twoLongOp[2];
                FuncList[0] = funcPlus;
                FuncList[1] = funcChen;
                 这样当然也是可以的*/
                foreach(twoLongOp aFunc in FuncList)
                {
                    Console.WriteLine(aFunc(4,4));
                }
                //委托泛型
                Func<long, long, double>[] FuncList2 = { funcChen , funcPlus};
                foreach (Func<long, long, double>aFunc in FuncList2)
                {
                    Console.WriteLine(aFunc(5, 5));
                }
                Console.ReadKey();
           
    输出:

    8

    16

    25

    10


    展开全文
  • C#委托delegate实例解析

    2020-09-04 07:27:08
    主要介绍了C#委托delegate实例解析,对C#的委托做了较为深入的剖析,很适合初学者学习,需要的朋友可以参考下
  • C#委托delegate

    2020-05-31 00:15:07
    1.委托最最最基本用法 1.首先应该知道什么是委托。一句话很抽象的话:我委托...委托 delegate int 委托名(int a, string b) 所委托的函数必须是 int 函数名(int a, string b) 这样形式的函数 namespace CSharpTest

    1.委托最最最基本用法

    1.首先应该知道什么是委托。一句话很抽象的话:我委托中介去买房。因为我不是特别会看房,所以要委托别人帮我。(委托其实是面向对象23种设计模式中的一种叫委托模式)看不懂没关系看代码
    2.声明一个委托 注意:委托是和类同级别的。
    (我这里声明了两个)
    3.被委托的函数必须和委托标签一致;
    委托 delegate int 委托名(int a, string b)
    所委托的函数必须是 int 函数名(int a, string b) 这样形式的函数

    namespace CSharpTest
    {
        //无参数无返回值的委托
        public delegate void NoArgsDelegate();
        //有返回值的委托
        public delegate int HavrArgsDelegate();
    
    }
    

    3.我声明一个委托对象(中介)

    NoArgsDelegate Say;//这样我就得到了一个名为Say的委托对象(通俗讲叫中介)
    

    4.定义两个静态函数

    public static void SayWang()
    {
        Console.WriteLine("汪汪");
    }
    public static void SayMiao()
    {
        Console.WriteLine("喵~~");
    }
    

    5.通过各种方式向委托对象添加函数并通过委托对象(中介)调用函数(仔细看)

    			#region delegate
    			//定义一个无参委托对象
    			//1.通过构造函数的方式向委托添加函数
    			//NoArgsDelegate Say = new NoArgsDelegate(SayWang);
    			//2.通赋值的方式为委托添加函数  只能添加静态函数
    			NoArgsDelegate Say = SayWang;
    			Say += SayMiao;
    			Console.WriteLine("-----添加函数后");
    			Say();
    			//3.通过-=删除委托中的函数
    			Console.WriteLine("-----删除一个函数后");
    			Say -= SayWang;
    			Say();
    			//4.委托添加匿名函数
    			Say += delegate ()
    			{
    			    Console.WriteLine("我是匿名函数");
    			};
    			Console.WriteLine("-----添加匿名函数后");
    			Say();
    			//5.委托通过lambda表达式添加函数
    			Say += () =>
    			{
    			    Console.WriteLine("我是lambda表达式");
    			};
    			Console.WriteLine("-----通过lambda表达式添加函数后");
    			Say();
    			#endregion
    

    运行结果
    运行结果

    2.带返回值委托的返回值测试

    1.声明一个带返回值的委托对象并添加两个函数

     		HavrArgsDelegate havrArgs = GetNum1;
            havrArgs += GetNum2;
            Console.WriteLine(havrArgs());
            //上面代码是构造函数里面的
            public static int GetNum1()
            {
                return 1;
            }
            public static int GetNum2()
            {
                return 2;
            }
    

    运行结果
    运行结果
    答案:带返回值的委托会返回最后一个被添加的函数的返回值

    3. .net framework自带的两个委托

    第一个:Action action; 无参数无返回值
    第二个:Func<int,int,string> func; 泛型里面最后一个参数是返回值类型,前面的是参数列表中类型。

    展开全文
  • c# 委托 delegate

    2018-12-02 23:17:39
    委托是一种存储函数引用的类型,在事件和事件的处理时有重要的用途 通俗的说,委托是一个可以引用方法的类型,当创建一个委托,也就...delegate double ParocessDelegate(double param1,double param2); 委托的定...

    委托是一种存储函数引用的类型,在事件和事件的处理时有重要的用途

    通俗的说,委托是一个可以引用方法的类型,当创建一个委托,也就创建一个引用方法的变量,进而就可以调用那个方法,即委托可以调用它所指的方法。

     

    1. 使用委托

    委托的使用需要以下步骤:

    定义委托

    delegate double ParocessDelegate(double param1,double param2);

    委托的定义非常类似于函数,但不带函数体,且要使用delegate关键字。委托定义需要指明委托名称以及一个返回类型和一个参数列表

     

    声明委托类型的变量

    ProcessDelegate process;

    定义了委托后,就可以声明一个该委托类型的变量

     

    初始化委托变量

    process =new ProcessDelegate(Multiply);

    初始化委托变量时要把一个函数(此处Multiply为一个函数的名称)引用赋给委托变量,此函数需要具有与委托相同的返回类型和参数列表。c#使用上述略显古怪的语法,使用new关键字创建一个新的委托,参数为
    要引用所需的函数,这是委托赋值的一个独特语法,函数名称是不带括号的

    还可以用另一种略微简单的语法

    process = Muiltiply;

     

    有了引用函数的委托变量之后,我们就可以用委托变量调用Muiltiply函数;也可以把委托变量传递给其他函数

    process (param1,param2);

     

    示例:

    namespace Delegate
    {
    
            public delegate int Call(int num1, int num2);//第一步:定义委托类型
            class SimpleMath
            {
                // 乘法方法
                public int Multiply(int num1, int num2)
                {
                    return num1 * num2;
                }
    
                // 除法方法
                public int Divide(int num1, int num2)
                {
                    return num1 / num2;
                }
            }
        }
        class Test
        {
            static void Main(string[] args)
            {
                Call objCall;//第二步:声明委托变量
                // Math 类的对象
                SimpleMath objMath = new SimpleMath(); 
                // 第三步:初始化委托变量,将方法与委托关联起来
                objCall = new Call(objMath.Multiply);
    
               
                objCall += objMath.Divide;//向委托增加一个方法
                //objCall -=  objMath.Divide;//向委托减去一个方法
    
                // 调用委托实例,先执行objMath.Multiply,然后执行objMath.Divide
                int result = objCall(5, 3);
                System.Console.WriteLine("结果为 {0}", result);
                Console.ReadKey();
            }
        }

    注意事项:

    • 委托可以调用多个方法,即一个委托变量可以引用多个函数,称为多路广播
    • 可以使用+=和-=运算符实现方法的增加和减少
    • 无返回值的委托,引用了多少个方法就会执行多少个方法。有返回值的委托同样会执行多个引用的方法,但返回的值是最后一个方法的返回值

     

     

      2.  其他形式的委托

    • 匿名委托

    匿名委托使用起来更简洁一点,不用在定义一个专用的委托函数来传递方法,也更可以更好的理解委托

     

      //定义委托
        delegate string lookMe(string s);
    
        protected void LinkButton1_Click(object sender, EventArgs e)
        {
            //匿名委托
            lookMe lm = delegate(string name) { return "亲爱的 " + name + ",请看着我的眼睛!"; };
    
            //匿名委托调用
            string name1 = "jarod";
            Label1.Text = lm(name1);
        }

     

    • 泛型委托

    Action<>,Func<>,Predicate<> 其实他们都是委托代理的简写形式,通过他们可以省去定义委托的步骤

    示例

    public static void HellowChinese(string strChinese)  
    {  
        Console.WriteLine("Good morning," + strChinese);  
        Console.ReadLine();  
    }  
      
    Action<string> action = HellowChinese;  
    action("Spring.");  

    其中Action是无返回值的泛型委托,Func是有返回值的泛型委托,Predicate<>是返回bool类型的委托,他们都有多个参数的重载版本

     

     

       3.  委托的各种写法

    public delegate int DelegateProcess(int num1, int num2);
    
    //第一种写法
    DelegateProcess process= new DelegateProcess(Multiply);
    
    //第二种写法
    DelegateProcess process= Multiply;
    
    //第三种写法  匿名委托
    DelegateProcess process= delegate(int a,int b)
    {
       return a*b;
    }
    
    //第四种写法 Lamdba表达式
    DelegateProcess process =((int a,int b)=>{return a*b;});
    
    //第五种写法 Action<T>和Func<T>
    Action<int,int> process= ((int a,int b)=>{Console.WriteLine(a * b);});
    Func<int,int,int> process= ((int a,int b)=>{return a*b;});
    展开全文
  • C#委托Delegate教程案例

    2021-01-03 07:21:18
    namespace 委托Delegate { class Program { /*委托Delegate 目的:为了实现方法参数化 语法:[修饰符] delegate [返回类型] [委托名称] ([参数列表]) 定义:委托是一种引用方法类型(即委托是方法的引用) */ ...
  • 但是.Net毕竟是更高级的语言,委托Delegate也更高级了,委托是一种数据接口,它包含调用目标和调用方法的指针;而在.Net中定义的委托都继承自MulticastDelegate即多播委托,所谓的多播委托是指可以包含多个调用方法...
  • 委托delegate使用方法

    2016-01-10 11:22:00
    委托delegate使用方法 允许传递一个类A的方法m给另一个类B的对象,使得类B的对象能够调用这个方法m,说白了就是可以把方法当作参数传递。 class Program { //delegate的使用方法一 public ...
  • C# 委托Delegate

    2017-08-01 11:07:00
    委托 C# 中的委托Delegate)类似于 C 或 C++ 中函数的指针。...所有的委托Delegate)都派生自 System.Delegate 类。 声明委托Delegate委托声明决定了可由该委托引用的方法。委托可指向...
  • 委托 delegatedelegate是C#中的一种类型,它实际上是一个能够持有对某个方法的引用的类。与其它的类不同,delegate类能够拥有一个签名(signature),并且它”只能持有与它的签名相匹配的方法的引用”。它所实现的...
  • using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 ... delegate int Fun(int x);//声明委托 delegate+typename+name(typename); class Pr...
  • 如下的资料是关于C#委托delegate使用范例的代码。 using System; using System.Collections.Generic; using System.Text; namespace Delegate { public delegate void MyDelegate(string name); class ...
  • C#的委托Delegate

    2020-01-10 17:32:51
     委托Delegate)是存有对某个方法的引用的一种引用类型变量,用关键字delegate申明,实现相同返回值和参数的函数的动态调用,提供了对方法的抽象。  委托Delegate)特别用于实现事件和回调方法。所有的委托...
  • c#委托delegate

    2020-06-19 16:50:23
    委托是一种数据类型,想类一样的一种数据类型,一般都是直接在命名空间中定义 public delegate void MyDelegate(); MyDelegate md = Method; md(); public static void Method() { .... } 匿名方法 public...
  • C# 委托 delegate

    2019-02-15 14:54:00
    什么是委托委托是一种引用类型,是安全封装方法的类型,类似C语音中的指针。与指针不同的是,委托是面向对象,类型安全的和可靠的。 使用delegate关键字修饰。 委托可以作为方法的参数传递。 以下委托可以...
  • IOS开发使用委托delegate在不同窗口之间传递数据是本文要介绍的内容,主要是来讲解如何使用委托delegate在不同窗口之间传递数据,具体内容来看详细内容。在IOS开发里两个UIView窗口之间传递参数方法
  • Unity 项目中委托Delegate用法案例

    千次阅读 2018-05-21 00:00:19
    Unity 项目中委托Delegate用法案例 Unity中Delegate的用法场景 Chinar - 本文提供全流程,中文翻译。助力快速理解 C# Delegate的基本用法 Unity 中,委托多用于当某个值,或者物体状态发生改变的时候 其他一些操作...
  • 委托delegate是一种依赖倒置的调用机制 假设我们有两个对象a和b,如果对象a需要调用对象b的一个函数func,那么对象a就需要取得对象b的引用,才能调用到对象b的函数func。也可以说成是,对象a提供了逻辑运行的时机...
  • 1.委托delegate一般表达式:delegate return-Type delegateName (parameters) eg: //1.declare a delegate public delegate Tranform(int x); public static int Square(int x) {return x*x}; //2.instaniated ...
  • C# -- 使用委托 delegate 执行异步操作 委托是一种安全地封装方法的类型,它与 C 和 C++ 中的函数指针类似。 与 C 中的函数指针不同,委托是面向对象的、类型安全的和保险的。 委托的类型由委托的名称定义。 1. ...
  • 委托Delegate使用帮助

    2011-12-26 10:24:55
    using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 委托Delegate { class Program { static void Main(string[] args) { //4,
  • c# .net 委托delegate

    2020-04-21 22:08:22
    1 委托的声明、实例化和调用 2 委托的意义:解耦 3 泛型委托--Func Action 委托也是无处不在 Func Action 异步多线程 事件 如果需要定义委托 就用Func Action Framework1.0 ----4.7 Core到处都是委托 一、...
  • C#中的委托 Delegate(委托 也叫代表,代表一类方法) 转载自: [link]:https://www.cnblogs.com/tommy-huang/p/4828589.html 1. 委托类似与 C或C++中的函数指针,但委托是 面向对象的,并且是类型安全的 详情可查看...
  • C#委托Delegate

    2016-10-28 11:23:06
    委托类型用于定义一个System.Delegate类派生的类,功能与C++中指向函数的指针功能类似,不过委托既可以指向静态方法也可以指向实例的方法。 它的最大特点是:任何类或对象中的方法都可以通过委托来调用,唯一的要求...
  • C#委托Delegate委托Delegate)是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。 委托Delegate)特别用于实现事件和回调方法。所有的委托Delegate)都派生自System.Delegate类。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,625
精华内容 4,650
关键字:

委托delegate