泛型总结

C# 2012-06-04 10:54

所谓泛型,即通过参数化类型来实现在同一份代码上操作多种数据类型。泛型编程是一种编程范式,它利用“参数化类型”将类型抽象化,从而实现更为灵活的复用。

面向对象的语言好处是使得程序员可以很方便地重用代码, 在面向对象中程序员可以写一个子类去继承自一个父类,写不同的程序能够重用以前的代码, 会减少很多代码的工作量。
但是算法能不能重用呢? 答案是肯定的, CLR提供了一个算法重用的机制, 就是泛型。



1. 减少装箱/拆箱(提高性能)

2.  限制泛型参数的类型

首先有一点需要说明,泛型类型和普通类型在静态构造函数上有一点不同。

对于普通类型,静态构造函数只在此类型第一次初始化的时候才会执行,

而泛型类型的静态构造函数会在 每种特定类型(即泛型参数T被替换为Int32或者String等等)的第一次初始化的时候执行。


3.  节点类型不同的链表


泛型标识
泛型的写法的确是麻烦, 一堆的< 和 >, 不管是读和写都很麻烦, 有什么方法能走点近道呢?

答案有两种方法: 继承 和 使用Using 关键字。
如果我们在程序中用的了List<DateTime> dtl=new List<DateTime>(); 这样的代码很多的话, 我们就能写一个DateTimeList的类来继承List<DateTime>
Interanl class DateTimeList: List<DateTime>{
//这里边不需要写代码
}
所以在程序中我们就可以使用DateTimeList来替换所有使用到List<DateTime>的地方。

第二种方法使用Using关键字
我们可以给List<DateTime>声明一个别名DateTimeList, 如下代码:
Using DateTimeList=System.Collections.Generic.List<System.DateTime>;
然后我们就可以在程序中使用DateTimeList这个类型了。

两种方法的区别是第二种方法中, DateTimeList和List<DateTime>完全等价, 而在第一种方法中, 有如下注意点: 任何使用类型List<DateTime>的地方都可以使用DateTimeList替换, 但是使用DateTimeList的地方不能使用List<DateTime>替换, 因为两者是继承关系而非等价关系。


在定义泛型类时,可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类,则会产生编译时错误。这些限制称为约束。约束是使用 where 上下文关键字指定的。

下表列出了五种类型的约束:



约束说明

T:struct

类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。

T:class

类型参数必须是引用类型,包括任何类、接口、委托或数组类型。

T:new()

类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时,new() 约束必须最后指定。

T:<基类名>

类型参数必须是指定的基类或派生自指定的基类。

T:<接口名称>

类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。

T:U

为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。这称为裸类型约束.


一.派生约束

1.常见的

public class MyClass5<T> where T :IComparable { }

2.约束放在类的实际派生之后

public class B { }

public class MyClass6<T> : B where T : IComparable { }

3.可以继承一个基类和多个接口,且基类在接口前面

public class B { }

public class MyClass7<T> where T : B, IComparable, ICloneable { }

二.构造函数约束

1.常见的

public class MyClass8<T> where T :  new() { }

2.可以将构造函数约束和派生约束组合起来,前提是构造函数约束出现在约束列表的最后

public class MyClass8<T> where T : IComparable, new() { }

三.值约束

1.常见的

public class MyClass9<T> where T : struct { }

2.与接口约束同时使用,在最前面(不能与基类约束,构造函数约束一起使用)

public class MyClass11<T> where T : struct, IComparable { }

四.引用约束

1.常见的

public class MyClass10<T> where T : class { }

五.多个泛型参数

public class MyClass12<T, U> where T : IComparable  where U : class { }

六.继承和泛型

public class B<T>{ }

1. 在从泛型基类派生时,可以提供类型实参,而不是基类泛型参数

   public class SubClass11 : B<int>
   { }

2.如果子类是泛型,而非具体的类型实参,则可以使用子类泛型参数作为泛型基类的指定类型

   public class SubClass12<R> : B<R>
   { }

3.在子类重复基类的约束(在使用子类泛型参数时,必须在子类级别重复在基类级别规定的任何约束)
   public class B<T> where T : ISomeInterface { }
   public class SubClass2<T> : B<T> where T : ISomeInterface { }

4.构造函数约束
   public class B<T> where T : new()
   {
       public T SomeMethod()
       {
           return new T();
       }
   }
   public class SubClass3<T> : B<T> where T : new(){ }

七.泛型方法(C#2.0泛型机制支持在"方法声名上包含类型参数",这就是泛型方法)

1.泛型方法既可以包含在泛型类型中,又可以包含在非泛型类型中

public class MyClass5
   {

       public void MyMethod<T>(T t){ }
   }

2.泛型方法的声明与调用

public class MyClass5
   {
       public void MyMethod<T>(T t){ }
   }
   public class App5
   {
       public void CallMethod()
       {
           MyClass5 myclass5 = new MyClass5();
           myclass5.MyMethod<int>(3);
       }
   }

3.泛型方法的重载

//第一组重载
void MyMethod1<T>(T t, int i){ }

void MyMethod1<U>(U u, int i){ }

//第二组重载
void MyMethod2<T>(int i){ }
void MyMethod2(int i){ }

//第三组重载,假设有两个泛型参数
void MyMethod3<T>(T t) where T : A { }
void MyMethod3<T>(T t) where T : B { }

//第四组重载

public class MyClass8<T,U>
   {
       public T MyMothed(T a, U b)
       {
           return a;
       }
       public T MyMothed(U a, T b)
       {
           return b;
       }
       public int MyMothed(int a, int b)
       {
           return a b;
       }
   }

4.泛型方法的覆写

(1)public class MyBaseClass1
   {
       public virtual void MyMothed<T>(T t) where T : new() { }
   }
   public class MySubClass1:MyBaseClass1
   {
       public override void MyMothed<T>(T t) //不能重复任何约束
       { }
   }

(2)public class MyBaseClass2
   {
       public virtual void MyMothed<T>(T t)
       { }
   }
   public class MySubClass2 : MyBaseClass2
   {
       public override void MyMothed<T>(T t) //重新定义泛型参数T
       { }
   }

八.虚拟方法

public class BaseClass4<T>
   {
       public virtual T SomeMethod()
       {
           return default(T);
       }
   }
   public class SubClass4 : BaseClass4<int> //使用实参继承的时候方法要使用实参的类型
   {
       public override int SomeMethod()
       {
           return 0;
       }
   }

   public class SubClass5<T> : BaseClass4<T> //使用泛型继承时,方法也是泛型
   {
       public override T SomeMethod()
       {
           return default(T);
       }
   }

九.编译器只允许将泛型参数隐式强制转换到 Object 或约束指定的类型

class MyClass<T> where T : BaseClass, ISomeInterface
   {
       void SomeMethod(T t)
       {
           ISomeInterface obj1 = t;
           BaseClass obj2 = t;
           object obj3 = t;
       }
   }

变通方法:使用临时的 Object 变量,将泛型参数强制转换到其他任何类型

class MyClass2<T>
   {
       void SomeMethod(T t)
       {
           object temp = t;
           BaseClass obj = (BaseClass)temp;
       }
   }

十.编译器允许您将泛型参数显式强制转换到其他任何接口,但不能将其转换到类

class MyClass1<T>
   {
       void SomeMethod(T t)
       {
           ISomeInterface obj1 = (ISomeInterface)t;  
           //BaseClass obj2 = (BaseClass)t;           //不能通过编译
       }
   }


十一.使用临时的 Object 变量,将泛型参数强制转换到其他任何类型

class MyClass2<T>
   {
       void SomeMethod(T t)
       {
           object temp = t;
           BaseClass obj = (BaseClass)temp;
       }
   }

十二.使用is和as运算符

public class MyClass3<T>
   {
       public void SomeMethod(T t)
       {
           if (t is int) { }
           if (t is LinkedList<int>) { }
           string str = t as string;
           if (str != null) { }
           LinkedList<int> list = t as LinkedList<int>;
           if (list != null) { }
       }
   }



总结:

1、C#的泛型能力由CLR在运行时支持,它既不同于C 在编译时所支持的静态模板,也不同于Java在编译器层面使用“擦拭法”支持的简单的泛型。

2、C#的泛型支持包括类、结构、接口、委托四种泛型类型,以及方法成员。

3、C#的泛型采用“基类,接口,构造器,值类型/引用类型”的约束方式来实现对类型参数的“显式约束”,它不支持C 模板那样的基于签名的隐式约束。



Leave a Reply