《CLR Via C# 第3版》笔记之(十三) – 泛型基础

.net2.0发端就引入了泛型的建制,泛型有助于我们贯彻“算法重用”。

凭借泛型机制,大家能够少定义一些重载函数,同时还是可以担保项目安全性。泛型的语法万分不难,上面通过例子来演示泛型的一部分施用。

重中之重内容:

  • 减去装箱/拆箱(升高质量)
  • 界定泛型参数的品类
  • 节点类型分歧的链表

1.
滑坡装箱/拆箱(提升品质)

俺们都通晓,.net中的额装箱/拆箱操作很是有害品质,通过运用泛型,能够使得的滑坡大家代码中的装箱拆箱操作,从而进步代码的特性。

实例代码如下:

using System;
using System.Collections.Generic;
using System.Collections;

class CLRviaCSharp_13
{
    static void Main(string[] args)
    {
        List<Int32> lst = new List<int>();
        lst.Add(1);
        Int32 i = lst[0];

        ArrayList arr = new ArrayList();
        arr.Add(1);
        // 此处必须强制转型,否则报错,
        // 因为ArrayList中的元素都是Object类型的。
        i = (Int32) arr[0];
    }
}

代码非凡不难,分别用泛型List和ArrayList来囤积值类型,然后在取出值类型。

行使泛型List的话,不会现出装箱/拆箱的操作。具体证据或者看上面的IL代码:

.method private static hidebysig 
    void Main (
        string[] args
    ) cil managed 
{
    // Method begins at RVA 0x217c
    // Code size 56 (0x38)
    .maxstack 2
    .entrypoint
    .locals init (
        [0] class [mscorlib]System.Collections.Generic.List`1<int32> lst
        [1] int32 i
        [2] class [mscorlib]System.Collections.ArrayList arr
    )

    IL_0000: nop
    IL_0001: newobj instance void [mscorlib]System.Collections.Generic.List`1<int32>::.ctor()
    IL_0006: stloc.0
    IL_0007: ldloc.0
    IL_0008: ldc.i4.1
    IL_0009: callvirt instance void [mscorlib]System.Collections.Generic.List`1<int32>::Add(!!0)
    IL_000e: nop
    IL_000f: ldloc.0
    IL_0010: ldc.i4.0
    IL_0011: callvirt instance !!0 [mscorlib]System.Collections.Generic.List`1<int32>::get_Item(int32)
    IL_0016: stloc.1
    IL_0017: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor()
    IL_001c: stloc.2
    IL_001d: ldloc.2
    IL_001e: ldc.i4.1
    IL_001f: box int32
    IL_0024: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
    IL_0029: pop
    IL_002a: ldloc.2
    IL_002b: ldc.i4.0
    IL_002c: callvirt instance object [mscorlib]System.Collections.ArrayList::get_Item(int32)
    IL_0031: unbox.any int32
    IL_0036: stloc.1
    IL_0037: ret
} // End of method CLRviaCSharp_13.Main

其中IL_0001~IL_0016是泛型List的连带操作

IL_0017~IL_0036是ArrayList的操作,包涵的有害质量的装箱(IL_001f: box
int32
)和拆箱(IL_0031: unbox.any
int32
)操作。

2.  限量泛型参数的序列

首先有少数要求证实,泛型类型和一般档次在静态构造函数上有一点例外。

对于常见档次,静态构造函数只在此类型第两遍初阶化的时候才会执行,

而泛型类型的静态构造函数会在
每种特定类型(即泛型参数T被替换为Int32要么String等等)的第五遍开端化的时候实施。

叙述的有些别扭,照旧看代码吧:

using System;
using System.Collections.Generic;
using System.Collections;
using System.Threading;


class CLRviaCSharp_13
{
    static void Main(string[] args)
    {
        /*
         * 非泛型的类:虽然有3次初始化,但是静态构造函数只执行一次
         */
        // 第一次初始化,会执行静态构造函数
        NormalClass nc = new NormalClass();
        // 第二次初始化,不会执行静态构造函数
        NormalClass nc2 = new NormalClass();
        // 第三次初始化,不会执行静态构造函数
        NormalClass nc3 = new NormalClass();

        /*
         * 泛型的类:泛型参数类型改变的话,会再次执行静态构造函数
         */
        // 对泛型参数(string)来说是第一次初始化,会执行静态构造函数
        GenericClass<string> gc = new GenericClass<string>();
        // 对泛型参数(string)来说是第二次初始化,不会执行静态构造函数
        GenericClass<string> gc2 = new GenericClass<string>();
        // 对泛型参数(Int32)来说是第一次初始化,会执行静态构造函数
        GenericClass<Int32> gc3 = new GenericClass<Int32>();

        Console.ReadKey(true);
    }
}

public class GenericClass<T>
{
    static GenericClass()
    {
        Thread.Sleep(1000);
        Console.WriteLine("GenericClass<" + typeof(T) + "> is initialized at : " + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss fff"));
    }
}

public class NormalClass
{
    static NormalClass()
    {
        Thread.Sleep(1000);
        Console.WriteLine("NormalClass is initialized at : " + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss fff"));
    }
}

如上代码的实践结果为:

图片 1

据悉泛型类型的静态构造的特性,大家可以通过泛型类型的静态构造函数来界定泛型参数(T)的品种。

例如以下代码,通过泛型类型的静态构造函数来界定泛型参数(T)只好为值类型

using System;

class CLRviaCSharp_13
{
    static void Main(string[] args)
    {
        // 对于引用类型的泛型参数,会抛出异常
        GenericClass<string> gc = new GenericClass<string>();
        // 对于值类型的泛型参数,都能正常初始化
        GenericClass<Int32> gc2 = new GenericClass<Int32>();
        GenericClass<Double> gc3 = new GenericClass<Double>();
        GenericClass<DateTime> gc4 = new GenericClass<DateTime>();

        Console.ReadKey(true);
    }
}

public class GenericClass<T>
{
    static GenericClass()
    {
        if (!typeof(T).IsValueType)
        {
            throw new ArgumentException("T must be a Enum type!");
        }

        Console.WriteLine("Type " + typeof(T).ToString() + " is initilized!");
    }
}

注明掉 GenericClass<string> gc = new GenericClass<string>();
就能健康实施。

有关泛型参数(T)的限定,将在下一篇 泛型高级
中有更进一步的讲演。

3.  节点类型不相同的链表

链表是一种常用的数据结构,以往结构链表时,每个节点往往都是一律的档次,否则取出节点后我们不可能还原其本身的连串。

只是现在依靠泛型,大家得以协会出节点类型差别的链表,而且链表中各样节点都是强类型(不是Object类型)的,从而满意日益复杂的必要。

代码如下:

using System;

class CLRviaCSharp_13
{
    static void Main(string[] args)
    {
        Node header = new TypedNode<Char>('.');
        header = new TypedNode<string>("hello world", header);
        header = new TypedNode<Int32>(100, header);
        header = new TypedNode<DateTime>(DateTime.Now, header);

        Console.WriteLine(header.ToString());
        Console.ReadKey(true);
    }
}

public class Node
{
    protected Node _next;

    public Node(Node next)
    {
        _next = next;
    }
}

public sealed class TypedNode<T> : Node
{
    public T _data;
    public TypedNode(T data) : this(data, null)
    {}

    public TypedNode(T data, Node next) : base(next)
    {
        _data = data;
    }

    public override string ToString()
    {
        return _data.ToString() + "\n" +
            ((_next != null) ? _next.ToString() : null);
    }
}

其一事例是《CLR via
C#》上的,每一次都是从链表尾部增添一个节点。实际行使时也足以按照须要修改为从链表底部增添节点。

执行结果如下:

图片 2

相关文章