啃了啃泛型编程,写点心得,很肤浅,泛型仔细研究起来太复杂,跟反射、委托等等许多东西都有种种关联,慢慢积累吧,今天写点基本的东西。我们知道C#中有装箱,拆箱的操作,我们使用ArrayList可以知道,当我们向ArrayList中加入数据时,是以Object类型加入的,取出的时候也是以Object类型取出的,因此我们需要对取出的数据进行强制类型转换才能保证使用,代码如下:
ArrayList al=new ArrayList();
al.Add(123);
int temp=(int)al[0];
Console.WriteLine(temp);
这样当我们用MSIL反汇编程序看IL代码时会发现,程序进行了装箱,拆箱操作,下图:
可以清楚的看到,画红圈的box及unbox,就是通常所说的装箱,拆箱操作,引我们老师的一句话:“ArrayList的最大特点就是管你怎么操作都不出错。”弊端在哪呢?如果程序规模庞大,如此频繁的装箱拆箱的操作必然导致程序效率低下,因为Object这个类型实在是过于庞大,是处于顶端的一个类型,这是从效率方面考虑,从另一方面安全性的考虑上来说,频繁的装箱操作及拆箱操作也会引发安全问题,因为你随便往里装什么都无所谓,但是如果不知道装的是什么,你就取不出来(或者说取出来不知道怎么用),因此C#2.0引入泛型,提高了程序效率,并引入了新的编程模式,也就是泛型编程,泛型编程不仅可以应用于需要装箱,拆箱操作的数据,编程时恰当的使用泛型思想也可以减化某些工作的实现。并且C#对泛型的支持,是从编译IL代码、元数据到CLR运行时,实例化则是在JIT编译时,与JAVA的泛型相比是有些不同的。泛型有着更强的类型安全,更好的复用,更高的效率,更清晰的约束。下面开始代码与代码解释。
泛型的基本声明及用法:
代码:
一个简单模拟存数据,取数据的泛型类型,代码中<>中的T是这个类的参数类型,写在“<>”中,表示的是这个T是一个晚绑定的类型,也就是在前两次编译时,并不确定T是一个什么类型,前面说过,泛型的实例化是在JIT编译时,这里我是这么理解的,T可以把它当做一个占位符,未实例化之前,它可能是任意类型,泛型类型可以看做一个抽象类,当实例化的时候,应指定T的参数类型,如下:
public classStack<T>
{
private T[] store;
private int size;
public Stack()
{
store = new T[10];
size = 0;
}
public void Push(T x)
{
store[size++] = x;
}
public T Pop()
{
return store[--size];
}
}
Stack<int> stack=newStack<int>(); 好了,实例化完成后,T的参数类型就明确了,如此一来,有个问题,我听WebCast的时候只听说需要这么写,那不这么写行不行呢?如果我写
Stack stack=new Stack(); 编译是不会报错的,而且也没有任何的装箱,拆箱操作,Pop出来的值的Type也完全与Push进去的相符合,这个我需要再研究研究,难道编译器这么智能了。。会自己判断了,汗。无关大局,继续。
class C<V>
{
public Vf1;
publicD<V> f2;
public C(Vx)
{
this.f1=x;
}
}可以看出泛型类型中还是可以写很多东西的,包括其他泛型类型的对象(泛型类型D的对象f2,并且将自己的参数类型V传递给泛型类型D)。
泛型类型继承的语法规则
class C1<U,V>{}//合法
classC2:C1<string,int>{} //合法
class C3<U,V>:C1<U,V>{}//合法
classC4<U,V>:C1<string,int>{} //合法
class C5:C1<U,V>{} //非法这里跟struct类似,基类的参数要么已经实例化,要么来源于子类的参数。如果两者都不是,那运行时将无法实例化子类对象。
泛型类型大体上就简单的说完了,下一个:
泛型接口:
interfaceIList<T>
{
T[]GetElements();
}
interface IDictionary<K,V>
{
void Add(Kkey,V value);
}
class MyList<T>:IList<T>,IDictionary<int,T>
{
public T[]getElements(){}
public voidAdd(int index,T value){}
}注意,接口的参数类型与泛型类型继承中的父类泛型类型类似,当某个类需要实现某个或多个泛型接口时,泛型接口中的参数类型要么已经实例化,要么来源于实现类的参数列表(请注意那个红色的int)。好了,从这个例子可以稍微看出点来,我们可以定义一个可以接收或返回任意数据类型的泛型接口,而实现类只需要根据自身的需要去实现对应数据类型的接口就好了,不仅提高了代码重用,而且提高了效率,当然,这只是泛型接口应用之一。
继续。
泛型委托:
delegate boolpredicate<T>(T value);
class X
{
static void F(int i){}
static void G(string s){}
static voidmain()
{
predicate<string>p1=G;p1(123);
predicate<int> p2=new predicate<int>(F);p2("fuckdawnh");
}
}这段代码需要注意的是红色那段的写法,C#2.0以后支持这种写法,但是实际上编译器做的工作是predicate<string>p1=newpredicate<string>(G);所以我老觉得语言越来越难学,本来就因为C#是建立在高层的语言,底层本来就不容易理解,编译器作者又这么为程序员着想,想方设法为我们节省工作量,是好是坏呢?谁知道……额回到正题,泛型这么一引入,得又省了,定义一个返回或需要任意参数类型的参数(注意,委托支持在返回值类型上使用泛型,且参数类型同样可以附带合法的约束),好了,你需要整型的就写int,你需要字符串就写string,也是一种在参数类型上多态的体现吧。。
继续,
泛型方法:注意泛型方法既可以包含在泛型类型中,也可以包含在非泛型类型中,不包含在属性、事件、索引器、构造器、析构器。
①基本写法:
public class Finder
{
publicstatic int Find<T>(T[] items,T item)
{
for(int i=0;i
{
if(itmes[i].Equals(item))
return i;
}
return-1;
}
}
int i=Finder.Find<T>(newint[]{1,3,4,5,6,8,9},6);注意Finder类并不是一个泛型类型,而其中的方法Find却是一个返回int类型,需要T类型数组,T类型变量的泛型方法,注意最后调用Find的写法,这是在非泛型类中的泛型方法的典型例子。
继续。
②泛型方法的重载:
class MyClass
{
voidF1<T>(T[] a,int i){}
voidF1<U>(U[] a,int i){} //不构成重载
void F2<T>(int x){};
void F2(intx){} //构成重载
void F3<T>(T t) where T:A{}
voidF3<T> where T:B{} //不构成重载
}好了,这里需要注意的地方挺多:
第一个比较好理解,典型的换汤不换药,不构成重载没什么疑问。
第二组则构成重载,虽然T没在F2方法的参数列表中使用,可是T可以做为第一个F2方法内部成员变量的参数类型,并且同样都是方法F2,调用方法是不同的,调用第一个F2的写法(假如T的类型是string)是对象名.F2<string>(123);而调用第二个F2的写法是 对象名.F2(123);是有区别的。
第三组也是无法构成重载的,原因是不到运行时,编译器根本无法判断T是不是类型A,也无法判断T是不是类型B,前面已经说过,不到JIT编译,泛型不会被实例化,因此我觉得要做一个程序员,要有两个层次的认识,一是高层认识,就是你需要知道什么场合、什么时间该用什么方法构造你的代码,二是底层认识,你也需要知道底层大概路线是怎么走的,也需要有内存模型,知道栈堆等等都存什么用的。
继续。
③泛型方法的重写:
abstract class Father
{
publicabstract T F<T,U>(T t,U u) where U:T;
publicabstract T G<T>(T t) where T:IComparable;
}
class Child:Father{
publicoverride X F<X,Y>(X x,Y y){} //正确
publicoverride T G<T>(T t) where T:IComparable{} //错误!
}注意的一点,当重写泛型方法时,此方法的所有约束都是被默认继承的,因此不需要你手动去添加。
继续下一个大项。
泛型的约束:
对所有泛型类型或泛型方法的类型参数的任何假定,都要基于“显式的约束”,以维护类型安全,泛型约束主要有这么几个:①基类约束,②接口约束,③构造器约束,④值/引用类型约束。如果没有显式约束,则泛型类型只能访问Object里的公有方法。一个个看吧:
①基类约束
class A{public voidF1(){}}
class B{public void F2(){}}
class C<S,T>where S:A where T:B
{
static Sa=(S)(new A());static T b=(T)(new B());
static void Main()
{
a.F1();
b.F2();
}
}where后面的S:A就是说这个参数S必须是类型A,参数T必须是类型B,否则将导致运行时异常,当我们对类型C做了基类约束后,那我们便可以通过传递进来的合法参数来调用类型A的F1方法及类型B的F2方法了。注意强制类型转换,这里是将A当成了S的父类,B当成了T的父类。
②接口约束
interface IPrintable{voidPrint();}
interface IComparable<T>{int CompareTo(T v)}
interface IKeyProvider<T>{T GetKey();}
class Dictionary<K,V>where K:IComparable<K>
where V:IPrintable,IKeyProvider<K>
{
//可以调用K类型实例的CompareTo方法//可以调用V类型实例的Print,GetKey方法
}
我们可以看到参数K,V被约束为必须实现了某个接口的类型的实例,因此在该类中我们便可使用该实现类中所实现的接口中的方法了,还是要注意约束中接口中的参数,必须已经实例化或来源于实现类。
③构造器约束
class A{publicA(){}}
class B{public B(int i){}}
class C<T> where T:new()
{
T t=newT();
}
C<A> c=new C<A>();
B<B> c=new C<B>(); //错这里只是注意一下where后面的意思就可以了,这里的whereT:new()的意思是,该类型带有一个无参构造函数,我们看到类型B只有一个带有int类型的构造函数,因此如果将B当做类型传入会发生错误。另外注意,如果需要使用Tt=new T();则必须在约束中指定new();否则无法通过编译。
④值/引用类型约束
public struct A{}
public class B{}
class C<T> where T:struct
{
}
C<A> c=new C<A>();
C<B> c=new C<B>(); //错误这里也只是需要注意一下where后面约束的意思就可以了,whereT:stuct意思是T是一个值类型,因此第二种写法是错的。
累晕了,写到这泛型的一些基础的东西就说完了,做为C#2.0的核心技术,泛型的应用非常广泛,其复杂程度也是相当之高,光以上这些东西,MSDN里就标出来,这是Level300的,因此还是需要我们多多的积累才能对泛型有一个更全面的认识。
下一篇准备写写委托与事件,这个东西真是不怎么好理解。
联系客服