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

最新推荐文章于 2022-10-28 15:07:14 发布
最新推荐文章于 2022-10-28 15:07:14 发布
阅读量3.4k 收藏
点赞数
分类专栏： C# 文章标签： C# 集合类 排序 linq
C# 专栏收录该内容
85 篇文章 18 订阅 ¥9.90 ¥99.00
订阅专栏

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

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

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

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

namespace 对集合对象进行排序
{
    class Product : IComparable
    {
        public string Name
        {
            get;
            private set;
        }
        public decimal Price
        {
            get;
            private set;
        }
        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
        public Product()
        {
        }
        public static List<Product> GetSampleProduct()
        {
            return new List<Product> 
            { 
                new Product { Name = "Watch", Price = 12345.56m }, 
                new Product { Name = "Knife", Price = 224.50m },
                new Product { Name = "EZpe", Price = 12.50m }, 
                new Product { Name = "ETorch", Price = 58.5m } };
        }
        public override string ToString()
        {
            return string.Format("{0} : {1}", Name, Price);
        }
        int IComparable.CompareTo(object obj)
        {
            Product temp = (Product)obj;
            return this.Name.CompareTo(temp.Name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<Product> ProductSample = Product.GetSampleProduct();
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
            Console.WriteLine();
            ProductSample.Sort();
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
            Console.ReadKey();
        }
    }
}

其中最主要的是这句：

 　　class Product :IComparable

跟这句：

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

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

2，指定IComparer  类的对象。 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SortTeset2
{
    class Product
    {
        public string Name
        {
            get;
            private set;
        }
        public decimal Price
        {
            get;
            private set;
        }
        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
        public Product()
        {
        }
        public static List<Product> GetSampleProduct()
        {
            return new List<Product> 
            { 
                new Product { Name = "Watch", Price = 12345.56m }, 
                new Product { Name = "Knife", Price = 224.50m },
                new Product { Name = "Rope", Price = 12.50m }, 
                new Product { Name = "ETorch", Price = 58.5m }
            };
        }
        public override string ToString()
        {
            return string.Format("{0} : {1}", Name, Price);
        }
    }
    class ProductNameComparer : IComparer<Product>
    {
        public int Compare(Product first, Product second)
        {
            return first.Name.CompareTo(second.Name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<Product> ProductSample = Product.GetSampleProduct();
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
            Console.WriteLine();
            ProductSample.Sort(new ProductNameComparer());
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
        }
    }
}

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

ProductSample.Sort(new ProductNameComparer());

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

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

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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SortTeset3
{
    class Product
    {
        public string Name
        {
            get;
            private set;
        }
        public decimal Price
        {
            get;
            private set;
        }
        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
        public Product()
        {
        }
        public static List<Product> GetSampleProduct()
        {
            return new List<Product> 
            {
                new Product { Name = "Watch", Price = 12345.56m },
                new Product { Name = "Knife", Price = 224.50m },
                new Product { Name = "Rope", Price = 12.50m }, 
                new Product { Name = "ETorch", Price = 58.5m } 
            };
        }
        public override string ToString()
        {
            return string.Format("{0} : {1}", Name, Price);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<Product> ProductSample = Product.GetSampleProduct();
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
            Console.WriteLine();
            ProductSample.Sort(delegate(Product first, Product second)
            {
                return first.Name.CompareTo(second.Name);
            });
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
        }
    }
}

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

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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SortTeset3
{
    class Product
    {
        public string Name
        {
            get;
            private set;
        }
        public decimal Price
        {
            get;
            private set;
        }
        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
        public Product()
        {
        }
        public static List<Product> GetSampleProduct()
        {
            return new List<Product> 
            {
                new Product { Name = "Watch", Price = 12345.56m },
                new Product { Name = "Knife", Price = 224.50m },
                new Product { Name = "Rope", Price = 12.50m }, 
                new Product { Name = "ETorch", Price = 58.5m } 
            };
        }
        public override string ToString()
        {
            return string.Format("{0} : {1}", Name, Price);
        }
    }
    class Program39
    {
        static void Main(string[] args)
        {
            List<Product> ProductSample = Product.GetSampleProduct();
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
            Console.WriteLine();
            ProductSample.Sort((first, second) => first.Name.CompareTo(second.Name));
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
        }
    }
}

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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SortTeset3
{
    class Product
    {
        public string Name
        {
            get;
            private set;
        }
        public decimal Price
        {
            get;
            private set;
        }
        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
        public Product()
        {
        }
        public static List<Product> GetSampleProduct()
        {
            return new List<Product> 
            {
                new Product { Name = "Watch", Price = 12345.56m },
                new Product { Name = "Knife", Price = 224.50m },
                new Product { Name = "Rope", Price = 12.50m }, 
                new Product { Name = "ETorch", Price = 58.5m } 
            };
        }
        public override string ToString()
        {
            return string.Format("{0} : {1}", Name, Price);
        }
    }
    class Program39
    {
        static void Main(string[] args)
        {
            List<Product> ProductSample = Product.GetSampleProduct();
            foreach(Product tmp in ProductSample)
            {
                Console.WriteLine(tmp);
            }
            Console.WriteLine();
            foreach(Product tmp in ProductSample.OrderBy(p => p.Name))
            {
                Console.WriteLine(tmp);
            }
        }
    }
}


 

“这里似乎调用了一个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>{ 
  
     private ComparisonType type;
  
     public BookComparison(ComparisonType type)
  
     {         this .type = type;    }
  
     public int Compare(Book x, Book y)
  
     {
  
         switch ( this .type) 
  
        {
  
             case ComparisonType.Price:
  
                 return x.Price.CompareTo(y.Price);
  
                 break ;
  
             case ComparisonType.PublishDate:
  
                 return x.PublishDate.CompareTo(y.PublishDate);
  
                 break ;
  
             default :
  
                 break ;
  
         }
  
         return 0;
  
     }
  
}
  
添加一个ComparisonType结构，在BookComparson初始化时决定Comparison的方式：
  
//04 Sort by custom comparison: BookComparison
  
bs.Books.Sort( new BookComparison(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  in list)
  
{
  
     Console.WriteLine( string .Format( "{0}:{1}, {2}" , item.Name, item.Price, item.PublishDate.ToString()));
  
}
  
orderby子句可以选择任意的排序条件，同时ascending或者descending控制升序和降序。
暖杨下的好日子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
C#自定义类型排序
大红苹果甜的博客
06-09 798
在编写程序处理数据时经常需要对自己组织的数据进行排序，有时还是不同形式的排序，在C++中可以自定义结构体重载bool operator<()函数，也可以自己写int compare()。而在C#中自定义排序，就需要对类的IComparer<>接口进行实现，排序时调用Sort()方法时将实现的排序接口作为参数传入即可。 本文同步更新在 https://www.malic.xyz/archives/1745 假定现在有一组学生的三门课成绩 class student { publi
c#自定义ordreby的排序方式
weixin_43935474的博客
06-24 484
有一个类队列，需要按组名进行排序，直接按string排序不行，得自定义orderby()来排序
C#中自定义排序的三种用法
有趣的博客
06-13 1958
自定义sort三种写法 1. 使用接口IComparable 2. 使用委托回调和lambad表达式 3. 使用接口IComparer 我们先定义一个学生类 public class Student { //学生的编码 public int Id { get; set; } //学生的年龄 public int Age { get; set; } } 排序规则 1 ID小的排前面 2 ID相同的，Age小的排前面 第一种做法（实现IComparable接口）
order by 按照指定顺序排序或自定义顺序排序
u014644574的博客
08-11 7388
今天 突然 接到了一个需求改动 是这样的 假设 A （0,1,2,3,4）字段有几个值 则按照这个值进行不规则的排序（2,1,4,3,0） 这样的话就会没有规律去进行排序，值可以自己进行自定义排序我用到了这个方法 order by A WHEN '2' THEN 1 WHEN '1'THEN 2 WHEN '4' THEN 3 WHEN '3' THEN 4 WHEN '0' THEN 5 END 具体讲解一下 order by 后面是需要进行排序的字段，WHEN 是值 ...
order by 自定义排序
weixin_30470643的博客
12-21 914
使用order by排序，有时候不是根据字符或数字顺序，而是根据实际要求排序。 例如有客户A,B,C，我希望排序结果是B,C,A，那么就要通过自定义的规则排序。 第一种方法，可以构造一张映射表，将客户映射到所需要的顺序。 第二种方法，如果要排序的客户不多，可以直接写出，那就使用如下方法： order by case customer when B then 1 　　　　　　　　　　　　w...
C#通过IComparable实现ListT.sort()排序
09-04
主要介绍了C#通过IComparable实现ListT.sort()排序的方法,可实现自定义的排序方法,是非常实用的技巧,需要的朋友可以参考下
字典集合按值排序
04-11
有关创建自定义集合（如SortedList）的文章，该集合按值而不是键对条目进行排序。
Linq两个List集合取交集的实现
12-23
C#中Linq查询基本操作使用实例c#中LINQ的基本用法实例C# linq查询之动态OrderBy用法实例C#中的Linq Intersect与Except方法使用实例C#中的Linq to Xml详解LINQ 标准查询操作符linq语法基础使用示例C#使用linq对数组...
SQL学习之使用order by 按照指定顺序排序或自定义顺序排序
热门推荐
日拱一卒无有尽，功不唐捐终入海
07-01 6万+
我们通常需要根据客户需求对于查询出来的结果给客户提供自定义的排序方式，那么我们通常sql需要实现方式都有哪些，参考更多资料总结如下（不完善的和错误望大家指出）： 一、如果我们只是对于在某个程序中的应用是需要按照如下的方式排序，我们只需在SQL语句级别设置排序方式：   1、按照oracled的默认方式排序：select * from table_name order by  col_n
排序：order by 多字段排序、自定义排序、中文排序、其他条件排序
Sucker的小笔记
07-26 2459
部分参考：https://blog.csdn.net/s78365126/article/details/83993862 其他参考已不可查，若有问题请联系及时删除； 目录 一、多字段排序 二、自定义排序 三、中文排序 四、其他条件排序 一、多字段排序 语法： select * from tablename order by column1, column2; 二、自定义排序 ...
c# 自定义排序
weixin_43950528的博客
06-19 455
自定义c#集合排序
.NET 中Newtonsoft的使用 自定义对象的序列化
SieSteven
12-05 1667
.NET 中Newtonsoft的使用 自定义对象的序列化
比较器的初次尝试(二维数组比较器）+（TreeMap比较器:根据KEY的大小排列）+（优先队列）+（Map根据VALUE的大小进行排列）+(重写比较器比较）
WC949464367的博客
12-14 1104
public static void main(String[] args) { int arr[][]=new int[][]{{5,8,1},{3,9,4},{9,10,1}}; int sum[][]=new int[][]{{5,8,1},{3,9,4},{9,10,1}}; Arrays.sort(arr,(a,b)->b[1]-a[1]); //通过对数组每一行的第二列元素大小进行降序排列，从而对二维数组进行重新排列(对比较器的重写) ...
自定义排序比较器compare，可自己定义排序规则例如（1.1.1.2）的排序方法
鹏神丶明月天
10-28 470
【代码】自定义排序比较器compare，可自己定义排序规则例如（1.1.1.2）的排序方法。
使用Comparator比较器进行排序
kd123_hacker的博客
01-09 1956
题目： 地址类： package api1_9作业; import java.util.ArrayList; public class Address { private String name; private String street; private String city; private String country; private String pinCode; /* * 姓名、街道、市(县)、省(自治区)、国家(地区)和代码
（一）、自定义比较器Comparator及其使用
leoBETT的博客
11-09 607
/** * @Description: 自定义比较器及其使用方式 * @author: harold * @date: 2021年11月09日 19:12 */ public class CustomComparator { public static class Student { public String name; public int id; public int age; public Student(Stri.
.net/c#面试手册
最新发布
01-17
在.net/c框架下，开发者可以使用多种编程语言进行开发，例如C#、VB.NET、F#等，这些语言都可以充分利用.net/c平台提供的库和组件，实现快速开发和简化代码编写。.net/c平台还提供了丰富的类库和工具，包括ASP.NET...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值