委托回调函数的妙用（c# code )

最新推荐文章于 2024-01-30 09:30:16 发布

原创最新推荐文章于 2024-01-30 09:30:16 发布 · 211 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c#

WPF 同时被 2 个专栏收录

12 篇文章

订阅专栏

12 篇文章

订阅专栏

本文通过一个具体的C#代码示例介绍了如何利用委托简化代码并提高其灵活性与扩展性。展示了如何通过定义通用的筛选方法避免重复代码，并通过不同的委托表达式实现多种筛选条件。

   //person类
  public  class Person
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;

        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        private string role;

        public string Role
        {
            get { return role; }
            set { role = value; }
        } 
    }
//
 public class DelegateClass
    {
        private List Psersons;
        ///

        /// 待筛选的person集合
        ///
        public List Persons
        {
            get { return Psersons; }
            set { Psersons = value; }
        }
        public List FindPerson(Predicate condition)
        {
            List list = new List();
            foreach (var p in Persons)
            {
                if (condition(p))
                         list.Add(p);
            }
            return list;
        }
    }//委托函数调用
 class Program
    {
        static void Main(string[] args)
        {
            List list = new List();
            Person people = new Person();
            people.Name = "FrankPeng";
            people.Age = 25;
            people.Role = "软件工程师";
            list.Add(people);

            Person people1 = new Person();
            people1.Name = "Jack";
            people1.Age = 30;
            people1.Role = "项目主管";
            list.Add(people1);

            Person people2 = new Person();
            people2.Name = "James";
            people2.Age = 36;
            people2.Role = "总监";
            list.Add(people2);
           
            DelegateClass deleCall = new DelegateClass();
            deleCall.Persons = list;
            //查找名字叫张三的人。
            list = deleCall.FindPerson(delegate(Person p) { return p.Name == "张三"; });
            foreach (var item in list)
            {
                Console.WriteLine("姓名为张三的人：");
                Console.WriteLine(item.Name);
                Console.WriteLine(item.Age);
                Console.WriteLine(item.Role);
                Console.WriteLine("============================");
            }
            //查找年龄在20~30岁的人。
            list = deleCall.FindPerson(delegate(Person p) { return p.Age >= 20 && p.Age <= 30; });
            foreach (var item in list)
            {
                Console.WriteLine("年龄在20~30岁的人：");
                Console.WriteLine(item.Name);
                Console.WriteLine(item.Age);
                Console.WriteLine(item.Role);
                Console.WriteLine("============================");
            }
            ////查找职务角色是总监

            list = deleCall.FindPerson(delegate(Person p) { return p.Role == "总监"; });
            foreach (var item in list)
            {
                Console.WriteLine("职位为总监的人是：");
                Console.WriteLine(item.Name);
                Console.WriteLine(item.Age);
                Console.WriteLine(item.Role);
                Console.WriteLine("============================");
            }
        }
    }

在这段代码中，调用者提前定义行为（筛选什么样的数据），而算法（查找人员的方法），它只管遍历。
如果没有委托，你怎么写？
你得写
FindPersonByName(string Name)
FindPersonByAge(int MinAge, int MaxAge)
FindPersonByRole(RoleType type)
FindPersonByXXX(...)
...
这些函数在遍历算法上相同，但是筛选的依据不同，于是相同的程序就要写很多次。
你有什么办法把这些方法写入一个函数，同时具有无限扩展性呢？比如有人提出，我查找年龄不这么找，我找年龄是偶数的人（好奇怪的需求）。用委托的代码很简单，查找函数不用改，用如下调用即可：
你得写
FindPersonByName(string Name)
FindPersonByAge(int MinAge, int MaxAge)
FindPersonByRole(RoleType type)
FindPersonByXXX(...)
...
这些函数在遍历算法上相同，但是筛选的依据不同，于是相同的程序就要写很多次。
你有什么办法把这些方法写入一个函数，同时具有无限扩展性呢？
比如有人提出，我查找年龄不这么找，我找年龄是偶数的人（好奇怪的需求）。
用委托的代码很简单，查找函数不用改，用如下调用即可：
C# code
    list = FindPerson(delegate(Person p)
{
    return p.Age % 2 == 0; });
    foreach (var item in list)
    {
       Console.WriteLine(item);
    }
随着功能的增多，不使用委托的代码要么出现很多很多重复的方法，或者是一个很复杂的 switch case 分支，而且每次新的需求都要修改函数实现。