泛型

基本

class MyData <T>
{
    private List<T> lst = new List<T>();

    public void Push(T item)
    {
        lst.Add(item);
    }

    public void Print()
    {
        foreach(T item in lst)
        {
            Debug.Log(item);
        }
    }
}

//
MyData<int> md = new MyData<int>();
md.Push(1);
md.Push(2);
md.Print();

泛型class中的静态成员

只有泛型类型相同的类，才会共享静态成员。因为JIT会将其解释为两个不同的类，虽然C#源代码是同一个。

MyData<string> md1 = new MyData<string>();
MyData<int> md2 = new MyData<int>();
// 所有的MyData<string>类型共享静态成员
// 所有的MyData<int>类型共享静态成员
// 但MyData<string>, MyData<int>不共享静态成员

泛型约束

// 值类型
public void Method1<T>(T arg) where T : struct
{
}

// 引用类型（object不用当作约束）
public void Method1<T>(T arg) where T : MyClass
{
}

public void Method<T>(T arg) where T : MyInterface
{
}

// 无参公共构造方法
public void Method<T>(T arg) where T : new()
{
}

// 泛型约束泛型
public class MyClass<U>
{
    public void Method<T>(T arg) where T : U
    {
    }
}

初始化泛型变量

public T Method1<T>
{
    return default(T);
}

public void Method2<T>(T arg = default(T))
{
    Console.WriteLine(arg);
}

// 
Method2();

委托

// 无返回值；参数int,string
private Action<int, string> action1;

// 返回string；参数为int
private Func<int, string> func1;

// 返回bool；参数为int
private Pridicate<int> predicate1;

协变，逆变

不管是协变还是逆变，它们都遵守的原则是：
* 可以将子类引用，赋予父类引用

string str = "a";
object obj = str;   // 将子类引用赋予父类引用

它们的区别是，方向不同
* 协变用于函数的返回数据，从内到外 out
* 逆变用于向函数传递数据，从外到内 in
* 所以协变只能用于修饰返回泛型，逆变只能用于修饰参数泛型

public delegate T Fun1<out T>();
public delegate void Fun2<in T>(T args);

Fun1<object> fun11 = null;
Fun1<string> fun12 = null;
fun11 = fun12;

Fun2<object> fun21 = null;
Fun2<string> fun22 = null;
fun22 = fun21;

MSDN-covariance-and-contravariance
http://www.cnblogs.com/CLR010/p/3274310.html