【基础】泛型的简单理解

前言

最近工作不是很忙，抽出时间来看看C#中基础的东西，也算是“温故而知新”了，于是就看到了泛型这块儿，看了园子里其他园友的文章，讲的都很到位。这篇文章本着简单、容易理解为前提，记录下我自己对泛型的认识，方便以后查看。

泛型是什么

泛型是一种开放式类型，它的出现保证了我们可以创建类型安全的集合。

泛型的应用场景

<1>当一种逻辑适用于多种数据类型时，可以采用泛型，简化代码，提高代码的复用性。

<2>避免不必要的装箱(Boxing)和拆箱(Unboxing)操作。

<3>避免不必要的类型强制转换。

下面通过一个自定义的栈，来对上面的应用场景进行解释。

首先定义一个栈，该栈有一个含参构造函数，有三个方法，元素的入栈Push、元素的出栈Pop、元素的输出Out。代码如下：

/// <summary>
/// 自定义栈
/// </summary>
/// <typeparam name="?"></typeparam>
class Stack
{
    private int[] arr;
    private int length = 0;
    private int topElement;

    /// <summary>
    /// 设置或获取栈顶元素
    /// </summary>
    public int TopElement
    {
        get
        {
            this.topElement= arr[length-1];
            return this.topElement;
        }
        set
        {
            this.topElement = value;
        }
    }

    /// <summary>
    /// 栈中已存在元素数量
    /// </summary>
    public int Length
    {
        get { return this.length; }
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="m"></param>
    public Stack(int m)
    {
        this.arr = new int[m];
    }

    /// <summary>
    /// 将栈顶元素出栈
    /// </summary>
    /// <returns></returns>
    public int Pop()
    {
        if (this.length <= 0)
            return -1;
        else
        {
            int popElement = this.topElement;
            arr[this.length-1] = 0;
            this.length = this.length - 1;
            return popElement;
        }
    }

    /// <summary>
    /// 将元素入栈
    /// </summary>
    /// <param name="item">目标元素</param>
    public void Push(int item)
    {
        if (length >= this.arr.Length) return;
        this.arr[length] = item;
        this.topElement = this.arr[length];
        this.length = this.length + 1;
    }

    /// <summary>
    /// 输出栈内所有元素
    /// </summary>
    /// <param name="stack">目标栈</param>
    public void Out(Stack stack)
    {
        if (stack.arr.Length <= 0) return;
        foreach (int item in arr)
        {
            Console.WriteLine(item);            
        }
        Console.ReadLine();
    }
}

以上代码可以正常运行，实现了一个栈的基本功能，但是我想把这个逻辑放在string类型上也通用，怎么办？有人说那好办，把int替换成string就好咯，代码如下：

/// <summary>
/// 自定义栈
/// </summary>
/// <typeparam name="?"></typeparam>
class StringStack
{
    private string[] arr;
    private int length = 0;
    private string topElement;

    /// <summary>
    /// 设置或获取栈顶元素
    /// </summary>
    public string TopElement
    {
        get
        {
            this.topElement = arr[length - 1];
            return this.topElement;
        }
        set
        {
            this.topElement = value;
        }
    }

    /// <summary>
    /// 栈中已存在元素数量
    /// </summary>
    public int Length
    {
        get { return this.length; }
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="m"></param>
    public StringStack(int m)
    {
        this.arr = new string[m];
    }

    /// <summary>
    /// 将栈顶元素出栈
    /// </summary>
    /// <returns></returns>
    public string Pop()
    {
        if (this.length <= 0)
            return "Empty";
        else
        {
            string popElement = this.topElement;
            arr[this.length - 1] = string.Empty;
            this.length = this.length - 1;
            return popElement;
        }
    }

    /// <summary>
    /// 将元素入栈
    /// </summary>
    /// <param name="item">目标元素</param>
    public void Push(string item)
    {
        if (length >= this.arr.Length) return;
        this.arr[length] = item;
        this.topElement = this.arr[length];
        this.length = this.length + 1;
    }

    /// <summary>
    /// 输出栈内所有元素
    /// </summary>
    /// <param name="stack">目标栈</param>
    public void Out(StringStack stack)
    {
        if (stack.arr.Length <= 0) return;
        foreach (string item in arr)
        {
            Console.WriteLine(item);
        }
        Console.ReadLine();
    }
}

经过测试发现，上面的栈也可以正常工作了，但是问题又来了，我想把这个栈的逻辑再应用到long类型上怎么办？聪明的人不会在同一个问题上绊倒三次，既然有那么多类型需要用到这个栈的逻辑，那我索性就给他来个Object，这下总可以了吧~于是Object类型的栈横空出世，代码如下：

/// <summary>
/// 自定义栈
/// </summary>
/// <typeparam name="?"></typeparam>
class ObjectStack
{
    private object[] arr;
    private int length = 0;
    private object topElement;

    /// <summary>
    /// 设置或获取栈顶元素
    /// </summary>
    public object TopElement
    {
        get
        {
            this.topElement = arr[length - 1];
            return this.topElement;
        }
        set
        {
            this.topElement = value;
        }
    }

    /// <summary>
    /// 栈中已存在元素数量
    /// </summary>
    public int Length
    {
        get { return this.length; }
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="m"></param>
    public ObjectStack(int m)
    {
        this.arr = new object[m];
    }

    /// <summary>
    /// 将栈顶元素出栈
    /// </summary>
    /// <returns></returns>
    public object Pop()
    {
        if (this.length <= 0)
            return null;
        else
        {
            object popElement = this.topElement;
            arr[this.length - 1] = null;
            this.length = this.length - 1;
            return popElement;
        }
    }

    /// <summary>
    /// 将元素入栈
    /// </summary>
    /// <param name="item">目标元素</param>
    public void Push(object item)
    {
        if (length >= this.arr.Length) return;
        this.arr[length] = item;
        this.topElement = this.arr[length];
        this.length = this.length + 1;
    }

    /// <summary>
    /// 输出栈内所有元素
    /// </summary>
    /// <param name="stack">目标栈</param>
    public void Out(ObjectStack stack)
    {
        if (stack.arr.Length <= 0) return;
        foreach (object item in arr)
        {
            Console.WriteLine(item);
        }
        Console.ReadLine();
    }
}

经过重构之后，这个栈逻辑可以适用于任何类型，这是毫无疑问的，但是还有一个问题，来看调用的代码：

static void Main(string[] args)
{
    ObjectStack ostd = new ObjectStack(3);
    ostd.Push(true);
    ostd.Push("http://www.cnblogs.com/xhb-bky-blog/");
    ostd.Push(12);

    int a = (int)ostd.Pop();
    string b = ostd.Pop().ToString();
    bool c = (bool)ostd.Pop();
    Console.ReadLine();
}
        

在调用代码中，我们居然看到了装箱和拆箱操作，而装箱操作和拆箱操作是要额外耗费cpu和内存资源的。再来看下面一段代码：

        static void Main(string[] args)
        {            
            ObjectStack ostd = new ObjectStack(3);
            Good good1 = new Good("pencil", 5);
            Good good2 = new Good("eraser", 2);
            Good good3 = new Good("pencilbox", 15);
            
            ostd.Push(good1);
            ostd.Push(good2);
            ostd.Push(good3);

            Good mygood = (Good)ostd.Pop();//注意
            Console.ReadLine();
        }

上面的代码中发生了类型强制转换，这表明该段代码是不安全的，虽然可以通过编译，但是如果类型对应不上，就会把错误推迟到运行期。为了解决上面的三个问题，泛型应运而生，来看一下泛型是如何解决这些问题的，看代码：

/// <summary>
/// 自定义栈
/// </summary>
/// <typeparam name="T"></typeparam>
class Stack<T> where T:IComparable
{
    private T[] arr;
    private int length = 0;
    private T topElement;

    /// <summary>
    /// 设置或获取栈顶元素
    /// </summary>
    public T TopElement
    {
        get
        {
            this.topElement = arr[length - 1];
            return this.topElement;
        }
        set
        {
            this.topElement = value;
        }
    }

    /// <summary>
    /// 栈中已存在元素数量
    /// </summary>
    public int Length
    {
        get { return this.length; }
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="m"></param>
    public Stack(int m)
    {
        this.arr = new T[m];
    }

    /// <summary>
    /// 将栈顶元素出栈
    /// </summary>
    /// <returns></returns>
    public T Pop()
    {
        //T t = new T();//必须声明new
        if (this.length <= 0)
            return default(T);
        else
        {
            T popElement = this.topElement;
            arr[this.length - 1] = default(T);
            this.length = this.length - 1;
            return popElement;
        }
    }

    /// <summary>
    /// 将元素入栈
    /// </summary>
    /// <param name="item">目标元素</param>
    public void Push(T item)
    {
        if (length >= this.arr.Length) return;
        this.arr[length] = item;
        this.topElement = this.arr[length];
        this.length = this.length + 1;
    }

    /// <summary>
    /// 输出栈内所有元素
    /// </summary>
    /// <param name="stack">目标栈</param>
    public void Out(Stack<T> stack)
    {
        if (stack.arr.Length <= 0) return;
        foreach (T item in arr)
        {
            Console.WriteLine(item);
        }
        Console.ReadLine();
    }
}

在泛型中，类名后面的Stack<T>中的T表示它操作的是一个未指定的数据类型，也称为开放式类型，因为T是一个不明确的类型，在实例化的时候才能知道T的实际类型是什么，实例化之后也就变成了封闭式类型，如Stack<String>，因为Stack<String>已经明确了T是String类型的。另外一点，Stack<String>和Stack<T>没有任何继承上的关系，而是两种完全独立的类型。下面来看下泛型的神奇之处吧：

static void Main(string[] args)
{
    Stack<int> std = new Stack<int>(2);
    std.Push(21);
    std.Push("Hello");//编译不通过，保证了类型安全
    int a = std.Pop();//未发生拆装箱

    Stack<Good> stdg = new Stack<Good>(2);
    Good sell = new Good("box", 10);
    stdg.Push(sell);
    Good buy = stdg.Pop();//未发生强制类型转换
    Console.ReadLine();
}

总结

以上是泛型的简单应用，实际应用中，泛型还有很多其他的特性，如泛型的约束、泛型的方法、接口、委托以及继承等。要理解这些特性，需要把基础打好，熟练掌握泛型的应用场景，才能事半功倍。