.NET/C#中对自定义对象集合进行自定义排序的方法

时间：2023-03-09 00:09:18
.NET/C#中对自定义对象集合进行自定义排序的方法

一个集合可否排序，要看系统知不知道排序的规则，像内建的系统类型，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控制升序和降序。

相关文章