泛型

泛型 
对参数类型进行了一个规定

ArrayList 

一个可变的object数组,长度可变,里面可以放任意类型的值,每一个值放进去都是object类型

麻烦:数据放进去就不知道是什么类型的了;不能防止非法类型数据的放入;

Dictionary(字典)

Key -value Pair: 键值对,键不可以重复,但是值可以重复
Dictionary<K,V>:K:键的类型,V:值的类型

Dictionary<string,int> dic = new Dictionary<string,int>();//声明了一个键为string类型,对应值为int的字典


Add():添加,如果重复,则报错
索引器方式设置值:可以重复设置,即使不存在也没关系,如果重复则新数据覆盖旧数据
ContainsKey(),判断是否存在这个Key
放进去的数据可能和遍历出来的数据的顺序不一样

Dictionary<K,V>的非泛型对应的是Hashtable;List<T>→ArrayList

数据库主键、索引、ASP中的Cookie等都有字典的影子

泛型的声明

 在类的声明后面约定一个类型

泛型类的声明

<span style="white-space:pre">	</span>class DateContainer<T>	
	//约定了一个待定类型T,T可以为其它名字。类中所有用类型的地方都可以用T代替
	{
		public T Data{get;set;}
		public T GetData()
		{
			return Date;
		}
		public void Hello(T t1,string s)
		{
			
		}
	}


声明变量:
DateContainer<int> dc = new DateContainer<int>();//和List<int> 就是一样的
dc.Data = 5;
int res = dc.GetData();

类型后面可以有多个类型约束符

	class Data<TKey,TValue>
	{
		public TKey key{get;set}
		public TValue value{get;set;}
	}

 

泛型方法 

在方法名后面声明约束类型。有效期就在这个方法体内

//泛型方法,在方法内部、参数、返回值都可以用这个类型代替

	static void Hello<T1,T2>(T1 i1,T2 i2)
	{
	
	}

 

泛型委托 

	delegate void MyDelegate<T1,T2>(T1 i1,T2 i2);	//类型约束类型个数同样可以改变
	
	static void H1(bool b1,int i1)
	{
	
	}
	//声明一个委托对象,指定约束的类型,指向一个复合类型约束的的方法
	MyDelegate<bool,int> md = H1;


系统定义的泛型委托:delegate void TRest Func<TRest>();以及其它重载的委托

泛型约束 

泛型的约束通过关键字where来完成

    约束泛型方法 

		// where T:new()	//约束类型T必须有一个无参的构造函数。只是能够约束无参的构造函数
		static List<T> CreatList<T>(int n) where T:new()	//约束类型T必须有一个无参的构造函数
		{
			List<T> list = new List<T>();
			for(int i=0 i<n; i++)
			{
				//约束了这个类型T必须有一个无参的构造函数.如果不约束是不能够创建的
				T p = new T();	
				list.Add(p);
			}
			return list;
		}

 

约束类/接口

		//约束类型T必须是继承至类Person或者是Person类
		class PersonList<T> where T:Person
		{
			public void DotIt(T p1)
			{
				//因为约定了T必须是继承自Person,所以可以再内部调用Person中的东东
				p1.Name = "aaa";
			}
		}
		
		class Person
		{
			public string Name{get;set;}
		}
		
		class Chinese:Person
		{
		}
		//声明这种类型的对象
		PersonList<Person> lists = new PersonList<Chinese>();

 

委托约束

delegate void MyDelegate<T1,T2>(T1 s1,T2 s2) where T1:Person

多个类型约束

就用多个where条件,以约束泛型类为例:

		class CountPerson<T1,T2,T3> where T1 : Person where T2:string where T3:Object
		{

		}


int? 类型

最终就编译成了一个Nullable<int>类型。

Nullable<T>,就是一个泛型,约束了T必须是一个struct
public struct Nullable<T> where T: struct
{
}


Lazy<T> 

懒惰对象,当我们真正使用的时候才会真正的创建T对象

Lazy<Person> person = new Lazy<Person>();//这句话的执行并不会去调用构造函数
.......
.......
person.Value.Hello();//Lazy的Value用来获得延迟创建的对象,
//会先判断这个对象有没有创建,创建了直接返回,没有创建就创建一个对象




posted on 2014-05-28 10:25  恋那片海  阅读(325)  评论(0编辑  收藏  举报