`
asd14828
  • 浏览: 30543 次
  • 性别: Icon_minigender_1
  • 来自: 太原
社区版块
存档分类
最新评论

C#范型List类的Sort方法有四种形式

    博客分类：
  • C#
 
阅读更多
C#范型List类的Sort方法有四种形式，分别是
1，不带有任何参数的Sort方法----Sort()；
2，带有比较器参数的Sort方法 ----Sort(IComparer<T>)
3，带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>))
4，带有比较起参数，可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T))


首先介绍第一种方法，使用这种方法不是对List中的任何元素对象都可以进行排序，List中的元素对象必须继承IComparable接口，并且要实现IComparable接口中的CompareTo()方法，在CompareTo()方法中要自己实现对象的比较规则。详细可以参照如下代码： 

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

namespace Comparer.SortObject
{
    /// <summary>
    /// List<>.Sort()的测试对象，类自己实现IComparable接口，
    /// 当需要对List中的SortTestObj1对象进行排序时，直接调用
    /// Sort()方法就可以了。
    /// </summary>
    public class SortTestObj1:IComparable
    {
        #region 类字段定义
        private int code;
        private string name;
        #endregion
        public SortTestObj1()
        {
            //
        }

        #region 属性定义
        public int Code
        {
            set { this.code = value; }
            get { return this.code; }
        }
        public string Name
        {
            set { this.name = value; }
            get { return this.name; }
        }
        #endregion

        #region 实现比较接口的CompareTo方法
        public int CompareTo(object obj)
        {
            int res = 0;
            try
            {
                SortTestObj1 sObj = (SortTestObj1)obj;
                if (this.code > sObj.code)
                {
                    res = 1;
                }
                else if (this.code < sObj.code)
                {
                    res = -1;
                }
            }
            catch (Exception ex)
            {
                throw new Exception("比较异常", ex.InnerException);
            }
            return res;
        }
        #endregion
    }
}


第二种带有比较器参数的Sort方法，List中的元素对象不需要继承IComparable接口，但需要额外创建一个对象的比较器，下面的代码中的SortTestObj2类是准备要保存到范型List中的对象，SortTestObj2Camparer 类则是SortTestObj2类的比较器，这个比较起必须继承IComparer<T>接口，并且实现接口中的Compare()方法。详细做法可参照下面的代码。
SortTestObj2类 

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

namespace Comparer.SortObject
{
    /// <summary>
    /// List<>.Sort(IComparer<(Of <(T>)>))的测试对象，类自己没有实现IComparable接口，
    /// 当需要对List中的SortTestObj2对象进行排序时，需要实例化一个SortTestObj2Camparer
    /// 类型的比较器,在比较器中指明排序类型(按Code排序还是按Name排序)，然后调用
    /// xxxLst.Sort(SortTestObj2Camparer)方法就可以了。
    /// </summary>
    public class SortTestObj2
    {
        #region 类字段定义
        private int code;
        private string name;
        #endregion
        public SortTestObj2()
        {
            //
        }

        #region 属性定义
        public int Code
        {
            set { this.code = value; }
            get { return this.code; }
        }
        public string Name
        {
            set { this.name = value; }
            get { return this.name; }
        }
        #endregion
    }
}

SortTestObj2Camparer类 

using System;
using System.Collections.Generic;
using System.Text;
using Comparer.SortObject;

namespace Comparer.Camparer
{
    [Flags]
    //排序类型定义
    public enum Obj2SortKind { Code, Name }
    /// <summary>
    /// SortTestObj2类排序用的比较器，继承IComparer<>接口，
    /// 实现接口中的Compare()方法。
    /// </summary>
    public class SortTestObj2Camparer : IComparer<SortTestObj2>
    {
        #region 类字段定义
        private Obj2SortKind sortKind;
        #endregion

        #region 构造器
        public SortTestObj2Camparer(Obj2SortKind sk)
        {
            this.sortKind = sk;
        }
        #endregion

        #region IComparer接口比较方法的实现
        public int Compare(SortTestObj2 obj1, SortTestObj2 obj2)
        {
            int res = 0;
            if ((obj1 == null) && (obj2 == null))
            {
                return 0;
            }
            else if((obj1 != null) && (obj2 == null))
            {
                return 1;
            }
            else if ((obj1 == null) && (obj2 != null))
            {
                return -1;
            }
            
            if (sortKind == Obj2SortKind.Code)
            {
                if (obj1.Code > obj2.Code)
                {
                    res = 1;
                }
                else if (obj1.Code < obj2.Code)
                {
                    res = -1;
                }
            }
            else if(sortKind == Obj2SortKind.Name)
            {
                res = obj1.Name.CompareTo(obj2.Name);
            }
            return res;
        }
        #endregion


    }
}


第三种方法需要编写一个对象排序比较的方法，对List中的元素对象没有特殊的要求，但在比较方法中需要实现对象比较规则，这个方法实现后，就可以把这方名字作为参数委托给List的Sort方法，Sort方法在排序时会执行这个方法对List中的对象进行比较，详细可参照下面的代码。对List中元素我们还使用上面的SortTestObj2类对象。 
        static void Main(string[] args)
        {
            //利用代理方法进行排序
            DelegateSort();
        }
        
        //Sort(Comparison<(Of <(T>)>))方法排序,这中方法需要先编写一个对象比较的方法,然后
        //把这个比较方法委托给List的Sort方法。
        //对象比较的方法
        private static int SortTestObj2Compare(SortTestObj2 obj1, SortTestObj2 obj2)
        {
            int res = 0;
            if ((obj1 == null) && (obj2 == null))
            {
                return 0;
            }
            else if ((obj1 != null) && (obj2 == null))
            {
                return 1;
            }
            else if ((obj1 == null) && (obj2 != null))
            {
                return -1;
            }
            if (obj1.Code > obj2.Code)
            {
                res = 1;
            }
            else if (obj1.Code < obj2.Code)
            {
                res = -1;
            }
            return res;
        }
        //List的委托排序
        private static void DelegateSort()
        {
            List<SortTestObj2> objLst = new List<SortTestObj2>();
            SortTestObj2 obj1 = new SortTestObj2();
            obj1.Code = 3;
            obj1.Name = "TestObj1";
            objLst.Add(obj1);
            SortTestObj2 obj2 = new SortTestObj2();
            obj2.Code = 2;
            obj2.Name = "TestObj2";
            objLst.Add(obj2);
            SortTestObj2 obj3 = new SortTestObj2();
            obj3.Code = 4;
            obj3.Name = "TestObj4";
            objLst.Add(obj3);
            SortTestObj2 obj4 = new SortTestObj2();
            obj4.Code = 1;
            obj4.Name = "TestObj3";
            objLst.Add(obj4);
            SortTestObj2 obj5 = new SortTestObj2();
            obj5.Code = 6;
            obj5.Name = "TestObj6";
            objLst.Add(obj5);
            objLst.Sort(SortTestObj2Compare);
            Console.WriteLine("委托方法排序的结果");
            foreach (SortTestObj2 item in objLst)
            {
                Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
            }
        }


对于第四排序方法，实际是第二种比较器排序的一个扩展，在指定排序比较器的同时，指定排序范围，即List中准备排序的开始元素索引和结束元素索引，代码样式如下：

//按Name进行排序
            SortTestObj2Camparer nameCmp = new SortTestObj2Camparer(Obj2SortKind.Name);
            objLst.Sort(1, 3, nameCmp);
下面的代码是对上面介绍的四种方法的进行测试的代码，可以结合上面代码建立一个控制台工程体会一下。 

using System;
using System.Collections.Generic;
using System.Text;
using Comparer.SortObject;
using Comparer.Camparer;

namespace Comparer
{
    class Program
    {
        static void Main(string[] args)
        {
            //List中的对象实现了IComparable接口时的排序
            LstSort();
            //利用比较器排序
            LstComparerSort();
            //利用比较器，对List中指定的区间的元素排序
            LstFromToSort();
            //利用代理方法进行排序
            DelegateSort();
        }

        //Sort()方法排序
        private static void LstSort()
        {
            List<SortTestObj1> objLst = new List<SortTestObj1>();
            SortTestObj1 obj1 = new SortTestObj1();
            obj1.Code = 3;
            obj1.Name = "TestObj3";
            objLst.Add(obj1);
            SortTestObj1 obj2 = new SortTestObj1();
            obj2.Code = 2;
            obj2.Name = "TestObj2";
            objLst.Add(obj2);
            SortTestObj1 obj3 = new SortTestObj1();
            obj3.Code = 4;
            obj3.Name = "TestObj4";
            objLst.Add(obj3);
            //排序
            objLst.Sort();
            foreach(SortTestObj1 item in objLst)
            {
                Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
            }
        }

        //Sort(IComparer(T))方法排序
        private static void LstComparerSort()
        {
            List<SortTestObj2> objLst = new List<SortTestObj2>();
            SortTestObj2 obj1 = new SortTestObj2();
            obj1.Code = 3;
            obj1.Name = "TestObj1";
            objLst.Add(obj1);
            SortTestObj2 obj2 = new SortTestObj2();
            obj2.Code = 2;
            obj2.Name = "TestObj2";
            objLst.Add(obj2);
            SortTestObj2 obj3 = new SortTestObj2();
            obj3.Code = 4;
            obj3.Name = "TestObj4";
            objLst.Add(obj3);
            //按Code进行排序
            SortTestObj2Camparer codeCmp = new SortTestObj2Camparer(Obj2SortKind.Code);
            //排序
            objLst.Sort(codeCmp);
            Console.WriteLine("按Code排序的结果");
            foreach (SortTestObj2 item in objLst)
            {
                Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
            }
            //按Name进行排序
            SortTestObj2Camparer nameCmp = new SortTestObj2Camparer(Obj2SortKind.Name);
            objLst.Sort(nameCmp);
            Console.WriteLine("按Name排序的结果");
            foreach (SortTestObj2 item in objLst)
            {
                Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
            }
        }

        //Sort(Int32, Int32 IComparer(T))排序,指定List中排序的开始元素和终了元素
        private static void LstFromToSort()
        {
            List<SortTestObj2> objLst = new List<SortTestObj2>();
            SortTestObj2 obj1 = new SortTestObj2();
            obj1.Code = 3;
            obj1.Name = "TestObj1";
            objLst.Add(obj1);
            SortTestObj2 obj2 = new SortTestObj2();
            obj2.Code = 2;
            obj2.Name = "TestObj2";
            objLst.Add(obj2);
            SortTestObj2 obj3 = new SortTestObj2();
            obj3.Code = 4;
            obj3.Name = "TestObj4";
            objLst.Add(obj3);
            SortTestObj2 obj4 = new SortTestObj2();
            obj4.Code = 1;
            obj4.Name = "TestObj3";
            objLst.Add(obj4);
            SortTestObj2 obj5 = new SortTestObj2();
            obj5.Code = 6;
            obj5.Name = "TestObj6";
            objLst.Add(obj5);
            //按Code进行排序
            SortTestObj2Camparer codeCmp = new SortTestObj2Camparer(Obj2SortKind.Code);
            //排序
            objLst.Sort(1, 3, codeCmp);
            Console.WriteLine("按Code排序的结果");
            foreach (SortTestObj2 item in objLst)
            {
                Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
            }
            //按Name进行排序
            SortTestObj2Camparer nameCmp = new SortTestObj2Camparer(Obj2SortKind.Name);
            objLst.Sort(1, 3, nameCmp);
            Console.WriteLine("按Name排序的结果");
            foreach (SortTestObj2 item in objLst)
            {
                Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
            }
        }

        //Sort(Comparison<(Of <(T>)>))方法排序,这中方法需要先编写一个对象比较的方法,然后
        //把这个比较方法委托给List的Sort方法。
        //对象比较的方法
        private static int SortTestObj2Compare(SortTestObj2 obj1, SortTestObj2 obj2)
        {
            int res = 0;
            if ((obj1 == null) && (obj2 == null))
            {
                return 0;
            }
            else if ((obj1 != null) && (obj2 == null))
            {
                return 1;
            }
            else if ((obj1 == null) && (obj2 != null))
            {
                return -1;
            }
            if (obj1.Code > obj2.Code)
            {
                res = 1;
            }
            else if (obj1.Code < obj2.Code)
            {
                res = -1;
            }
            return res;
        }
        //List的委托排序
        private static void DelegateSort()
        {
            List<SortTestObj2> objLst = new List<SortTestObj2>();
            SortTestObj2 obj1 = new SortTestObj2();
            obj1.Code = 3;
            obj1.Name = "TestObj1";
            objLst.Add(obj1);
            SortTestObj2 obj2 = new SortTestObj2();
            obj2.Code = 2;
            obj2.Name = "TestObj2";
            objLst.Add(obj2);
            SortTestObj2 obj3 = new SortTestObj2();
            obj3.Code = 4;
            obj3.Name = "TestObj4";
            objLst.Add(obj3);
            SortTestObj2 obj4 = new SortTestObj2();
            obj4.Code = 1;
            obj4.Name = "TestObj3";
            objLst.Add(obj4);
            SortTestObj2 obj5 = new SortTestObj2();
            obj5.Code = 6;
            obj5.Name = "TestObj6";
            objLst.Add(obj5);
            objLst.Sort(SortTestObj2Compare);
            Console.WriteLine("委托方法排序的结果");
            foreach (SortTestObj2 item in objLst)
            {
                Console.WriteLine("Code=" + item.Code + ",Name=" + item.Name);
            }
        }
    }
}
分享到：
| win2003 IIS6,能访问html页，但是不能访问 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    c#泛型详解，泛型方法，泛型类

    泛型类和方法在编译后生成的Microsoft中间语言(MSIL)中，不会为每种类型实例化一份代码，而是以参数化的方式存在，直到实际使用时才实例化具体的类型。这种机制使得泛型代码更加高效且内存占用更少。 总之，C#中的...

    范型List Dictory增加事件功能

    在.NET框架中，`List&lt;T&gt;`和`Dictionary, TValue&gt;`是两个常用的数据结构，分别代表泛型列表和泛型字典。它们都是系统提供的高效容器，用于存储和操作对象集合。然而，这两种数据结构在默认情况下并不直接支持事件通知...

    范型程序设计与 STL.pdf

    范型编程是一种强大的软件开发方法，它允许程序员创建可重用的代码模板，这些模板可以应用于各种不同的数据类型。STL则是C++标准库的一部分，提供了容器、迭代器、算法和函数对象等高效工具，极大地提高了代码的效率...

    第9章 范型和容器类.ppt

    在Java编程语言中，范型（Generics）和容器类是重要的核心概念，它们极大地提高了代码的可读性、安全性和复用性。本章主要探讨了如何利用这些概念来处理动态数据集合。 首先，传统的数组在Java中存在一些限制，如数...

    Java 实现泛型List

    Java 实现泛型List的源码，基本实现了List接口的全部所有方法。欢迎大家发表自己的观点和建议。

    目前软件组织常采用的几种范型

    不同的开发范型适用于不同类型的项目和需求，下面我们将详细探讨五种常见的软件开发范型：瀑布模型、演化模型、增量模型、喷泉模型以及螺旋模型。 1. **瀑布模型**：这是一种线性的开发方法，各阶段按照需求分析、...

    C++多范型设计

    《C++多范型设计》是一本深入探讨C++编程语言中模板技术的专著，由知名软件工程师James O. Coplien撰写，并由鄢爱兰、周辉等翻译成中文版，ISBN号为9787508318240。这本书的核心主题是C++中的泛型编程，它是C++编程...

    c#中的泛型

    泛型:泛型是程序设计语言的一种特性，通过参数类型来实现在同一封代码上操作多个数据类型，例如List 泛型的作用：提高了性能，避免了装箱拆箱，提高了代码的重用性，

    浅析c#范型中的特殊关键字where &amp; default

    以下是对c#范型中的特殊关键字where和default进行了详细的介绍，需要的朋友可以过来参考下

    论文研究-消息传递范型与C/S范型双范型的主数据管理机制 .pdf

    传统的数据一致性的维护方法有事务控制法、消息队列法和数据复制法。事务控制法在本地数据库之间的一致性维护中表现良好，但在异构和远程数据库环境下的应用存在局限性。消息队列法能够通过消息队列服务在不同数据库...

    Reflector(.Net映射)

    - **代码分析**：识别代码结构，如类、方法、属性等，并以树状视图展示。 - **依赖关系分析**：显示程序集之间的依赖关系，帮助理解代码的整体架构。 - **插件支持**：通过扩展插件，如CodeDigger、...

    浅谈程序设计语言中四种语言范型的区别.pdf

    程序设计语言中的四种主要语言范型分别是过程式、面向对象、函数式和声明式。每种范型都有其独特的设计理念和特点，适用于不同的编程场景。 **过程式编程**（Imperative Programming）： 过程式编程语言基于冯·...

    C# Tracker Starter Kit 修正版

    例如，在C#中的List类就是一个范型类，T代表一个未知的类型，你可以将任何类型的对象（如int、string或自定义类）放入List中。在Tracker Starter Kit修正版中，可能使用了范型来实现更通用的数据结构或算法，以提高...

    Java 范型攻略篇

    Java范型的核心概念是参数化类型（Parameterized Types），即允许在类、接口或方法中声明类型参数，从而在使用这些结构时可以指定具体的类型。例如，`ArrayList`在Java 1.5中被重构为`ArrayList&lt;T&gt;`，这里的`T`就是...

    Java 范型Java 范型.doc

    Java 范型Java 范型

    C++ 多范型设计

    在C++编程语言中，多范型设计是一种强大的技术，它允许程序员编写具有高度灵活性和通用性的代码。这种设计方法可以提高代码的重用性，减少代码量，并且能够适应不同类型的参数。本文将深入探讨C++中的多范型设计，...

    jdk1.5中的范型

    ### JDK 1.5 中的范型 #### 引言 自 JDK 1.5 开始，Java 语言正式引入了一项重要的特性——泛型（Generics），这使得 Java 成为了一个更为强大且灵活的语言。泛型允许开发人员编写出类型安全的通用类或方法，从而...

Magicbox
Global site tag (gtag.js) - Google Analytics