泛型
对参数类型进行了一个规定
麻烦:数据放进去就不知道是什么类型的了;不能防止非法类型数据的放入;
Dictionary<K,V>:K:键的类型,V:值的类型
索引器方式设置值:可以重复设置,即使不存在也没关系,如果重复则新数据覆盖旧数据
ContainsKey(),判断是否存在这个Key
放进去的数据可能和遍历出来的数据的顺序不一样
Dictionary<K,V>的非泛型对应的是Hashtable;List<T>→ArrayList
数据库主键、索引、ASP中的Cookie等都有字典的影子
声明变量:
DateContainer<int> dc = new DateContainer<int>(); //和List<int> 就是一样的
dc.Data = 5;
int res = dc.GetData();
类型后面可以有多个类型约束符
系统定义的泛型委托:delegate void TRest Func<TRest>();以及其它重载的委托
public struct Nullable<T> where T: struct
{
}
.......
.......
person.Value.Hello(); //Lazy的Value用来获得延迟创建的对象,
//会先判断这个对象有没有创建,创建了直接返回,没有创建就创建一个对象
对参数类型进行了一个规定
ArrayList
一个可变的object数组,长度可变,里面可以放任意类型的值,每一个值放进去都是object类型麻烦:数据放进去就不知道是什么类型的了;不能防止非法类型数据的放入;
Dictionary(字典)
Key -value Pair: 键值对,键不可以重复,但是值可以重复Dictionary<K,V>:K:键的类型,V:值的类型
Dictionary<string,int> dic = new Dictionary<string,int>(); //声明了一个键为string类型,对应值为int的字典
索引器方式设置值:可以重复设置,即使不存在也没关系,如果重复则新数据覆盖旧数据
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必须是一个structpublic struct Nullable<T> where T: struct
{
}
Lazy<T>
懒惰对象,当我们真正使用的时候才会真正的创建T对象
Lazy<Person> person = new Lazy<Person>(); //这句话的执行并不会去调用构造函数.......
.......
person.Value.Hello(); //Lazy的Value用来获得延迟创建的对象,
//会先判断这个对象有没有创建,创建了直接返回,没有创建就创建一个对象