C#学习笔记 ----泛型

泛型的优点和缺点：

性能

类型安全

二进制代码的重用

代码的扩展

命名约定（字母T作为前缀）

创建泛型类型，如下：

public class LinkedListNode<T>
{
    public LinkedListNode(T value)
    {
        this.Value = value;
    }
    public T Value{get;private set;}
    public LinkedListNode<T> Next{get;internal set;}
    public LinkedListNode<T> Prev{get;internal set;}
}

public class LinkedList<T>:IEnumerable<T>
{
    public LinkedListNode<T> First{get;private set;}
    public LinkedListNode<T> Last{get;private set;}

    public LinkedListNode<T> AddLast(T node)
    {
        var newNode = new LinkedListNode(node);
        if(First == null)
        {
            First = newNode;
            newNode.Prev = Last;
            Last = First;
        }
        else
        {
            LinklistNode previous = Last;
            Last.Next = newNode;
            Last = newNode;
            Last.Prev = previous;
        }
        return newNode;
    }

    public IEnumerator<T> GetEnumerator()
    {
        LinkedListNode<T> current = First;
        while(current != null)
        {
            yield return current.Value;
            current = current.Next;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

泛型类的功能

在泛型中，根据泛型类型是引用类型还是值类型，泛型default用于将泛型类型初始化为null或0。

泛型支持几种约束机制：

where T:struct 对于结构约束，类型T必须是值类型

where T:class 类约束指定类型T必须是引用类型

where T:IFoo 指定类型T必须实现接口IFoo

where T:new() 这是一个构造函数约束，指定类型T必须有一个默认构造函数

where T1:T2 这个约束也可以指定，类型T1派生自泛型类型T2。该约束也称为裸类型约束。

使用泛型类型还可以合并多个约束

泛型类的静态成员只能在类的一个实例中共享

泛型接口

泛型结构

Nullable<T>

结构Nullable<T>定义了一个约束：其中的泛型类型T必须是结构

如下：

public struct Nullable<T>
    where T:struct
{
    public Nullable(T value)
    {
        this.hasValue = true;
        this.value = value;
    }
    private bool hasValue;
    public bool HasValue;
    {
        get
        {
            return hasValue;
        }
    }
    private T value;
    public T Value;
    {
        get
        {
            if(!hasValue)
            {
                throw new InvalidOperationException("no value");
            }
            return value;
        }
    }

    public static explicit operator T(Nullable<T> value)
    {
        return value.Value;
    }

    public static implicit operator Nullable<T>(T value)
    {
        return new Nullable<T>(value);
    }

    public override string ToString()
    {
        if (!HasValue)
            return String.Empty;
        return this.value.ToString();
    }
}

定义可空类型的变量，使用“？”

泛型方法