泛型委托Predicate

此委托返回一个bool值，该委托通常引用一个"判断条件函数"。

需要指出的是，判断条件一般为“外部的硬性条件”,比如“大于50”，而不是由数据自身指定，不如“查找数组中最大的元素就不适合”。

 

例子一：

class Program
    {
        bool IsGreaterThan50(int i)
        {
            if (i > 50)
                return true;
            else
                return false;
        }

 

        static void Main(string[] args)
        {
            Program p=new Program();

            List<int> lstInt = new List<int>();
            lstInt.Add(50);
            lstInt.Add(80);
            lstInt.Add(90);

            Predicate<int> pred = p.IsGreaterThan50;
           
            int i = lstInt.Find(pred);                         // 找到匹配的第一个元素，此处为80
            Console.WriteLine("大于50的第一个元素为{0}",i);

           

            List<int> all = lstInt.FindAll(pred);
            for (int j = 0; j < all.Count(); j++)
            {
                Console.WriteLine("大于50的数组中元素为{0}", all[j]);  // 找出所有匹配条件的
            }

            Console.ReadLine();
        }
    }

 

例子二:

class Staff
    {
        private double salary;

        public double Salary
        {
            get { return salary; }
            set { salary = value; }
        }

        private string num;

        public string Num
        {
            get { return num; }
            set { num = value; }
        }

        public override string ToString()
        {
            return "Num......" + num + "......" + "......" + "Salary......" + salary;
        }
    }

 

class Program
    {
        bool IsSalaryGreaterThan5000(Staff s)
        {
            if (s.Salary > 5000)
                return true;
            else
                return false;
        }

        static void Main(string[] args)
        {
            Program p = new Program();

            List<Staff> allStaff = new List<Staff>
            {
                new Staff{Num="001",Salary=9999.9},
                new Staff{Num="002",Salary=8991},
                new Staff{Num="003",Salary=10000.8},
                new Staff{Num="004",Salary=4999.99}
            };

 

            Predicate<Staff> s = p.IsSalaryGreaterThan5000;

            Staff theFirstOne = allStaff.Find(s);
            Console.WriteLine(theFirstOne);              // 找出第一个

           

            List<Staff> all = allStaff.FindAll(s);
            for (int i = 0; i < all.Count(); i++)
            {
                Console.WriteLine(all[i]);               // 找出所有满足条件的
            }

            Console.ReadLine();
        }
    }

 

自定义泛型委托

在看泛型委托之前还需要先了解委托的概念。
这里讲的委托有两种类型一种是有返回值的，另一种是事件委托。

    //定义有返回值的委托 
    public delegate string GenricDelegate<T, S>(T title, S author);

    //定义事件委托。
    public delegate void GenricDelegateEnent<E,P>(E Name,P Address);

    public class GenericDelegateClass<V,F>
    {
        //声明委托
        public GenricDelegate<V, F> GdeleValue;
        //声明事件委托
        public event GenricDelegateEnent<V, F> GdEvent = null;

        public string GetValues(V title, F author)
        {
            //调用委托
            return GdeleValue(title, author);
         }

        public GenericDelegateClass()
        {
         }

        public void InvokeEvent(V name, F address)
        {
            if (GdEvent != null)
            {
                //调用委托
                 GdEvent(name, address);
             }
         }
     }

上面我们定义及调用了泛型委托，接下来就来梆定委托。

        private void btnDelegate_Click(object sender, EventArgs e)
        {

             GenericDelegateClass<string, string> gd = new GenericDelegateClass<string, string>();
            //将DelegateReturn事件梆定给GdeleValue
             gd.GdeleValue = new GenricDelegate<string, string>(DelegateReturn);
            //将GenericEvent事件梆定给GdEvent
             gd.GdEvent += new GenricDelegateEnent<string, string>(GenericEvent<string,string>);
         }

        public string DelegateReturn<T,S>(T title,S author)
        {
            return title.ToString() + author;
         }

        private void GenericEvent<V, F>(V name, F address)
        {
            //
         }

在这里我们看到我在梆定DelegateReturn的时候并没有带泛型参数。在这里的泛型参数其实是没什么意义的。因为他的类型取决于调用委托的方法的类型。也就是在前面那段代码中InvokeEvent方法的类型，这里的DelegateReturn要用泛型方法是可以随时跟InvokeEvent的参数类型保持一至。这样梆定后我们再来调用gd.GetValues("my generic post","fastyou");这样调用的其实就是DelegateReturn的方法，这就是委托的好处了，同样调用gd.InvokeEvent("my generic post","fastyou");就是GenericEvent方法。