委托

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ConsoleApplication2
{
    delegate int Mydelegetefour<Tdeligate>(Tdeligate x, Tdeligate y);//以前习惯用T来写泛型，其实用其他字符串也行
    class 委托练习2
    {
        public static void Main()
        {
            委托练习2 w = new 委托练习2();
            int y = w.Max(w.arrint);//    一个数组，求最大值 的一般写法
            Console.WriteLine(y);
            person p1 = w.MaxPerson(w.personArr); //一个对象素组 求age的最大值 的一般写法
            Console.WriteLine(p1.Age);
            int x = w.GatMax<int>(w.arrint, w.compare);
            person px = w.GatMax<person>(w.personArr, w.Pcompare);
            /*这里很奇怪，委托是方法的容器，他限制，容纳方法，委托的签名必须满足与方法的签名一致，
            这里用到泛型委托，用泛型加以修饰的委托，也开始抽象画了，明明委托签名写着必须返回int 
              这里去返回 一个 person类  */
            Console.WriteLine(x);
            Console.WriteLine(px.Age);            
            Console.ReadKey();
        }
        int compare(int x, int y)
        {
            return x < y ? 1 : 0;
        }
        int Pcompare(person p1, person p2)
        {
            return p1.Age < p2.Age ? 1 : 0;
        }
        #region person对象比较最大 age
        person[] personArr = { new person() { Name = "a1", Age = 1 },
                               new person() { Name = "a2", Age = 12 }, 
                               new person() { Name = "a3", Age = 2 } };
        person MaxPerson(person[] ArrP)
        {
            person ptemp = ArrP[0];
            for (int j = 1; j < ArrP.Length; j++)
            {
                if (ptemp.Age < ArrP[j].Age)
                {
                    ptemp = ArrP[j];
                }
            }
            return ptemp;
        }
        #endregion
        #region int 比较最大值
        int[] arrint = { 1, 2, 5, 7, 71, 56, 4 };
        int Max(int[] arr)
        {
            int temp = arr[0];//
            for (int i = 1; i < arr.Length; i++)
            {
                if (temp < arr[i])
                {
                    temp = arr[i];//临时变量大 则换位
                }
            }
            return temp;
        }
        #endregion
        Tfan GatMax<Tfan>(Tfan[] TArr, Mydelegetefour<Tfan> M)//这才是关键 把泛型委托作为参数
        {
            Tfan f = TArr[0];
            for (int k = 1; k < TArr.Length; k++)
            {
                if (M(f, TArr[k]) == 1)
                {
                    f = TArr[k];
                }
            }
            return f;
        }
    }
    class person
    {
        #region 姓名
        string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        #endregion
        #region 年龄
        int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        #endregion
    }
}