泛型
一、什么是泛型？
通过泛型可以定义类型安全类，而不会损害类型安全、性能或工作效率
二、实例化泛型
1、可以使用任何类型来声明和实例化
2、申明和实例话都必须用一个特定的类型来代替一般类型T
3、例子：
//原来写法
Public class Stack
{
object[] m_Items;
public void
Push(object item)
{...}
public object Pop()
{...}
}
Stack stack = new Stack();
stack.Push(1);
int number =
(int)stack.Pop();
//有了泛型后
Public class Stack <T>
{
T[] m_Items;
public void Push(T item)
{...}
public T
Pop()
{...}
}
Stack <int> stack = new Stack
<int> ();
stack.Push(1);
int number = (int)stack.Pop();
三：泛型的好处
1、一次性的开发、测试和部署代码，通过任何类型来重用它
2、编译器支持和类型安全
3、不会强行对值类型进行装箱和取消装箱，或者对引用类型进行向下强制类型转换，所以性能得到显著提高。
注：值类型大概可以提高200%，引用类型大概为100%
四：多个泛型
1、单个类型可以定义多个泛型
五：泛型别名
1、在文件头部使用using 为特定类型取别名，别名作用范围是整个文件
2、例子
using List =
LinkedList <int,string> ;
class ListClient
{
static void
Main(string[] args)
{
List list = new List();
list.AddHead(123, "AAA ");
}
}
五：泛型约束
(1)、派生约束
如：
public class LinkedList <K,T> where K:IComparable
{
T
Find(K key)
{
if (str.Key.CompareTo(key) == 0)//只有实现这个接口才可比较
}
}
注意:
1、所有的派生约束必须放在类的实际派生列表之后
如：public class
LinkedList <K,T> :IEnumerable <T> where K:IComparable <K>
{...}
2、一个泛型参数上可以约束多个接口（用逗号分隔）
public class LinkedList
<K,T> where K:IComparable <K> ,IConvertible
3、在一个约束中最多只能使用一个基类
4、约束的基类不能是密封类或静态类
5、不能将System.Delegate或System.Array约束为基类
6、可以同时约束一个基类以及一个或多个接口，但是该基类必须首先出现在派生约束列表中。
7、C#允许你将另一个泛型参数指定为约束
public class MyClass <T,U> where T:U
{...}
8、可以自己定义基类或接口进行泛型约束
9、自定义的接口或基类必须与泛型具有一致的可见性
(2)、构造函数约束
如：
class Node <K,T> where T:new()
{
}
注意：
1、可以将构造函数的约束和派生约束结合起来，前提是构造函数的约束出现在约束列表中的最后
(3)、引用/值类型约束
1、可以使用struct约束将泛型参数约束为值类型(如int、bool、enum),或任何自定义结构
2、同样可以使用class约束将泛型参数约束为引用类型
3、不能将引用/值类型约束与基类约束一起使用，因为基类约束涉及到类
4、不能使用结构和默认构造函数约束，因为默认构造函数约束也涉及到类
5、虽然您可以使用类和默认构造函数约束，但是这样做没有任何价值
6、可以将引用/值类型约束与接口约束组合起来，前提是引用/值类型约束出现在约束列表的开头
六：泛型和强制类型转换
1、C#编译器只允许将泛型参数隐式转换到Object或约束指定的类型
如：
interface IS{...}
class
BaseClass{...}
class MyClass <T> where T:BaseClass,IS
{
void SomeMethod(T t)
{
IS obj1 = t;
BaseClass obj2
= t;
object obj3 = t;
}
}
2、编译器允许你将泛型参数显示强制转换到其他任何借口，但不能将其转换到类
interface IS{...}
class
SomeClass{...}
class MyClass <T> //没有约束
{
void
SomeMethod(T t)
{
IS obj1 = (IS)t; //可以
SomeClass obj2
= (SomeClass)t //不可以
}
}
3、可以使用临时的Object变量，将泛型参数强制转换到其他任何类型
class SomeClass{...}
class MyClass <T>
{
void
SomeMethod(T t)
{
object temp = t;
SomeClass obj =
(SomeClass)temp;//可以
}
}
注意：这里只是告诉你这样写是可以的，但是要不要这样写？不要这样写，因为如果t确实没有继承SomeClass编译没错但是运行就会出错
4、解决上面强制转换问题，可以使用is和as运算符进行判断
public class MyClass <T>
{
public void SomeMethod <T t>
{
if (t is int
){...}
if (t is LinkedList <int,string> ){...}
//如果泛型参数的类型是所查询的类型，则is运算符返回true
string str = t as string;
//如果这写类型兼容，则as将执行强制类型转换，否则将返回null
if (str != null){...}
LinkedList <int,string> list = t as LinkedList
<int,string> ;
if (list != null){...}
}
}
七：继承和泛型
1、在从泛型基类派生，可以提供类型实参，而不是基类泛型参数
public class BaseClass
<T> {...}
public class SubClass:BaseClass <int>
2、如果子类是泛型，而非具体的类型实参，则可以使用子类泛型参数作为泛型基类的指定类型
public class BaseClass
<TT> {...}
public class SubClass <T> :BaseClass <T>
{...}
3、在使用子类泛型参数时，必须在子类级别重复在基类级别规定的任何约束
4、基类可以定义其签名使用泛型参数的虚礼方法，在重写它们时，子类必须在方法签名中提供相应的类型。
如：
public class
BaseClass <T>
{
public virtual T SomeMethod()
{...}
}
public class SubClass:BaseClass <int>
{
public
override int SomeMethod()
{...}
}
5、如果该子类是泛型，则它还可以在重写时使用它自己的泛型参数
public class SubClass <T> :BaseClass <T>
{
public
override T SomeMethod()
{...}
}
6、你可以定义泛型接口、泛型抽象类，甚至泛型抽象方法。
7、不能对泛型参数使用+或+=之类的运算符
public class Calculator <T>
{
public T Add (T arg1,T arg2)
{
return arg1 +
arg2;//错误
}
}
但是我们可以通过泛型抽象类、接口来实现在个功能，因为实现泛型抽象类、接口我们就已经明确传一个参数了，就可以执行诸如+这样的操作。
八：泛型方法
1、方法可以定义特定于其执行范围的泛型参数
public class MyClass <T>
{
public void MyMethod <X> (X x)
{...}
}
2、即使各包含类根本不使用泛型，你也可以定义方法特定的泛型参数
public class MyClass
{
public void MyMethod <T> (T t)
{...}
}
注意：该功能只使用于方法，属性，索引器只能使用在类的作用范围中定义的泛型参数。
3、调用泛型方法
MyClass obj =
new MyClass();
obj.MyMethod <int> (3);
也可以这样：
MyClass obj
= new MyClass();
obj.MyMethod(3); //该功能称为泛型推理
4、泛型方法也可以有自己的泛型参数约束
pubic class MyClass
{
public void
SomeMethod <T> (T t) where T:IComparable <T>
{...}
}
5、子类方法实现不能重复在父级别出现的约束
public class BaseClass
{
public
virtual void SomeMethod <T> (T t)where T:new()
{...}
}
pubic class SubClass:BaseClass
{
public override void
SomeMethod <T> (T t)//不能再有约束
{...}
}
6、静态方法
静态方法可以定义特定的泛型参数和约束
public class MyClass <T>
{
public
static T SomeMethod <X> (T t,X x)
{...}
}
int number
= MyClass <int> .SomeMethod <string> (3, "AAA ");
或者：int
mumber = MyClass <int> .SomeMethod(3, "AAA ");
九：泛型委托
1、在某个类中定义的委托可以利用该类的泛型参数
2、委托也可以定义自己的泛型参数
1.泛型和泛型强制转换
using System;
using System.Collections.Generic;
using System.Text;
namespace VS2005Demo2
8 C# 编译器只允许将泛型参数隐式强制转换到 Object 或约束指定的类型#region C# 编译器只允许将泛型参数隐式强制转换到 Object 或约束指定的类型
9 public interface ISomeInterface
10 { }
11 class BaseClass
12 { }
13 class MyClass<T> where T : BaseClass, ISomeInterface
15 void SomeMethod(T t)
17 ISomeInterface obj1 = t;
18 BaseClass obj2 = t;
19 object obj3 = t;
22 #endregion
24 编译器允许您将泛型参数显式强制转换到其他任何接口，但不能将其转换到类#region 编译器允许您将泛型参数显式强制转换到其他任何接口，但不能将其转换到类
25 class SomeClass
26 { }
27 //class MyClass1<T>
28 //{
29 // void SomeMethod(T t)
30 // {
31 // ISomeInterface obj1 = (ISomeInterface)t; //Compiles
32 // SomeClass obj2 = (SomeClass)t; //Does not compile
33 // }
34 //}
35 #endregion
38 使用临时的 Object 变量，将泛型参数强制转换到其他任何类型#region 使用临时的 Object 变量，将泛型参数强制转换到其他任何类型
39 class MyClass2<T>
41 void SomeMethod(T t)
43 object temp = t;
44 SomeClass obj = (SomeClass)temp;
47 #endregion
49 使用is和as运算符#region 使用is和as运算符
50 public class MyClass3<T>
52 public void SomeMethod(T t)
54 if (t is int) { }
55 if (t is LinkedList<int, string>) { }
56 string str = t as string;
57 if (str != null) { }
58 LinkedList<int, string> list = t as LinkedList<int, string>;
59 if (list != null) { }
62 #endregion
2.继承和泛型
1using System;
2using System.Collections.Generic;
3using System.Text;
5namespace VS2005Demo2
7 继承和泛型#region 继承和泛型
8 public class BaseClass<T>
9 { }
10 public class SubClass : BaseClass<int>
11 { }
14 public class SubClass1<R> : BaseClass<R>
15 { }
16 #endregion
18 继承约束#region 继承约束
19 public class BaseClass1<T> where T : ISomeInterface
20 { }
21 public class SubClass2<T> : BaseClass1<T> where T : ISomeInterface
22 { }
24 //构造函数约束
25 public class BaseClass3<T> where T : new()
27 public T SomeMethod()
29 return new T();
32 public class SubClass3<T> : BaseClass3<T> where T : new()
33 { }
35 #endregion
37 虚拟方法#region 虚拟方法
38 public class BaseClass4<T>
40 public virtual T SomeMethod()
42 return default(T);
45 public class SubClass4 : BaseClass4<int>
47 public override int SomeMethod()
49 return 0;
53 public class SubClass5<T> : BaseClass4<T>
55 public override T SomeMethod()
57 return default(T);
61 #endregion
63 接口、抽象类继承#region 接口、抽象类继承
64 public interface ISomeInterface6<T>
66 T SomeMethod(T t);
68 public abstract class BaseClass6<T>
70 public abstract T SomeMethod(T t);
72 public class SubClass6<T> : BaseClass6<T>,ISomeInterface6<T>
74 public override T SomeMethod(T t)
75 { return default(T); }
77 #endregion
79 泛型抽象方法和泛型接口#region 泛型抽象方法和泛型接口
80 //public class Calculator<T>
81 //{
82 // public T Add(T arg1, T arg2)
83 // {
84 // return arg1 + arg2;//Does not compile
85 // }
86 // //Rest of the methods
87 //}
89 public abstract class BaseCalculator<T>
91 public abstract T Add(T arg1, T arg2);
92 //public abstract T Subtract(T arg1, T arg2);
93 //public abstract T Divide(T arg1, T arg2);
94 //public abstract T Multiply(T arg1, T arg2);
96 public class MyCalculator : BaseCalculator<int>
98 public override int Add(int arg1, int arg2)
100 return arg1 + arg2;
101 }
102 //Rest of the methods
103 }
105 public interface ICalculator<T>
106 {
107 T Add(T arg1, T arg2);
108 //Rest of the methods
109 }
110 public class MyCalculator1 : ICalculator<int>
111 {
112 public int Add(int arg1, int arg2)
113 {
114 return arg1 + arg2;
115 }
116 //Rest of the methods
117 }
118 #endregion
120}
3.泛型方法
1using System;
2using System.Collections.Generic;
3using System.Text;
5namespace VS2005Demo2
8 泛型方法#region 泛型方法
9 public class MyClass
11 public void MyMethod<T>(T t)
12 { }
15 public class Class3
17 public void Test()
19 MyClass obj = new MyClass();
20 obj.MyMethod<int>(3);
22 obj.MyMethod(3);
25 #endregion
27 编译器无法只根据返回值的类型推断出类型#region 编译器无法只根据返回值的类型推断出类型
28 public class MyClass1
30 public T MyMethod<T>()
31 { return default(T); }
34 public class Class31
36 public void Test()
39 MyClass1 obj = new MyClass1();
40 int number = obj.MyMethod<int>();
43 #endregion
45 泛型方法约束#region 泛型方法约束
46 public class Class32
48 public T MyMethod<T>(T t) where T : IComparable<T>
49 { return default(T); }
51 #endregion
53 泛型虚拟方法#region 泛型虚拟方法
54 public class BaseClass33
56 public virtual void SomeMethod<T>(T t)
57 { }
59 public class SubClass33 : BaseClass33
61 public override void SomeMethod<T>(T t)
63 base.SomeMethod<T>(t);
67 public class BaseClass34
69 public virtual void SomeMethod<T>(T t) where T : new()
70 { }
72 public class SubClass34 : BaseClass34
74 public override void SomeMethod<T>(T t)// where T : IComparable<T>
75 { }
78 public class BaseClass35
80 public virtual void SomeMethod<T>(T t)
81 { }
83 public class SubClass35 : BaseClass35
85 public override void SomeMethod<T>(T t)
87 base.SomeMethod<T>(t);
88 base.SomeMethod(t);
91 #endregion
93 泛型静态方法#region 泛型静态方法
94 public class MyClass36<T>
96 public static T SomeMethod(T t)
97 { return default(T); }
100 public class Class36
101 {
102 public void Test()
103 {
104 int number = MyClass36<int>.SomeMethod(3);
105 }
106 }
108 public class MyClass37<T>
109 {
110 public static T SomeMethod<X>(T t, X x)
111 { return default(T); }
112 }
113 public class Class37
114 {
115 public void Test()
116 {
117 int number = MyClass37<int>.SomeMethod<string>(3, "AAA");
118 int number1 = MyClass37<int>.SomeMethod(3, "AAA");
119 }
120 }
122 public class MyClass38
123 {
124 public static T SomeMethod<T>(T t) where T : IComparable<T>
125 { return default(T); }
126 }
128 #endregion
129}
4.泛型委托
1using System;
2using System.Collections.Generic;
3using System.Text;
5namespace VS2005Demo2
7 泛型委托#region 泛型委托
8 public class MyClass40<T>
10 public delegate void GenericDelegate(T t);
11 public void SomeMethod(T t)
12 { }
15 public class MyClassTest40
17 public void Tests()
19 MyClass40<int> obj = new MyClass40<int>();
20 MyClass40<int>.GenericDelegate del;
22 del = new MyClass40<int>.GenericDelegate(obj.SomeMethod);
23 del(3);
25 //委托推理
26 del = obj.SomeMethod;
30 #endregion
32 委托泛型参数#region 委托泛型参数
33 public class MyClass41<T>
35 public delegate void GenericDelegate<X>(T t, X x);
38 //外部委托
39 public delegate void GenericDelegate<T>(T t);
41 public class MyClass42
43 public void SomeMethod(int number)
44 { }
47 public class MyClassTest42
49 public void Test()
51 MyClass42 obj = new MyClass42();
52 GenericDelegate<int> del;
53 //del = new GenericDelegate<int>(obj.SomeMethod);
55 del = obj.SomeMethod;
56 del(3);
61 #endregion
63 委托泛型参数#region 委托泛型参数
64 public delegate void MyDelegate<T>(T t) where T : IComparable<T>;
65 #endregion
67 事件#region 事件
69 public delegate void GenericEventHandler<S, A>(S sender, A args);
71 public class MyPublisher
73 public event GenericEventHandler<MyPublisher, EventArgs> MyEvent;
74 public void FireEvent()
76 MyEvent(this, EventArgs.Empty);
80 public class MySubscriber<A> //Optional: can be a specific type
82 public void SomeMethod(MyPublisher sender, A args)
83 { }
85 public class MyClassTest43
87 public void Test()
89 MyPublisher publisher = new MyPublisher();
90 MySubscriber<EventArgs> subscriber = new MySubscriber<EventArgs>();
91 publisher.MyEvent += subscriber.SomeMethod;
94 #endregion
