一个集合可否排序，要看系统知不知道排序的规则，像内建的系统类型，int ,string,short,decimal这些，系统知道怎么排序，而如果一个集合里面放置的是自定义类型，比如自己定义了一个Car类型，要把它排序，系统是不知道怎么办的。

那么，如何告知系统排序的规则呢？有以下几种方法：

1：对类实现IComparable接口，示例如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace 对集合对象进行排序
  6. {
  7. class Product : IComparable
  8. {
  9. public string Name
  10. {
  11. get;
  12. private set;
  13. }
  14. public decimal Price
  15. {
  16. get;
  17. private set;
  18. }
  19. public Product(string name, decimal price)
  20. {
  21. Name = name;
  22. Price = price;
  23. }
  24. public Product()
  25. {
  26. }
  27. public static List<Product> GetSampleProduct()
  28. {
  29. return new List<Product>
  30. {
  31. new Product { Name = "Watch", Price = 12345.56m },
  32. new Product { Name = "Knife", Price = 224.50m },
  33. new Product { Name = "EZpe", Price = 12.50m },
  34. new Product { Name = "ETorch", Price = 58.5m } };
  35. }
  36. public override string ToString()
  37. {
  38. return string.Format("{0} : {1}", Name, Price);
  39. }
  40. int IComparable.CompareTo(object obj)
  41. {
  42. Product temp = (Product)obj;
  43. return this.Name.CompareTo(temp.Name);
  44. }
  45. }
  46. class Program
  47. {
  48. static void Main(string[] args)
  49. {
  50. List<Product> ProductSample = Product.GetSampleProduct();
  51. foreach(Product tmp in ProductSample)
  52. {
  53. Console.WriteLine(tmp);
  54. }
  55. Console.WriteLine();
  56. ProductSample.Sort();
  57. foreach(Product tmp in ProductSample)
  58. {
  59. Console.WriteLine(tmp);
  60. }
  61. Console.ReadKey();
  62. }
  63. }
  64. }

其中最主要的是这句：

　　class Product :IComparable

跟这句：

　　  int IComparable.CompareTo(object obj)
        {
            Product temp = (Product)obj;
            return this.Name.CompareTo(temp.Name);
        }

就是实现了IComparable.CompareTo()这个方法。然后就可以直接调用 SomeProductList.Sort();方法来进行排序。

2，指定IComparer  类的对象。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace SortTeset2
  6. {
  7. class Product
  8. {
  9. public string Name
  10. {
  11. get;
  12. private set;
  13. }
  14. public decimal Price
  15. {
  16. get;
  17. private set;
  18. }
  19. public Product(string name, decimal price)
  20. {
  21. Name = name;
  22. Price = price;
  23. }
  24. public Product()
  25. {
  26. }
  27. public static List<Product> GetSampleProduct()
  28. {
  29. return new List<Product>
  30. {
  31. new Product { Name = "Watch", Price = 12345.56m },
  32. new Product { Name = "Knife", Price = 224.50m },
  33. new Product { Name = "Rope", Price = 12.50m },
  34. new Product { Name = "ETorch", Price = 58.5m }
  35. };
  36. }
  37. public override string ToString()
  38. {
  39. return string.Format("{0} : {1}", Name, Price);
  40. }
  41. }
  42. class ProductNameComparer : IComparer<Product>
  43. {
  44. public int Compare(Product first, Product second)
  45. {
  46. return first.Name.CompareTo(second.Name);
  47. }
  48. }
  49. class Program
  50. {
  51. static void Main(string[] args)
  52. {
  53. List<Product> ProductSample = Product.GetSampleProduct();
  54. foreach(Product tmp in ProductSample)
  55. {
  56. Console.WriteLine(tmp);
  57. }
  58. Console.WriteLine();
  59. ProductSample.Sort(new ProductNameComparer());
  60. foreach(Product tmp in ProductSample)
  61. {
  62. Console.WriteLine(tmp);
  63. }
  64. }
  65. }
  66. }

这儿我们新定义了一个类：ProductNameComparer，这个类实现了泛型接口：IComparer<Product>，然后在

ProductSample.Sort(new ProductNameComparer());

语句中我们提供了一个比较器对象。

这种方法看上去不如直接实现ICompareable接口来得简洁。

这种方法可以用匿名方法进行改进：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace SortTeset3
  6. {
  7. class Product
  8. {
  9. public string Name
  10. {
  11. get;
  12. private set;
  13. }
  14. public decimal Price
  15. {
  16. get;
  17. private set;
  18. }
  19. public Product(string name, decimal price)
  20. {
  21. Name = name;
  22. Price = price;
  23. }
  24. public Product()
  25. {
  26. }
  27. public static List<Product> GetSampleProduct()
  28. {
  29. return new List<Product>
  30. {
  31. new Product { Name = "Watch", Price = 12345.56m },
  32. new Product { Name = "Knife", Price = 224.50m },
  33. new Product { Name = "Rope", Price = 12.50m },
  34. new Product { Name = "ETorch", Price = 58.5m }
  35. };
  36. }
  37. public override string ToString()
  38. {
  39. return string.Format("{0} : {1}", Name, Price);
  40. }
  41. }
  42. class Program
  43. {
  44. static void Main(string[] args)
  45. {
  46. List<Product> ProductSample = Product.GetSampleProduct();
  47. foreach(Product tmp in ProductSample)
  48. {
  49. Console.WriteLine(tmp);
  50. }
  51. Console.WriteLine();
  52. ProductSample.Sort(delegate(Product first, Product second)
  53. {
  54. return first.Name.CompareTo(second.Name);
  55. });
  56. foreach(Product tmp in ProductSample)
  57. {
  58. Console.WriteLine(tmp);
  59. }
  60. }
  61. }
  62. }

这一次，不用定义那个类，然后使用它的方法了，而是直接填充delegate接口。

这种方法还可以进一步用Lambda表达式改进，如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace SortTeset3
  6. {
  7. class Product
  8. {
  9. public string Name
  10. {
  11. get;
  12. private set;
  13. }
  14. public decimal Price
  15. {
  16. get;
  17. private set;
  18. }
  19. public Product(string name, decimal price)
  20. {
  21. Name = name;
  22. Price = price;
  23. }
  24. public Product()
  25. {
  26. }
  27. public static List<Product> GetSampleProduct()
  28. {
  29. return new List<Product>
  30. {
  31. new Product { Name = "Watch", Price = 12345.56m },
  32. new Product { Name = "Knife", Price = 224.50m },
  33. new Product { Name = "Rope", Price = 12.50m },
  34. new Product { Name = "ETorch", Price = 58.5m }
  35. };
  36. }
  37. public override string ToString()
  38. {
  39. return string.Format("{0} : {1}", Name, Price);
  40. }
  41. }
  42. class Program39
  43. {
  44. static void Main(string[] args)
  45. {
  46. List<Product> ProductSample = Product.GetSampleProduct();
  47. foreach(Product tmp in ProductSample)
  48. {
  49. Console.WriteLine(tmp);
  50. }
  51. Console.WriteLine();
  52. ProductSample.Sort((first, second) => first.Name.CompareTo(second.Name));
  53. foreach(Product tmp in ProductSample)
  54. {
  55. Console.WriteLine(tmp);
  56. }
  57. }
  58. }
  59. }

变态的是，还可以进一步改进，使用扩展方法，如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace SortTeset3
  6. {
  7. class Product
  8. {
  9. public string Name
  10. {
  11. get;
  12. private set;
  13. }
  14. public decimal Price
  15. {
  16. get;
  17. private set;
  18. }
  19. public Product(string name, decimal price)
  20. {
  21. Name = name;
  22. Price = price;
  23. }
  24. public Product()
  25. {
  26. }
  27. public static List<Product> GetSampleProduct()
  28. {
  29. return new List<Product>
  30. {
  31. new Product { Name = "Watch", Price = 12345.56m },
  32. new Product { Name = "Knife", Price = 224.50m },
  33. new Product { Name = "Rope", Price = 12.50m },
  34. new Product { Name = "ETorch", Price = 58.5m }
  35. };
  36. }
  37. public override string ToString()
  38. {
  39. return string.Format("{0} : {1}", Name, Price);
  40. }
  41. }
  42. class Program39
  43. {
  44. static void Main(string[] args)
  45. {
  46. List<Product> ProductSample = Product.GetSampleProduct();
  47. foreach(Product tmp in ProductSample)
  48. {
  49. Console.WriteLine(tmp);
  50. }
  51. Console.WriteLine();
  52. foreach(Product tmp in ProductSample.OrderBy(p => p.Name))
  53. {
  54. Console.WriteLine(tmp);
  55. }
  56. }
  57. }
  58. }

“这里似乎调用了一个OrderBy方法，但查阅一下MSDN，就会发现这个方法在List<Product>中根本不存在。之所以能调用它，是由于存在一个扩展方法。这里实际不再是"原地"对列表进行排序，而只是按特定的顺序获取列表的内容。有的时候，你需要更改实际的列表；但有的时候，没有任何副作用的排序显得更"善解人意"。重点在于，现在的写法更简洁，可读性更好（当然是在你理解了语法之后）。我们的想法是"列表按名称排序"，现在的代码正是这样做的。并不是"列表通过将一个产品的名称与另一个产品的名称进行比较来排序"，就像C# 2代码所做的那样。也不是使用知道如何将一个产品与另一个产品进行比较的另一个类型的实例来按名称排序。这种简化的表达方式是C# 3的核心优势之一。既然单独的数据查询和操作是如此的简单，那么在执行更大规模的数据处理时，仍然可以保持代码的简洁性和可读性，这进而鼓励开发者以一种"以数据为中心"的方式来观察世界。”

最后这两步的语法，绝对是一个会用其它语言比如C/C++,VB的人所无法明白的，C#进化速度真是快。。。。。。。

关于排序，暂时还不知道有没有其它的方法，日后再补记。

参考书籍：《C#与.NET3.5高级程序设计》，《深入解析C#》（C# in depth) 。

另外，这篇文章还提到了另外两种更深入的做法：1，自定义排序，可以提供一个接口，接受一个排序指标，然后对指定List进行排序，2，用LINQ的orderby子句实现排序。

“

以自定义方式可以实现的更多的控制，例如我们重构BookComparison：
  
// Release : code01, 2009/04/12
  
 // Author  : Anytao, http://www.anytao.com/
  
 // List    : BookComparison.cs
  
public
 class  BookComparison : IComparer<Book>{ 
  
    privateComparisonType type;
  
    publicBookComparison(ComparisonType type)
  
    {        this.type = type;    }
  
    publicint
Compare(Book x, Book y)
  
    {
  
        switch(this.type) 
  
       {
  
            caseComparisonType.Price:
  
                returnx.Price.CompareTo(y.Price);
  
                break;
  
            caseComparisonType.PublishDate:
  
                returnx.PublishDate.CompareTo(y.PublishDate);
  
                break;
  
            default:
  
                break;
  
        }
  
        return0;
  
    }
  
}
  
添加一个ComparisonType结构，在BookComparson初始化时决定Comparison的方式：
  
//04 Sort by custom comparison: BookComparison
  
bs.Books.Sort(newBookComparison(ComparisonType.PublishDate).Compare); 
  
结论
  
自定义Comparison为实现更好的Sort控制，提供了很好的扩展机制。在我们的实际应用中，对于例如BookStore这样的具体应用而言，我更推荐以LINQ的OrderBy来实现，例如：
  
//05 Sort by Linq
  
var list = from c in
bs.Books
  
           orderby c.PublishDate ascending
  
           select c;
  
foreach(var item inlist)
  
{
  
    Console.WriteLine(string.Format("{0}:{1}, {2}", item.Name, item.Price, item.PublishDate.ToString()));
  
}
  
orderby子句可以选择任意的排序条件，同时ascending或者descending控制升序和降序。

.NET/C#中对自定义对象集合进行自定义排序的方法的更多相关文章

  1. C#中对象，字符串，dataTable、DataReader、DataSet，对象集合转换成Json字符串方法。

    C#中对象,字符串,dataTable.DataReader.DataSet,对象集合转换成Json字符串方法. public class ConvertJson { #region 私有方法 /// ...

  2. JAVA 自定义对象集合 List<T> 根据自定义字段去重

    1.拥有自定义对象 MyUser @Data public class MyUser { private String userName; private String passWord; } 2.编 ...

  3. C#高级知识点概要(3) - 特性、自动属性、对象集合初始化器、扩展方法、Lambda表达式和Linq查询

    1.特性(Attributes) 特性(Attributes),MSDN的定义是:公共语言运行时允许你添加类似关键字的描述声明,叫做attributes, 它对程序中的元素进行标注,如类型.字段.方法 ...

  4. nuxtjs在vue组件中使用window对象编译报错的解决方法

    我们知道nuxtjs是做服务端渲染的,他有很多声明周期是运行在服务端的,以及正常的vue声明周期mounted之前均是在服务端运行的,那么服务端是没有比如window对象的location.navag ...

  5. OBjective-C:在可变数组NSMutableArray中添加相同对象后,进行自定义的排序方式输出

    以下为自定义的排序方式的实现 #import "Person+Compare.h" @implementation Person (Compare) -(NSComparisonR ...

  6. C#中在比较自定义对象的时候要重写Equals方法

    using System;using System.Collections.Generic;using System.Text; namespace Equal{    using System; c ...

  7. Java中利用MessageFormat对象实现类似C# string.Format方法格式化

    我们在写C#代码的时候常常会使用到string.Format("待格式化字符串{0},{1},....",参数1,参数2,...),来格式化字符串,特别是拼接字符的时候,这种方式使 ...

  8. hibernate中对象集合的保存

    一.在java web设计中经常使用对象进行操作,在hibernate中对象集合的保存(一对多) 1需要进行如下步骤: 1) 设计数据表关系 2)引入jar包,需要注意引入数据库connector 3 ...

  9. 《java入门第一季》之HashSet存储自定义对象问题以及注意事项

    上一篇http://blog.csdn.net/qq_32059827/article/details/51578158 写到存储字符串类型的时候出现了无序,而且这个无序不是随机那种无序,它是有一定存 ...

随机推荐

  1. [Web 前端] 你不知道的 React Router 4

    cp from https://segmentfault.com/a/1190000010718620 几个月前,React Router 4 发布,我能清晰地感觉到来自 Twitter 大家对新版本 ...

  2. Error:(13, 60) java: 程序包com.sun.tools.internal.xjc.reader.xmlschema.bindinfo不存在

    我在import maven项目时,pom.xml报错Missing artifact com.sun:tools:jar:1.5.0,经过盘查发现是pom引入的struts2相关jar包导致报错. ...

  3. pthread_create 报函数参数不匹配问题

    pthread_create方法遇到类方法时总会报  argument of type ‘void* (Thread::)(void*)’ does not match ‘void* (*)(void ...

  4. freemarker怎么把数据显示到页面中？

    第一步  创建一个User.java文件 来两个变量       public class User {       private String userName;         private ...

  5. AD各种布线方法总结

    1.常规布线:不详细说了,是个人就知道怎么弄.需要说明的是在布线过程中,可按小键盘的*键或大键盘的数字2键添加一个过孔:按L键可以切换布线层:按数字3可设定最小线宽.典型线宽.最大线宽的值进行切换. ...

  6. JavaScript-手机中访问页面判断

    最近在做微信服务号开发,其中遇到一个问题是微信服务号查看的个人的消息,如果点击在浏览器中查看(iOS中是在Safari中打开)应该是跳转到登录页面,因为页面需要从后台获取,因为需要服务端判断,如果是存 ...

  7. iOS开发-ViewController的生命周期和切换

    ViewController在App开发中是至关重要的一环,无论是页面的展示和数据之间的交互,ViewController提供了一个框架可以管理和构建App应用.iOS中构建App提供了两种方式一种是 ...

  8. oracle归档日志的操作

                 oracle利用重做日志文件记录对数据库的操作.可是重做日志文件组是循环使用的,当所有的日志文件都被填满时,系统自己主动切换到第一组日志文件,当然数据库管理员也能够使用命令手 ...

  9. 梯度消失（vanishing gradient）与梯度爆炸（exploding gradient）问题

    (1)梯度不稳定问题: 什么是梯度不稳定问题:深度神经网络中的梯度不稳定性,前面层中的梯度或会消失,或会爆炸. 原因:前面层上的梯度是来自于后面层上梯度的乘乘积.当存在过多的层次时,就出现了内在本质上 ...

  10. Python 和 Asyncio 编写在线多人游戏（一）

    在技术和文化领域,大规模多人在线游戏(MMO)毋庸置疑是我们当今世界的潮流之一.很长时间以来,写一个 MMO 游戏这件事总是会涉及到大量的预算与复杂的底层编程技术.不过在最近这几年,事情迅速发生了变化 ...