泛型使用

简单总结一些泛型的使用：

泛型：通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用；

需要注意的时候，一定要看准参数的类型化；

泛型使用方式

1、泛型继承：

　　泛型能够实现基类数据的继承，如下举例：

class C<U,V>
class D:C<string,int>
class E<U,V>:C<U,V>
class F<U,V>:C<string,int>

2、泛型接口：

　　泛型接口的类型参数要么已实例化，要么来源于实现类声明的类型参数；

public interface  IPerson<T>{}

3、泛型委托：

　　动态指定参数类型，泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束；

delegate bool MyDelegate<T>(T value);

class MyClass

{

    static bool F(int i){...}

    static bool G(string s){...}

    static voidMain()

    {

        MyDelegate<string> p2 = G;

        MyDelegate<int> p1 = new MyDelegate<int>(F);

    }

}

4、泛型方法：

　　C#泛型机制只支持“在方法声明上包含类型参数”——即泛型方法;

class Myclass
{
    static void Swap<T, U>(T myt, U mt)
    {
        Console.Write(myt.ToString() + mt.ToString());
    }
}
-------调用方式-----------
new dmy().Swap<int, string>(1, "1254");

5、泛型重写：

　　在重写的过程中，抽象类中的抽象方法的约束是被默认继承的。

abstract class Base

{

    public abstract T F<T,U>(T t,U u) where U:T;

    public abstract T G<T>(T t) where T:IComparable;

}

 

class MyClass:Base

{

    public override X F<X,Y>(X x,Y y){...}

    public override T G<T>(T t) where T:IComparable{}

}

对于MyClass中两个重写的方法来说

F方法是合法的，约束被默认继承

G方法是非法的，指定任何约束都是多余的

泛型约束方式：

　　泛型约束：“显式约束”由where子句表达，可以指定“基类约束”，“接口约束”，“构造器约束”，“值类型/引用类型约束”共四种约束。

class A
    {
    }
interface IA<T>
    {
    }
----------------------------
class C<S, T,B>
        where S : A
        where T : IA<T>
        where:B:new()
-----------------------------------

泛型协变和逆变：

in和out指定类型为逆变和协变；接口和委托；

泛型属性：

var handlers = typeof(ICommandHandler<>).Assembly.GetExportedTypes()
.Where(x => x.GetInterfaces().Any(a => a.IsGenericType && a.GetGenericTypeDefinition() == typeof(ICommandHandler<>)))
.Where(h => h.GetInterfaces().Any(ii => ii.GetGenericArguments().Any(aa => aa == typeof(T)))).ToList();
return handlers;