C#基础之泛型

C#泛型　　

　　.Net1.1版本最后诟病的一个缺陷就是没有提供对泛型的支持。通过使用泛型，可以极大的提高代码的重用性。

　　以下一个简单的案例来说明使用泛型带来的好处，先看一段代码　　

public class SortHelper
    {
        /// <summary>
        /// int[]冒泡排序
        /// </summary>
        /// <param name="array">int[]</param>
        public void BubbleSort(int[] array)
        {
            int length = array.Length;
            for (int i = 0; i < length - 1; i++)
            {
                for (int j = length - 1; j > 0; j--)
                {
                    if (array[j] < array[j - 1])
                    {
                        int temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                    }
                }
            }
        }
    }

　　在没有接触过泛型的时候，这是一个完美的冒泡排序算法。可是问题来了，如果要对一个byte，char，string数组进行冒泡排序呢，总不能又重复一遍上面的代码吧，这时候泛型就蹦出来了。再看下面这一段代码

public class SortHelper<T>
    {
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="array">T[]</param>
        public void BubbleSort(T[] array)
        {
            int length = array.Length;
            for (int i = 0; i < length - 1; i++)
            {
                for (int j = length - 1; j > 0; j--)
                {
                    if (array[j] < array[j - 1])    //注意：泛型后，这两个对象是不能再用“<”进行比较的，会编译失败的。
                    {
                        T temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                    }
                }
            }
        }
    }

　　既然像上面说的那样，泛型后不能用“<”进行比较了，编译都通过不了，那这个泛型有啥用呢。这时候.Net内置的一个接口就起作用了，IComparable以及IComparable<T>；后一个是前一个的泛型版本，带来的好处就是减少了装箱拆箱；继承IComparable,实现CompareTo方法。对象进行计较的时候调用即可（CompareTo比较后会返回三个值1，-1，0）。所以上面的“<”可以改成 array[j].CompareTo(array[j - 1]) < 0；这时候你会惊讶的发现，array[j]没有这个方法啊。其实会出现不能用“<”，以及没有CompareTo方法的问题。都是因为编译器不知道你的T再将来会是什么类型。所以我们得告诉它。

　　这时候，泛型约束又出来了。泛型约束就比较简单了，写着也简单了；比起上面的代码，也就多了一个 where T : IComparable<T>；这个也很好理解，也就是这个T必须是实现了IComparable<T>的一个类型；

public class SortHelper<T> where T : IComparable<T>
    {
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="array">T[]</param>
        public void BubbleSort(T[] array)
        {
            int length = array.Length;
            for (int i = 0; i < length - 1; i++)
            {
                for (int j = length - 1; j > 0; j--)
                {
                    if (array[j].CompareTo(array[j - 1]) < 0)    //注意：泛型后，这两个对象是不能再用“<”进行比较的
                    {
                        T temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                    }
                }
            }
        }
    }

到此，不管什么类型，只要实现了IComparable<T>接口的，就都能比较了；比如下面自定义的一个类

public class Book : IComparable<Book>
    {
        public int Price { get; set; }

        public string Name { get; set; }

        
        public int CompareTo(Book other)
        {
            //这里面的比较代码，爱咋写咋写，爱咋比较咋比较，全部取决于你自己发挥  
            if (this.Price.CompareTo(other.Price) == 0)
            {
                return 0;
            }
            else if (this.Price.CompareTo(other.Price) > 0)
            {
                return 1;
            }
            return -1;
        }
    }

这样的话，就我们自定义一个的Book类，对Book[] 也能进行冒泡排序了。

        static void Main(string[] args)
        {
            Book[] books = new Book[3]
            {
                new Book() { Price = 300, Name = "明朝那些事1" },
                new Book() { Price = 100, Name = "明朝那些事2" },
                new Book() { Price = 200, Name = "明朝那些事3" }
            };
            SortHelper<Book> sorthelper = new SortHelper<Book>();
            sorthelper.BubbleSort(books);

            foreach (var item in books)
            {
                Console.WriteLine("Price:{0},Name{1}", item.Price, item.Name);
            }

            Console.Read();
        }

 

Ps：以上数据来源于《.Net之美》所读；