IComparable and IComparer

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Collections;


namespace  Sample_IComparable_and_IComparer
{
     ///   <summary>
     ///  Course Enum 课程枚举
     ///   </summary>
     public   enum  CourseEnum
    {
        Chinese  = 0 ,
        Math,
        English,
        Total
    }

     ///   <summary>
     ///  Scores class 分数类，用于记录学生的分数
     ///   </summary>
     public   class  Scores
    {
         int [] score  =   new   int [ 4 ];

         public   int   this [CourseEnum course]
        {
             get  {  return  score[( int )course]; }
             set
            {
                score[( int )course]  =  value;
            }
        }

         public   override   string  ToString()
        {
            StringBuilder sbScore  =   new  StringBuilder();
            sbScore.Append( " Chinese: " );
            sbScore.Append(score[ 0 ]);
            sbScore.Append( "     " );

            sbScore.Append( " Math: " );
            sbScore.Append(score[ 1 ]);
            sbScore.Append( "     " );

            sbScore.Append( " English: " );
            sbScore.Append(score[ 2 ]);
            sbScore.Append( "     " );

            sbScore.Append( " Total: " );
            sbScore.Append(score[ 3 ]);

             return  sbScore.ToString();
        }
    }


     ///   <summary>
     ///  Student Class 继承 IComparable。IComparable接口定义了类型的自然排序方式。
     ///   </summary>
     public   class  StudentComparable : IComparable
    {
         string  name;
        Scores score  =   new  Scores();

         public  StudentComparable( string  name,  int  chinese,  int  math,  int  english)
        {
             this .name  =  name;
             this .score[CourseEnum.Chinese]  =  chinese;
             this .score[CourseEnum.Math]  =  math;
             this .score[CourseEnum.English]  =  english;
             this .score[CourseEnum.Total]  =  chinese  +  math  +  english;
        }

         public   string  Name
        {
             get  {  return   this .name; }
             set  {  this .name  =  value; }
        }

         public  Scores Score
        {
             get  {  return   this .score; }
             set  {  this .score  =  value; }
        }


         // 显示实现接口,该方法在类型上不够安全。必须检查参数的运行时类型
         // 此方法要执行装箱和拆箱来进行实际的比较
         // 用此方法。如果Student[] student = new Student[99999];或者更大的时候，就知道“爽”就一个字了。
         int  IComparable.CompareTo( object  obj)
        {
             if  (obj  is  StudentComparable)
            {
                StudentComparable s  =  obj  as  StudentComparable;
                 return   this .CompareTo(s); // 升序。
                 // return this.CompareTo(s) * -1; // 降序。
            }

             throw   new  ArgumentException( " obj is not a StudentComparable " );
        }

         // 为接口中的方法提供一个公有的强类型重载版本
         // 优点：强类型，方便（至少能少打几个字母-_-#）
         public   int  CompareTo(StudentComparable stu)
        {
             // 执行 String.CompareTo 方法 (String)
             // 此方法性能优于CompareTo(object obj)方法
             // 很明显String.CompareTo 方法 (String) 没有拆箱
             return   this .name.CompareTo(stu.name);
        }
        

         public   override   string  ToString()
        {
             return   this .name  +   "  :  "   +   this .score.ToString();
        }
    }


     ///   <summary>
     ///  StudentComparer Class。继承 IComparer。IComparer则为类型提供了另外的排序方式。
     ///   </summary>
     public   class  StudentComparer : IComparer
    {
        StudentComparable[] sc;
        CourseEnum course;

         int  IComparer.Compare( object  x,  object  y)
        {
             if ( ! (x  is  StudentComparable))
                 throw   new  ArgumentException( " obj is not a StudentComparable " );
             if ( ! (y  is  StudentComparable))
                 throw   new  ArgumentException( " obj is not a CourseEnum " );

            StudentComparable left  =  x  as  StudentComparable;
            StudentComparable right  =  x  as  StudentComparable;

             return  Compare(left, right);
            
        }

         public   int  Compare(StudentComparable left, StudentComparable right)
        {
             return  left.Score[course].CompareTo(right.Score[course]);      // 升序
             // return left.Score[course].CompareTo(right.Score[course]) * -1;   // 降序
        }

         public  StudentComparable[] Sc
        {
             get  {  return  sc; }
             set  { sc  =  value; }
        }

         public  StudentComparer(StudentComparable[] sc, CourseEnum course)
        {
             this .sc  =  sc;
             this .course  =  course;
        }

         public   override   string  ToString()
        {
             return  sc.ToString();
        }

    }


     ///   <summary>
     ///  Test Class
     ///   </summary>
     public   class  TestClass
    {

         public   static   void  Main()
        {

            Console.WriteLine( " ***** IComparable 根据姓名排序*****\n " );

            StudentComparable[] student  =   new  StudentComparable[ 4 ];
            student[ 0 ]  =   new  StudentComparable( " C " ,  60 ,  80 ,  80 );
            student[ 1 ]  =   new  StudentComparable( " A " ,  70 ,  70 ,  70 );
            student[ 2 ]  =   new  StudentComparable( " D " ,  90 ,  90 ,  90 );
            student[ 3 ]  =   new  StudentComparable( " B " ,  80 ,  100 ,  100 );

            Array.Sort(student); // 调用 int IComparable.CompareTo(object obj)

             foreach  (StudentComparable stu  in  student)
            {
                Console.WriteLine(stu);
            }

            StudentComparable[] student2  =   new  StudentComparable[ 2 ];
            student2[ 0 ]  =   new  StudentComparable( " A " ,  80 ,  80 ,  80 );
            student2[ 1 ]  =   new  StudentComparable( " B " ,  70 ,  70 ,  70 );
             // 调用 public int CompareTo(Student stu)
            Console.WriteLine( " \n\ " { 0 }\ " .CompareTo(\ " { 1 }\ " ) : {2} " , student2[ 0 ].Name, student2[ 1 ].Name, student2[ 0 ].CompareTo(student2[ 1 ]));



            Console.WriteLine( " \n\n***** IComparer 根据总成绩排序 *****\n " );

            StudentComparer sc  =   new  StudentComparer(student, CourseEnum.Total);
            Array.Sort(sc.Sc, sc.Compare); // 调用 public int Compare(StudentComparable left, StudentComparable right)
             foreach  (StudentComparable s  in  sc.Sc)
            {
                Console.WriteLine(s.ToString());
            }

            Console.WriteLine( " \n\n***** IComparer 根据语文成绩排序 *****\n " );

            StudentComparer sc2  =   new  StudentComparer(student, CourseEnum.Chinese);
            Array.Sort(sc2.Sc, sc2.Compare);
             foreach  (StudentComparable s  in  sc2.Sc)
            {
                Console.WriteLine(s.ToString());
            }

            Console.Read();

        }
    }

} // namespace

结果如下：

***** IComparable 根据姓名排序*****

A : Chinese:70   Math:70   English:70   Total:210
B : Chinese:80   Math:100   English:100   Total:280
C : Chinese:60   Math:80   English:80   Total:220
D : Chinese:90   Math:90   English:90   Total:270

"A".CompareTo("B") : -1

***** IComparer 根据总成绩排序 *****

A : Chinese:70   Math:70   English:70   Total:210
C : Chinese:60   Math:80   English:80   Total:220
D : Chinese:90   Math:90   English:90   Total:270
B : Chinese:80   Math:100   English:100   Total:280

***** IComparer 根据语文成绩排序 *****

C : Chinese:60   Math:80   English:80   Total:220
A : Chinese:70   Math:70   English:70   Total:210
B : Chinese:80   Math:100   English:100   Total:280
D : Chinese:90   Math:90   English:90   Total:270