委托的用途

对一个数组进行排序算法,使用冒泡排序算法,代码如下:

           

int[] sortArray = {0,5,6,2,1};
            //冒泡排序
            bool swapped =true;
            do{
                swapped = false;
                for (int i = 0; i < sortArray.Length-1;i++)
                {
                    if(sortArray[i] >sortArray[i+1]) //problem code
                    {
                        int temp = sortArray[i];
                        sortArray[i]= sortArray[i + 1];
                        sortArray[i+ 1] = temp;
                        swapped = true;
                    }
                }
            }while(swapped);

但这仅仅是对int型数据进行排序。

如果还需要对其他自定义类型的数据进行排序，那么上述代码中的if(sortArray[i]

 >sortArray[i+1])就有问题了，因为它需要比较数组中的两个对象，看哪个更大。对int 可以这样比较，但是如何对没有实现”<”运算符的新类进行比较呢？

这时，便可以使用委托，在委托中传递一个封装的方法，这个方法可以进行比较，另外，不给变量temp使用int类型，而是使用泛型。

         对于接受类型T的泛型方法Sort<T>()，需要一个比较方法，其两个参数的类型是T，if比较的返回方法是布尔类型。这个方法可以从Func<T1,T2,Tresult>委托中引用，其中，T1，T2类型相同：Func<T,T,bool>。

         给Sort<T>方法指定下列签名：

        

static public void Sort<T>(IList<T>sortArray,Func<T, T,bool> comparison)

         定义BubbleSorter类，如下：

    class BubbleSorter
    {
        static public void Sort<T>(IList<T>sortArray,Func<T, T,bool> comparison)
            {
               //冒泡排序
               bool swapped =true;
               do
               {
                   swapped = false;
                   for (int i = 0; i < sortArray.Count - 1; i++)
                   {
                        if (comparison(sortArray[i],sortArray[i+1]))
                        {
                            T temp =sortArray[i];
                            sortArray[i] =sortArray[i + 1];
                            sortArray[i + 1] =temp;
                            swapped = true;
                        }
                   }
               } while (swapped);
            }
}

为了使用这个类，我们定义另一个类，从而建立排序数组。

  

  class Employee
    {
        public Employee(string name,decimal salary)
        {
            this.Name = name;
            this.Salary = salary;
        }
        public string Name { get; private set; }
        public decimal Salary { get; private set; }
        public override string ToString()
        {
            returnstring.Format("{0},{1:C}",Name,Salary);
        }
        public static bool CompareSalary(Employee e1,Employee e2)
        {
            return e1.Salary < e2.Salary;
        }
}

为了匹配Func<T,T,bool>，这个类必须定义CompareSalary，它的参数必须是两个Employee引用，并返回一个布尔值。

下列是主函数代码:

   

 class Program
    {
        static void Main(string[] args)
        {
            Employee[] employees =
            {
               newEmployee("A",300),
               newEmployee("B",200),
               newEmployee("C",500),
               newEmployee("D",100),
               newEmployee("E",200)
           };
            BubbleSorter.Sort<Employee>(employees,Employee.CompareSalary);
            foreach(Employee eein employees)
            {
               Console.WriteLine(ee);
            }
        }
}

运行这段代码，可得到如下结果：

C,￥500.00

A,￥300.00

B,￥200.00

E,￥200.00

D,￥100.00

当排序类型为int型时，代码如下：

   

 class Program
    {
        static void Main(string[] args)
        {
            int[] ar = {5,4,2,3,1 };
            BubbleSorter.Sort<int>(ar,CompareSalary);
            foreach(int eein ar)
            {
               Console.WriteLine(ee);
            }
        }
        public static bool CompareSalary(int e1,int e2)
        {
            return e1 < e2;
        }
    }