1、使用示例代码
1)泛型(类、接口、委托)
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace MyGeneric { /// <summary> /// 一个类来满足不同的具体类型,做相同的事儿 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="S"></typeparam> /// <typeparam name="X"></typeparam> /// <typeparam name="Eleven"></typeparam> /// <typeparam name="老K"></typeparam> public class GenericClass<T> //, S, X, Eleven, 老K> //where T : People //where S : Chinese //where Eleven : Hubei { public T _T; } /// <summary> /// 一个接口来满足不同的具体类型的接口,做相同的事儿 /// </summary> /// <typeparam name="T"></typeparam> public interface IGenericInterface<T> //where T : People { T GetT(T t);//泛型类型的返回值 } public class CommonClass //: GenericClass<int>//必须指定 : IGenericInterface<int>//必须指定 { public int GetT(int t) { throw new NotImplementedException(); } } public class GenericClassChild<Eleven> //: GenericClass<Eleven> : GenericClass<int>, IGenericInterface<Eleven> { public Eleven GetT(Eleven t) { throw new NotImplementedException(); } } public delegate void SayHi<T>(T t);//泛型委托 }
2) 泛型方法
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace MyGeneric { /// <summary> /// 泛型方法 /// </summary> public class GenericMethod { /// <summary> /// 2.0推出的新语法 /// 泛型方法解决用一个方法,满足不同参数类型;做相同的事儿 /// 没有写死参数类型,调用的时候才指定的类型 /// </summary> /// <typeparam name="T">T/S 不要用关键字 也不要跟别的类型冲突 </typeparam> /// <param name="tParameter"></param> public static void Show<T>(T tParameter) { Console.WriteLine("This is {0},parameter={1},type={2}", typeof(GenericMethod), tParameter.GetType().Name, tParameter.ToString()); } public static void ShowObject(object oParameter) { Console.WriteLine("This is {0},parameter={1},type={2}", typeof(GenericMethod), oParameter.GetType().Name, oParameter); } } }
2、泛型类介绍
泛型类封装了不针对任何特定数据类型的操作。泛型类常用于容器类,如链表、哈希表、栈、队列、树等等。这些类中的操作,如对容器添加、删除元素,不论所存储的数据是何种类型,都执行几乎同样的操作。
对大多数情况,推荐使用.NET框架2.0类库中所提供的容器类。有关使用这些类的详细信息,请参见基础类库中的泛型。
通常,从一个已有的具体类来创建泛型类,并每次把一个类型改为类型参数,直至达到一般性和可用性的最佳平衡。当创建你自己的泛型类时,需要重点考虑的事项有:
哪些类型应泛化为类型参数。一般的规律是,用参数表示的类型越多,代码的灵活性和复用性也就越大。过多的泛化会导致代码难以被其它的开发人员理解。
如果有约束,那么类型参数需要什么样约束。一个良好的习惯是,尽可能使用最大的约束,同时保证可以处理所有需要处理的类型。例如,如果你知道你的泛型类只打算使用引用类型,那么就应用这个类的约束。这样可以防止无意中使用值类型,同时可以对T使用as运算符,并且检查空引用。
把泛型行为放在基类中还是子类中。泛型类可以做基类。同样非泛型类的设计中也应考虑这一点。泛型基类的继承规则 。
是否实现一个或多个泛型接口。例如,要设计一个在基于泛型的容器中创建元素的类,可能需要实现类似IComparable<T>的接口,其中T是该类的参数。
//泛型类: public class MySQLHelp<T> { private T t; public MySQLHelp(T t) { this.t = t; } } //测试类 public class Test{ public static void Main(){ MySQLHelp<Message> mm = new MySQLHelp<Message>(new Message()); } } //其他类 public class Message{ }
3、泛型接口介绍
不论是为泛型容器类,还是表示容器中元素的泛型类,定义接口是很有用的。把泛型接口与泛型类结合使用是更好的用法,比如用IComparable<T>
而非IComparable
,以避免值类型上的装箱和拆箱操作。.NET框架2.0类库定义了几个新的泛型接口,以配合System.Collections.Generic
中新容器类的使用。
当一个接口被指定为类型参数的约束时,只有实现该接口的类型可被用作类型参数。下面的示例代码显示了一个从MyList<T>
派生的SortedList<T>
类。更多信息,请参见泛型概述。SortedList<T>
增加了约束where T : IComparable<T>
。
这使得SortedList<T>
中的BubbleSort
方法可以使用表中的元素的IComparable<T>.CompareTo
方法。在这个例子中,表中的元素是简单类——实现IComparable<Person>
的Person
类。
using System; using System.Collections.Generic; //Type parameter T in angle brackets. public class MyList<T> { protected Node head; protected Node current = null; // Nested type is also generic on T protected class Node { public Node next; //T as private member datatype. private T data; //T used in non-generic constructor. public Node(T t) { next = null; data = t; } public Node Next { get { return next; } set { next = value; } } //T as return type of property. public T Data { get { return data; } set { data = value; } } } public MyList() { head = null; } //T as method parameter type. public void AddHead(T t) { Node n = new Node(t); n.Next = head; head = n; } // Implement IEnumerator<T> to enable foreach // iteration of our list. Note that in C# 2.0 // you are not required to implment Current and // GetNext. The compiler does that for you. public IEnumerator<T> GetEnumerator() { Node current = head; while (current != null) { yield return current.Data; current = current.Next; } } } public class SortedList<T> : MyList<T> where T : IComparable<T> { // A simple, unoptimized sort algorithm that // orders list elements from lowest to highest: public void BubbleSort() { if (null == head || null == head.Next) return; bool swapped; do { Node previous = null; Node current = head; swapped = false; while (current.next != null) { // Because we need to call this method, the SortedList // class is constrained on IEnumerable<T> if (current.Data.CompareTo(current.next.Data) > 0) { Node tmp = current.next; current.next = current.next.next; tmp.next = current; if (previous == null) { head = tmp; } else { previous.next = tmp; } previous = tmp; swapped = true; } else { previous = current; current = current.next; } }// end while } while (swapped); } } // A simple class that implements IComparable<T> // using itself as the type argument. This is a // common design pattern in objects that are // stored in generic lists. public class Person : IComparable<Person> { string name; int age; public Person(string s, int i) { name = s; age = i; } // This will cause list elements // to be sorted on age values. public int CompareTo(Person p) { return age - p.age; } public override string ToString() { return name + ":" + age; } // Must implement Equals. public bool Equals(Person p) { return (this.age == p.age); } } class Program { static void Main(string[] args) { //Declare and instantiate a new generic SortedList class. //Person is the type argument. SortedList<Person> list = new SortedList<Person>(); //Create name and age values to initialize Person objects. string[] names = new string[]{"Franscoise", "Bill", "Li", "Sandra", "Gunnar", "Alok", "Hiroyuki", "Maria", "Alessandro", "Raul"}; int[] ages = new int[]{45, 19, 28, 23, 18, 9, 108, 72, 30, 35}; //Populate the list. for (int x = 0; x < 10; x++) { list.AddHead(new Person(names[x], ages[x])); } //Print out unsorted list. foreach (Person p in list) { Console.WriteLine(p.ToString()); } //Sort the list. list.BubbleSort(); //Print out sorted list. foreach (Person p in list) { Console.WriteLine(p.ToString()); } Console.WriteLine("Done"); } }
可以在一个类型指定多个接口作为约束,如下:
class Stack<T> where T : IComparable<T>, IMyStack1<T>{}
一个接口可以定义多个类型参数,如下:
IDictionary<K,V>
接口和类的继承规则相同:
IMyInterface : IBaseInterface<int>
IMyInterface<T> : IBaseInterface<T>
IMyInterface<T>: IBaseInterface<int>
具体类可以实现封闭构造接口,如下:
class MyClass : IBaseInterface<string>
泛型类可以实现泛型接口或封闭构造接口,只要类的参数列表提供了接口需要的所有参数,如下:
class MyClass<T> : IBaseInterface<T>
class MyClass<T> : IBaseInterface<T, string>
4、泛型方法介绍
泛型方法是声名了类型参数的方法,如下:
void Swap<T>( ref T lhs, ref T rhs) { T temp; temp = lhs; lhs = rhs; rhs = temp; }
下面的示例代码显示了一个以int作为类型参数,来调用方法的例子:
int a = 1; int b = 2; //… Swap<int>(a, b);
也可以忽略类型参数,编译器会去推断它。下面调用Swap的代码与上面的例子等价:
Swap(a, b);
静态方法和实例方法有着同样的类型推断规则。编译器能够根据传入的方法参数来推断类型参数;而无法单独根据约束或返回值来判断。因此类型推断对没有参数的方法是无效的。类型推断发生在编译的时候,且在编译器解析重载方法标志之前。编译器对所有同名的泛型方法应用类型推断逻辑。在决定(resolution)重载的阶段,编译器只包含那些类型推断成功的泛型类。更多信息,请参见C# 2.0规范,20.6.4类型参数推断
在泛型方法中,非泛型方法能访问所在类中的类型参数,如下:
class MyClass<T> { //… void Swap (ref T lhs, ref T rhs){…} }
[JX1] 定义一个泛型方法,和其所在的类具有相同的类型参数;试图这样做,编译器会产生警告CS0693。
class MyList<T> { // CS0693 void MyMethod<T>{...} } class MyList<T> { //This is okay, but not common. void SomeMethod<U>(){...} }
使用约束可以在方法中使用更多的类型参数的特定方法。这个版本的Swap<T>
称为SwapIfGreater<T>
,它只能使用实现了IComparable<T>
的类型参数。
void SwapIfGreater<T>( ref T lhs, ref T rhs) where T: IComparable<T> { T temp; if(lhs.CompareTo(rhs) > 0) { temp = lhs; lhs = rhs; rhs = temp; } }
泛型方法通过多个类型参数来重载。例如,下面的这些方法可以放在同一个类中:
void DoSomething(){} void DoSomething<T>(){} void DoSomething<T,U>(){}
5、泛型委托介绍
无论是在类定义内还是类定义外,委托可以定义自己的类型参数。引用泛型委托的代码可以指定类型参数来创建一个封闭构造类型,这和实例化泛型类或调用泛型方法一样,如下例所示:
public delegate void MyDelegate<T>(T item); public void Notify(int i){} //... MyDelegate<int> m = new MyDelegate<int>(Notify);
C#2.0版有个新特性称为方法组转换(method group conversion),具体代理和泛型代理类型都可以使用。用方法组转换可以把上面一行写做简化语法:
MyDelegate<int> m = Notify;
在泛型类中定义的委托,可以与类的方法一样地使用泛型类的类型参数。
class Stack<T> { T[] items; int index //... public delegate void StackDelegate(T[] items); }
引用委托的代码必须要指定所在类的类型参数,如下:
Stack<float> s = new Stack<float>(); Stack<float>.StackDelegate myDelegate = StackNotify;
泛型委托在定义基于典型设计模式的事件时特别有用。因为sender[JX2] ,而再也不用与Object相互转换。
public void StackEventHandler<T,U>(T sender, U eventArgs); class Stack<T> { //… public class StackEventArgs : EventArgs{...} public event StackEventHandler<Stack<T>, StackEventArgs> stackEvent; protected virtual void OnStackChanged(StackEventArgs a) { stackEvent(this, a); } } class MyClass { public static void HandleStackChange<T>(Stack<T> stack, StackEventArgs args){...}; } Stack<double> s = new Stack<double>(); MyClass mc = new MyClass(); s.StackEventHandler += mc.HandleStackChange;
相关文档:
C#(.NET Core) 泛型<T>中协变(covariant)和逆变(contravariant)的使用