4委托

委托

也是一种类型，特殊类型，初始化时需要一个方法支持，委托是记录方法信息的一种类型，它保存了方法的信息，调用委托的时候就是在调用实例化委托的方法。委托本质是一个方法指针，也就是方法的指针被封装了。

自定义委托

自定义委托的定义方法：

public delegate +返回值+委托名称+(参数类型参数名);

如：

//定义一个无返无参的委托
   public delegate void HelloDelegate();//这里的委托名HelloDelegate就相当于类型的名字，和string、int其一样的作用，表示HelloDelegate这个类型

    //定义一个无返有参的委托
    delegate void HelloDelegate2(string str);

    //定义一个有返有参的委托
    delegate string HelloDelegate3(string name);

使用方法：

1，委托初始化，需要一个和委托签名一样的方法来实例化，并且只需要写方法名即可，实际上就是创建了一个HelloDelegate2类型的实例，只不过这里面装的是一个方法
如：
HelloDelegate2 helloHelloDelegate2 = new HelloDelegate2(SayHello2);
2，调用委托，调用委托其实就是调用初始化委托的那个方法
格式：委托名.Invoke(参数);
helloHelloDelegate2.Invoke("");
或者
helloHelloDelegate2("")

其它使用方法1：将委托作为一个方法的参数，实现将一个方法作为参数传递

第一步，定义委托(无参无返回值的委托)
public delegate void Del();

第二步，将委托名放在要被要被调用该委托的参数内，并在被委托的函数内调用委托即可

public static void AA(Del del)/添加委托为参数类型
{
    del();//方法内部调用该委托
}

第三步，声明一个Del()委托需要的函数类型

 public static void BB()
 {
            Console.WriteLine("hello");
  }

第四步，调用使用了委托Del为参数类型的方法AA，再传一个符合委托类型的方法即可
AA(BB);
BB为要执行的函数名，AA为需要委托为参数类型的函数，调用AA时会执行BB函数，因为AA的参数类型是委托Del的类型

也可以在AA的参数列表里多加一个参数，用于限制条件，如：

 public static void AA(Del del,int money)//使用第二个参数进行判断
{
            if (money>=100)
                del();
}

自定义泛型委托的定义方法：

作用：使委托更加通用
delegate void GetSumDelegate<T>(T a, T b);

在实例化的时候指定类型即可
GetSumDelegate<int> getSum = new GetSumDelegate<int>(Getsum);

比如：
1、定义泛型委托
public delegate void GenericDelegate<D>(D d);

2、创建一个类，在这个类里面的方法的参数里使用这个类型的委托

class Person
    {
        public void PersonRun<P>(GenericDelegate<P> genericDelegate,P p)
        {
            genericDelegate(p);
        }
    }

3、在main函数里实例化并且传入符合该委托定义的方法即可

static void Main(string[] args)
        {
            Person person = new Person();
            person.PersonRun(Run,5);
            Console.ReadKey();
        }

        public static void Run<T>(T t)
        {

            Console.WriteLine($"泛型方法别调用了");
        }

将匿名委托作为参数传递

1、定义一个无参数无返回值的委托

public delegate void DelValue();

2、在Person类的PersonRun方法里把上面定义的委托类型当作参数的类型，并且在方法里面调用传进来的委托

 public void PersonRun(DelValue delValue)
        {
            delValue.Invoke();
        }

3、一般都是定义好一个方法，

 public static void Run()
        {
            Console.WriteLine("人们在跑步");
        }

4、然后直接调用的时候传方法名即可

person.PersonRun(Run);

但是，也可以直接定义一个匿名委托，这样就不用再定义一个方法了，就像js的回调函数一样,f只不过js里面使用Function关键字，在C#里面使用delegate关键字而已

person.PersonRun(delegate () { Console.WriteLine("人们在跑步--传匿名委托"); });

或者是直接传lambda表达式
person.PersonRun(()=> { Console.WriteLine("人们在跑步--传lambda表达式"); });

多播委托

多播委托：在一个委托中加上多个方法

基本使用

1、创建一个无参无返的委托类型OrdDelegate

public delegate void OrdDelegate();

2、创建一个Person类，在该类中定义一个OrdDelegate类型的属性和一个调用该属性的方法

public class Person
    {

        public OrdDelegate ordDelegate { get; set; }

        public void PersonRun()
        {
            ordDelegate();
        }

    }

3、在program类中创建一个符合委托类型的方法

public static void Test1()
        {
            Console.WriteLine("Test1");
        }

        public static void Test2()
        {
            Console.WriteLine("Test2");
        }

        public static void Test3()
        {
            Console.WriteLine("Test3");
        }

4、在main函数中实例化person类并且给ordDelegate属性多赋值几个方法，或者减方法

Person person = new Person();
            
            //加上方法
            person.ordDelegate = Test1;
            person.ordDelegate += Test2;
            person.ordDelegate += Test3;

            //减去方法
            person.ordDelegate -= Test1;

            //调用委托
            person.PersonRun();//也可以直接用类名调用委托：person.ordDelegate();

因为减掉了Test1，所以只调用了Test2，和Test3方法，这里因为给ordDelegate属性加了几个方法，所以一次调用即可调用多个方法

事件委托

事件：事件就是相当于一个响应。
通过event关键字修饰委托类型的委托就是事件委托，事件可以在类的内部直接调用，但是无法在类的外部直接调用，在类外面只能把事件放在+=前面，然后给它赋值而已，但是不能调用，原理类似于属性，属性是用来保护字段的，一般字段都不希望被外部直接访问，同理，事件就非常类似于属性对私有字段的封装，事件本质上也是对委托的一种封装，这样能提供委托的安全性。

1、定义一个有参无返的委托EventDelegate类型

public delegate void EventDelegate(string msg);

2、创建一个Person类

public class Person
    {
        private string _userName;//字段

        public Person(string userName)//构造函数
        {
            _userName = userName;
        }

        public event EventDelegate eventDelegate;//事件委托

        public void Run()//调用事件的方法
        {
            
            eventDelegate(_userName);//调用事件，事件会自动帮我们调用委托
        }

    }

3、在main函数里面给实例化对象并且给事件赋值和调用person内部调用事件的方法

 Person person = new Person("张三");//实例化方法

            person.eventDelegate += Person_EventHandle;//给事件赋值

            person.Run();//调用person类的Run方法调用事件

Person_EventHandle方法

 private static void Person_EventHandle(string msg)
        {
            Console.WriteLine(msg);
        }

系统(预定义)委托

系统预先定义好的委托就叫系统委托

作用

简化使用委托，使用委托的时候不需要重复定义，直接使用

分类

Action:没有返回值，参数0-16个
Func：必须有返回值，参数可以0-16个,返回值为最后一个参数
Predicate：限定了返回值必须是bool类型,用于判断式的委托
Comparison：返回值数字，用于计算

Action使用

初始化格式：
Action<参数类型和个数> 委托名 = new Action<参数类型和个数>(满足委托的方法);
如：
Action<string, int> actionDelegate = new Action<string, int>(SayHello);

SayHello方法如下：

public static void SayHello(string name, int age)
        {
            Console.WriteLine("你好，我叫" + name + "我今年" + age + "岁");
        }

调用：actionDelegate.Invoke("张三",20);

Action使用实例

第一步：创建一个参数为一个委托的方法AA

public static void AA(Action<int, int, int> act)//参数为委托的方法
        {
            //执行传过来的方法，并且提供参数
            act.Invoke(1, 2, 3);
        }

第二步：为AA方法创建一个符合参数类型的方法Test

public static void Test(int a, int b, int c)
        {
            Console.WriteLine(""+a+b+c);
        }

第三步：调用
AA(Test);
也可在使用lamdba表达式写一个符合委托类型的方法调用：
AA(( a, b, c) => { Console.WriteLine(a + b + c); });

Func使用

初始化格式：在泛型里写具体参数类型和个数的时候，最后一个参数就是返回值，如果只有一个参数，那么这个参数就是返回值
Func<参数类型和个数> 委托名 = new Func<参数类型和个数>(满足委托的方法);

一初始化：有返回值有参数的类型
Func<string, bool> funcDelegate2 = new Func<string, bool>(ResultName2);，返回值类型为bool

ResultName2方法如下：

 public static bool ResultName2(string naem)
        {
            return true;
        }

二调用：
funcDelegate2.Invoke("xxx"))

初始化的时候也可以直接写一个lamdba表达式给它，如：
Func<string, bool> funcDelegate2 = new Func<string, bool>((a) => { return false; });

实现List的Find的方法

系统自带的find方法实际上循环集合，然后执行你传的lambda表达式或者符合它的委托的方法，不过注意在传递的时候返回值都是bool类型。
如：


            List<int> intList = new List<int>() { 1, 2, 3, 4 };
            int number = intList.Find(m => m == 2);

1、首先定义一个返回值为bool的泛型委托MyFindDelegate类型，方便传递方法
public delegate bool MyFindDelegate<T>(T t);

2、创建MyFind方法

 public static T MyFind<T>(List<T> list, MyFindDelegate<T> myFindDelegate)
        {
            //根据反射创建泛型的对象实例
            T t = (T)Activator.CreateInstance(typeof(T));

            //循环遍历list集合
            foreach (var item in list)
            {
                if (myFindDelegate(item))//根据传递进来的方法进行筛选，把符合条件的值赋值给t对象
                {
                    t = item;
                    break;//找到了即可跳出循环
                }
            }
            return t;

        }

3、调用即可

List<int> intList = new List<int>() { 1, 2, 3, 4 };
         
            int number = MyFind(intList,
                delegate (int i)
                {
                    return i == 2;
                }
            );//number值为2

也可以将这个MyFind方法定义为扩展方法，比较方便

实现List的FindAll的方法