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