学习利用泛型和委托进行实体类比较

对于一个int类型的数组，我们可以用冒泡排序的方法进行比较排序，但是对于实体类，则不行。

例如，对数组进行排序，代码如下：

class Program
    {

        static void Sort(int[] sortArray)
        {
            bool swapped = true;
            do
            {
                swapped = false;
                for (int i = 0; i < sortArray.Length-1; i++)
                {
                    if (sortArray[i] > sortArray[i + 1])
                    {
                        int temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                        swapped = true;
                    }
                }
            } while (swapped);
        }
 

        static void Main(string[] args)
        {
            int[] array = new int[] { 12, 234, 5, 64, 3, 23, 334 };
            Sort(array);
            foreach (int i in array)
            {
                Console.WriteLine(i + "  ");
            }
            
            Console.ReadKey();
        }
    }

对数组进行排序，如果这个数组是有序的数组，即是从小到大排序的，第一遍遍历完后，就跳出循环，这样可以减少时间。所以在循环开始时，设置一个布尔型的标识，在do循环开始时，把值设置为fasle，如果进行了数组内值换位置的动作，则把标识设置为true，接着循环，如果没有进行换位动作，则说明数据时有序的，直接跳出循环比较。但是，这个冒泡排序的方法只适用于int类型的比较，如果是对实体对象进行比较，则行不通，需要做调整，利用泛型和委托进行。

示例代码如下：

Employee实体类

 public class Employee
    {
        public string Name { get; private set; }
        public int Salary { get; private set; }

        public Employee(string name, int salary)
        {
            this.Name = name;
            this.Salary = salary;
        }

        public static bool Compare(Employee e1, Employee e2)
        {
            return e1.Salary > e2.Salary;
        }

        public override string ToString()
        {
            //return base.ToString();
            return Name + "的薪水是" + Salary;
        }
    }

Main方法

  class Program
    {
         
        static void CommanSort<T>(T[] sortArray, Func<T, T, bool> compareMethod)
        {
            bool swapped = true;
            do
            {
                swapped = false;
                for (int i = 0; i < sortArray.Length - 1; i++)
                {
                    if (compareMethod(sortArray[i],sortArray[i+1]))
                    {
                        T temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                        swapped = true;
                    }
                }
            } while (swapped);
        }
        static void Main(string[] args)
        {
            
            Employee[] employees=new Employee[]
            {
                new Employee("1",1),
                new Employee("2",2),
                new Employee("3",3),
                new Employee("4",4),
                new Employee("5",5)
            };
            CommanSort(employees,Employee.Compare);
            foreach (Employee model in employees)
            {
                //Console.WriteLine(model.Name +" "+model.Salary);
                Console.WriteLine(model.ToString());
            }
            
            Console.ReadKey();
        }
    }

在Employee中，定义两个属性，一个是Name，一个是Salary ,并添加构造函数，用于实例化赋值。增加Compare(Employee e1, Employee e2)方法，用于两个对象的薪水比较。如果e1大于e2，则返回true,反之，则返回false。

在比较方法CommanSort<T>(T[] sortArray, Func<T, T, bool> compareMethod)中，应为我们不知道比较的对象是什么，所以采用泛型T，然后利用Func<T, T, bool> compareMethod 委托对两个泛型对象进行比较，并返回一个布尔类型的值。所以在循环比较中，需要调用委托参数compareMethod方法进行比较，同时，换位的中间参数Temp也要定义成泛型。在main方法中，CommanSort(employees,Employee.Compare)中的employees对用第一个泛型参数组，第二个参数的意思就是把Employee.Compare放到委托对象compareMethod中进行调用。

以上为个人学习所得，如有不妥，请指正！