【C#拾遗】——泛型

我会带着你远行 2022-07-14 05:42 204阅读 0赞

泛型在程序开发中经常应用的技术，小编也是从第一个项目就开始用，平常就是直接用，关于理论方面的知识还是知道甚少，所以小编算是重新学习泛型吧。

# 是什么？ #

## **定义：** ##

在程序编码中一些包含类型参数的类型，可以说泛型的参数只可以代表类，不能是个别的对象。主要目的就是加强类型安全及减少类转换的次数。

## 何处此言？——不使用泛型的问题 ##

Demo——分别给int\[\]，byte\[\]，char\[\]三种类型的数组排序。

不使用泛型之前

Int\[\]

public class SortHelper {
        public void BubbleSort(int[] array) {
            int length = array.Length;
    
    
            for (int i = 0; i <= length - 2; i++) {
                for (int j = length - 1; j >= 1; j--) {
    
    
                    // 对两个元素进行交换
                    if (array[j] < array[j - 1]) {
                        int temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                    }
                }
            }
        }

Byte\[\]

public class SortHelper {
        public void BubbleSort(Byte[] array) {
            int length = array.Length;
    
            for (int i = 0; i <= length - 2; i++) {
                for (int j = length - 1; j >= 1; j--) {
    
                    // 对两个元素进行交换
                    if (array[j] < array[j - 1]) {
                        byte temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                    }
                }
            }
        }

Char\[\]

public class SortHelper {
        public void BubbleSort(char[] array) {
            int length = array.Length;
    
            for (int i = 0; i <= length - 2; i++) {
                for (int j = length - 1; j >= 1; j--) {
    
                    // 对两个元素进行交换
                    if (array[j] < array[j - 1]) {
                        char temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                    }
                }
            }
        }

仔细观察，发现三段代码基本一致，如果按上面方式写，那么这个排序算也是封装的太烂了！

怎么用？

于是就开始想办法，改成我们期待中的样子

public classSortHelper<T> {
        public void BubbleSort(T[] array){
            // 方法实现体
        }
    }

## 类型参数 ##

这个时候引入了T——**类型参数**，进而引出了**类型参数约束**，要求实现比较方法IComparable

定义book类

public class Book :IComparable{
            private int id;
            private string title;
    
            public Book() { }
    
            public Book(int id, string title) {
                this.id = id;
                this.title = title;
            }
            public int Id {
                get { return id; }
                set { id = value; }
            }
    
            public string Title
            {
                get { return title; }
                set { title = value; }
            }

排序类

public class SortHelper <T> where T:IComparable{
            public void BubbleSort(T[] array)
            {
                int length = array.Length;
    
                for (int i = 0; i <= length - 2; i++)
                {
                    for (int j = length - 1; j >= 1; j--)
                    {
    
                        // 对两个元素进行交换
                        if (array[j] < array[j - 1]）
                        {
                            T temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                        }
                    }
                }
            }
        }

**客户端**

static void Main(string[] args)
            {
                Book[] bookArray = new Book[2];
    
                Book book1 = new Book(124, "贾文静");
                Book book2 = new Book(45, "文静");
    
                bookArray[0] = book1;
                bookArray[1] = book2;
    
                SuperCalculator<Book> sorter = new SuperCalculator<Book>();
                sorter.SuperSort(bookArray);
              
                foreach (Book b in bookArray)
                {
                    Console.WriteLine("Id:{0}", b.Id);
                    Console.WriteLine("Title:{0}\n", b.Title);
                }
                Console.ReadKey();
            }

如果真的去运行这个程序肯定会提示，参数类型的问题，id和title那个比较为准？

**类型参数约束**目的是为了告诉SortHelper<T>类（准确说是告诉编译器），它所接受的T类型参数必须能够进行比较，换言之，就是实现IComparable接口。

修改Book类

修改排序类

public class SortHelper <T> where T:IComparable{
            public void BubbleSort(T[] array)
            {
                int length = array.Length;
    
                for (int i = 0; i <= length - 2; i++)
                {
                    for (int j = length - 1; j >= 1; j--)
                    {
    
                        // 对两个元素进行交换
                        if (array[j].CompareTo(array[j - 1]) < 0)
                        {
                            T temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                        }
                    }
                }
            }
        }

## **泛型方法 ** ##

**  **

现在看泛型是用在这个类上的，假如类中只有一个方法需要使用泛型，那么如果放到类中，那么就是对同类中其他方法的污染。这个时候就有了泛型方法——把类型参数T加到方法上，降低T的作用范围。

public class SuperCalculator
        {
            public void SpeedSort<T>(T[] array) where T : IComparable
            {
                int length = array.Length;
    
                for (int i = 0; i <= length - 2; i++)
                {
                    for (int j = length - 1; j >= 1; j--)
                    {
    
                        // 对两个元素进行交换
                        if (array[j].CompareTo(array[j - 1]) < 0)
                        {
                            T temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                        }
                    }
                }
            }
        }

客户端调用

SuperCalculator calculator = new SuperCalculator();
    calculator.SpeedSort<Book>(bookArray);

现在看其实泛型方法和普通方法没有什么区别了。

# 泛型到底有什么好处！！ #

1、提高性能，类型安全和质量，减少重复性的编程任务

2、泛型类型携带了丰富的元数据，应用程度强大与反射技术。

3、使用起来非常的灵活，不用为具体不同的重载方法写具体的代码。

【总结】

利用一些Demo希望不显得那么理论吧。关于泛型无论是在.NET还是Java都是非常成熟的一项技能，为我们的程序开发带来莫大的好处。好好学习，好好利用。