排序的问题

Question

今天出的题，完全没头绪，求高人指点需求:
一个Person类，包含人的信息，这个类要实现ICompareable接口
一个排序类，实现IComparer接口
要求能够通过索引号或者人名（忽略大小写）来实现查询（两种都要实现）描述得不太清楚，做过这类东西的大大估计还是能看懂的，希望能给点提示或者代码

Answer 1

我的博客using System;   
using System.Collections.Generic;   
using System.Text;   
using System.Collections;   
  
namespace hgoApp   
{   
    class Comparer   
    {   
        static void Main()   
        {   
            Employee[] Employees = new Employee[5];   
               
            Employees[0] = new Employee("张三", 2800);   
            Employees[1] = new Employee("李四", 1800);   
            Employees[2] = new Employee("王五", 5800);   
            Employees[3] = new Employee("马六", 12800);   
            Employees[4] = new Employee("钱七", 8800);   
            Console.WriteLine("按照姓名排序");   
            Array.Sort(Employees);   
            foreach (Employee em in Employees)   
            {   
                Console.WriteLine(em);   
            }   
            Console.WriteLine("按照薪水排序");   
            Array.Sort(Employees, Employee.SalaryCom);   
            foreach (Employee em in Employees)   
            {   
                Console.WriteLine(em);   
            }   
        }   
    }   
    class Employee : IComparable   
    {   
        private string _Name;   
        public string Name   
        {   
            get { return _Name; }   
        }   
        private int _Salary;   
        public int Salary   
        {   
            get { return _Salary; }   
        }   
        public Employee(string Name, int Salary)   
        {   
            _Name = Name;   
            _Salary = Salary;   
        }   
        //显示接口实现   
        int IComparable.CompareTo(object obj)   
        {   
            if (!(obj is Employee))   
            {   
                throw new ArgumentException("不是Employee类");    
            }   
            return _Name.CompareTo(((Employee)obj)._Name);   
        }   
        //提供一个公用的强类型重载版本   
        public int CompareTo(Employee Em)   
        {   
            return _Name.CompareTo(Em._Name);   
        }   
        //当第一次实例化Employee的时候,_SalaryCom为空,当使用SalaryCom时,就会创建一个SalaryCompare对象,第2次，3次的时候,就可以直接使用_SalaryCom了   
        private static SalaryCompare _SalaryCom = null;   
        public static IComparer SalaryCom   
        {   
            get  
            {   
                if (_SalaryCom == null)   
                {   
                    _SalaryCom = new SalaryCompare();    
                }   
                return _SalaryCom;   
            }   
        }   
        //嵌套类(这个类是针对薪水进行排序的类)   
        private class SalaryCompare:IComparer   
        {   
            //使用指定的IComparer对Array中的元素进行排序   
            int IComparer.Compare(object obj1,object obj2)   
            {   
                if (!(obj1 is Employee) || !(obj2 is Employee))   
                {   
                    throw new ArgumentException("不是Employee类");    
                }   
                return ((Employee)obj1)._Salary.CompareTo(((Employee)obj2)._Salary);   
            }   
        }   
        public override string ToString()   
        {   
            return _Name +"  "+ _Salary.ToString();   
        }   
    }   
}  本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ws_hgo/archive/2009/08/02/4402096.aspx

Answer 2

http://blog.csdn.net/ws_hgo/archive/2009/08/02/4402096.aspx

Answer 3

忘说了，要求用Array的二分法实现，完全不明白经理出的这个题啥意思了

Answer 4

        //显示接口实现   
        int IComparable.CompareTo(object obj)   
        {   
            if (!(obj is Employee))   
            {   
                throw new ArgumentException("不是Employee类");    
            }   
            return _Name.CompareTo(((Employee)obj)._Name);   
        }   
        //提供一个公用的强类型重载版本   
        public int CompareTo(Employee Em)   
        {   
            return _Name.CompareTo(Em._Name);   
        }  能不能解释下这两句呢，没接触过接口编程，看不懂啊

Answer 5

最直接的...
string.Compare(a,b)
返回0表示a==b
返回>0表示a>b
返回<0表示a<b一般来说string.Compare也就够了.

Answer 6

//显示接口实现   
        int IComparable.CompareTo(object obj)   
        {   
            if (!(obj is Employee))   
            {   
                throw new ArgumentException("不是Employee类");    
            }   
            return _Name.CompareTo(((Employee)obj)._Name);   
        }   
        //提供一个公用的强类型重载版本   
        public int CompareTo(Employee Em)   
        {   
            return _Name.CompareTo(Em._Name);   
        }   
int IComparable.CompareTo(object obj)  这句为什么不能加public修饰符呢