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用来获得延迟创建的对象，
//会先判断这个对象有没有创建，创建了直接返回，没有创建就创建一个对象