C#集合排序

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

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

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

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

namespace SortTeset
{
    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="Rope",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);
            }
        }
    }
}

其中最主要的是这句：

 　　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 SortTest2
{
    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 SortTest3
{
    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 SortTest4
{
    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((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 SortTest5
{
    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();

            foreach (Product tmp in ProductSample.OrderBy(p => p.Name))
            {
                Console.WriteLine(tmp);
            }
        }
    }
}

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

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

再来看看另外一位大神对student类的排序

student类：

public class Student
{
    public string name;
    public int num;
    
    //下面是一些方法及属性
    // ......
}

排序一：

List<Student> students = new List<Student>();
List<Student> sortedStudents = students.OrderBy(s => s.num).ToList();

逆序：

List<Student> sortedStudents = students.OrderByDescending(s => s.num).ToList();

排序二（Sort）：

students.Sort(delegate(Student a, Student b) { return a > b; });

排序三：

List<Student> students = new List<Student>();
//Linq
List<Student> sortedStudents = students.OrderByDescending(s => s.num).ToList();
//List.Sort
students.Sort((Comparison<Student>)delegate(Student a, Student b) { return a.num > b.num ? 1 : a.num == b.num ? 0 : -1; });
//Array.Sort
Array.Sort(students.ToArray(), (Comparison<Student>)delegate(Student a, Student b) { return a.num > b.num ? 1 : a.num == b.num ? 0 : -1; });

排序四：

//ps
//Array.Sort
Array.Sort(students.ToArray(), (Comparison<Student>)delegate(Student a, Student b) { return a.num > b.num ? 1 : a.num == b.num ? 0 : -1; });

//这只是例子，实际不能这么写哦。需要写
Student[] SortedArray = students.ToArray();
Array.Sort(SortedArray, (Comparison<Student>)delegate(Student a, Student b) { return a.num > b.num ? 1 : a.num == b.num ? 0 : -1; });