C# .NET对通用泛型进行快速排序

我们经常使用List<model>泛型进行数据的封装，但是有时候，在某种需求下，你可能需要对这个泛型进行排序，而排序规则是根据model中的某一个属性进行排序，这时棘手的事情来了，怎么办？！！

这个时候我们需要自己扩展一个排序方法，以下我给出一个继承自IComparer接口的类，此类内置好升序和降序的排序规则：

[csharp]
/// <summary>  
/// 继承IComparer<T>接口，实现同一自定义类型　对象比较  
/// </summary>  
/// <typeparam name="T">T为泛用类型</typeparam>  
public class Reverser<T> : IComparer<T> 
{ 
    private Type type = null; 
    private ReverserInfo info; 
 
    /// <summary>  
    /// 构造函数  
    /// </summary>  
    /// <param name="type">进行比较的类类型</param>  
    /// <param name="name">进行比较对象的属性名称</param>  
    /// <param name="direction">比较方向(升序/降序)</param>  
    public Reverser(Type type, string name, ReverserInfo.Direction direction) 
    { 
        this.type = type; 
        this.info.name = name; 
        if (direction != ReverserInfo.Direction.ASC) 
            this.info.direction = direction; 
    } 
 
    /// <summary>  
    /// 构造函数  
    /// </summary>  
    /// <param name="className">进行比较的类名称</param>  
    /// <param name="name">进行比较对象的属性名称</param>  
    /// <param name="direction">比较方向(升序/降序)</param>  
    public Reverser(string className, string name, ReverserInfo.Direction direction) 
    { 
        try 
        { 
            this.type = Type.GetType(className, true); 
            this.info.name = name; 
            this.info.direction = direction; 
        } 
        catch (Exception e) 
        { 
            throw new Exception(e.Message); 
        } 
    } 
 
 
    /// <summary>  
    /// 构造函数  
    /// </summary>  
    /// <param name="t">进行比较的类型的实例</param>  
    /// <param name="name">进行比较对象的属性名称</param>  
    /// <param name="direction">比较方向(升序/降序)</param>  
    public Reverser(T t, string name, ReverserInfo.Direction direction) 
    { 
        this.type = t.GetType(); 
        this.info.name = name; 
        this.info.direction = direction; 
    } 
 
    //必须！实现IComparer<T>的比较方法。  
    int IComparer<T>.Compare(T t1, T t2) 
    { 
        object x = this.type.InvokeMember(this.info.name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty, null, t1, null); 
        object y = this.type.InvokeMember(this.info.name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty, null, t2, null); 
        if (this.info.direction != ReverserInfo.Direction.ASC) 
            Swap(ref x, ref y); 
        return (new CaseInsensitiveComparer()).Compare(x, y); 
    } 
 
    //交换操作数  
    private void Swap(ref object x, ref object y) 
    { 
        object temp = null; 
        temp = x; 
        x = y; 
        y = temp; 
    } 
} 
 
/// <summary>  
/// 对象比较时使用的信息类  
/// </summary>  
public struct ReverserInfo 
{ 
 
    /// <summary>  
    /// 比较的方向，如下：  
    /// ASC：升序  
    /// DESC：降序  
    /// </summary>  
    public enum Direction 
    { 
        ASC = 0, 
        DESC, 
    }; 
 
    public enum Target 
    { 
        CUSTOMER = 0, 
        FORM, 
        FIELD, 
        SERVER, 
    }; 
 
    public string name; 
    public Direction direction; 
    public Target target; 
} 

    /// <summary>
    /// 继承IComparer<T>接口，实现同一自定义类型　对象比较
    /// </summary>
    /// <typeparam name="T">T为泛用类型</typeparam>
    public class Reverser<T> : IComparer<T>
    {
        private Type type = null;
        private ReverserInfo info;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="type">进行比较的类类型</param>
        /// <param name="name">进行比较对象的属性名称</param>
        /// <param name="direction">比较方向(升序/降序)</param>
        public Reverser(Type type, string name, ReverserInfo.Direction direction)
        {
            this.type = type;
            this.info.name = name;
            if (direction != ReverserInfo.Direction.ASC)
                this.info.direction = direction;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="className">进行比较的类名称</param>
        /// <param name="name">进行比较对象的属性名称</param>
        /// <param name="direction">比较方向(升序/降序)</param>
        public Reverser(string className, string name, ReverserInfo.Direction direction)
        {
            try
            {
                this.type = Type.GetType(className, true);
                this.info.name = name;
                this.info.direction = direction;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="t">进行比较的类型的实例</param>
        /// <param name="name">进行比较对象的属性名称</param>
        /// <param name="direction">比较方向(升序/降序)</param>
        public Reverser(T t, string name, ReverserInfo.Direction direction)
        {
            this.type = t.GetType();
            this.info.name = name;
            this.info.direction = direction;
        }

        //必须！实现IComparer<T>的比较方法。
        int IComparer<T>.Compare(T t1, T t2)
        {
            object x = this.type.InvokeMember(this.info.name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty, null, t1, null);
            object y = this.type.InvokeMember(this.info.name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty, null, t2, null);
            if (this.info.direction != ReverserInfo.Direction.ASC)
                Swap(ref x, ref y);
            return (new CaseInsensitiveComparer()).Compare(x, y);
        }

        //交换操作数
        private void Swap(ref object x, ref object y)
        {
            object temp = null;
            temp = x;
            x = y;
            y = temp;
        }
    }

    /// <summary>
    /// 对象比较时使用的信息类
    /// </summary>
    public struct ReverserInfo
    {

        /// <summary>
        /// 比较的方向，如下：
        /// ASC：升序
        /// DESC：降序
        /// </summary>
        public enum Direction
        {
            ASC = 0,
            DESC,
        };

        public enum Target
        {
            CUSTOMER = 0,
            FORM,
            FIELD,
            SERVER,
        };

        public string name;
        public Direction direction;
        public Target target;
    }

此时写好后，就只需要知道如何调用就行了：

[csharp]
Reverser<Model> reverser = new Reverser<Model>(typeof(Model), "btnIndex", ReverserInfo.Direction.ASC); 

Reverser<Model> reverser = new Reverser<Model>(typeof(Model), "btnIndex", ReverserInfo.Direction.ASC);我们通过这样的调用方式，就得到一个定义好的排序规则 reverser，假设我们的泛型实例名为 list，则按照如下调用：

[csharp]
list.Sort(reverser); 

list.Sort(reverser);
至此，就完成了特定的排序规则处理了。

后感：

虽然这种需求不多，但是在自定义构造的泛型中，需要根据某一属性进行有序显示的时候，就非常实用。

同时任何自定义的类组成的泛型集合都可以实现自定义排序，可以做成一个通用类，没有必要每一个自定义类都去实现排序的接口。