一般而言,一个泛型类型G可以应用于一个或多个其他类型——如O1、O2等——其思想是,G的实现不需要对Ox等类型知道很多。
C#函数式程序设计之泛型函数
任何方法在为方法签名添加一个或多个类型参数后,就成为泛型。如下所示:static void OutputThing<T>(T thing)
{
Console.WriteLine("Thing: {0}",thing);
}
这里T是类型变量,它出现在方法名后面的一对尖括号中。这样声明后,这个参数就可以在参数列表中和方法体重当成类型使用。这个方法并不关心这个thing元素和它的类型,它只是把它的值传递给其他方法以进一步处理。
下面是用显示类型参数调用这个函数:
OutputThing<string>("A string");
OutputThing<int>(42);
使用显式类型参数意味着这个类型要受到Visual Studio的智能感知和C#编译器的双重检查。如下面这个调用会产生编译错误信息:
OutputThing<double>("A string");
错误如下:
尽管这个例子很简单,但它说明泛型的一个作用:不是使用类型对象的参数,而是在调用中显式说明类型,这回启动严格的类型检查。
另一方面,许多程序员认为直接使用显式类型过于草率,OutputThing方法也可以像下面这样调用:
OutputThing("A string");
OutputThing(42);
这里使用类型推断机制可以根据字面值推断它的类型。这并不是一个无类型调用,在OutputThing方法中还有一个类型变量T。上面两个调用语句实际上T分别代表了string和int,编译器会在编译时自动为它们替换为该类型。
然而,许多程序员把C#类型推断看成是一个只有在必要时才使用的功能,而不是一个任何时候都可以使用的通用工具,这是正确的,使用类型推断,会让复杂的代码的可读性变差。
下面是一个稍微复杂(同时也比较有用)的有关泛型的李子
static void Apply<T>(IEnumerable<T> sequence, Action<T> action)
{
foreach (T item in sequence)
{
action(item);
}
}
本例中也有一个类型参数T,但是它作用在这个方法的两个参数上,它们之间存在一种关联:第一个参数是事件序列,第二个参数是一个委托,此委托作用的参数就是在此序列中的事件类型。这正是泛型表现出强大功能的地方,如果不使用泛型,但仍然希望此方法可以灵活应用于不同类型,就无法表现出这种关联性。
泛型元素并不关心类型本身。下面是对Apply方法的调用:
var values = new List<int> { 10, 20, 35 };
Apply(values, v => Console.WriteLine("Value:{0}", v));
调用Apply方法,但是省略了泛型参数,编译器需要推断Apply调用语句中参数T的类型,为此需要检查参数。
C#函数式程序设计之泛型类
也可以给类添加类型信息。在这种情况下,类型参数的作用域是整个类,但其用法与前面完全一样:它代表某个类型。下面的例子是一个链表的实现(不完整):public class ListItem<T>
{
public ListItem(T value)
{
this.value = value;
}
private ListItem(T value, ListItem<T> next)
: this(value)
{
this.next = next;
}
private readonly T value;
public T Value
{
get { return value; }
}
private ListItem<T> next;
public ListItem<T> Prepend(T value)
{
return new ListItem<T>(value, this);
}
}
ListItem类有一个泛型参数T,这个参数封装在ListItem容器中,在类中任何需要显式类型的位置都可以使用这个类。使用泛型会使ListItem类更加灵活,因为它可以把任何其他类型的信息封装到链表列中。
同时,泛型系统会使编译器的类型检查功能更强大。上例中的Prepend方法只接受T类型的值。从ListItem类的实例角度来看,T是固定的,换言之,新的值必须与当前实例的值具有相同类型。分析下面的例子:
public static void List()
{
var intItem = new ListItem<int>(10);
var secondItem = intItem.Prepend(20);
var thirdItem = secondItem.Prepend("string");
}
这里,当ListItem类与new关键字一起使用时,要在类名中添加一个类型参数,现在保存在ListItem变量中的实例是类型化的,包含了类型为int的值。其结果是,Prepend方法可以接受一个为int的类型参数,因此,上例会报错:
泛型语法的最后一个部分是多个类型参数。在任何情况下,只要使用类型参数,就不会只有一个。看下面的代码:
public class Test<T1, T2>
{
private Test(T1 val1, T2 val2)
{
this.val1 = val1;
this.val2 = val2;
}
private readonly T1 val1;
public T1 Val1
{
get
{
return val1;
}
}
private readonly T2 val2;
public T2 Val2
{
get
{
return val2;
}
}
}
使用多个泛型参数实际上并没有什么特别之处。重要的是必须认识到这是完全可行的,最后一点是:类中的类型参数与方法中的类型参数可以同时使用,但是必须保证它们不会发生冲突。
C#函数式程序设计之约束类型
每当使用泛型类型时,可以通过where字句对泛型添加约束:
static void OutputValue<T>(T value) where T : ListItem<string>
{
Console.WriteLine("String list value: {0}", value.Value);
}
这个例子直观地声明了一个约束:类型T必须与ListItem<string>相匹配。泛型类型约束T:X表示T可以是X、X的派生对象或X的实现(假如X是一个接口)。换言之,假如类型T的一个实例为t,则可以把它赋给一个变量:X x=t;
约束可以使用具体的类型,但是在这些情形下,类型不可以是密封的。有几个特殊的关键字可以取代或补充类型声明符。关键字class表示此类型必须是一个引用类型,而struct表示它必须是一个值类型。当new()与class或者任何具体类型一起使用时,可以给这个类型定义一个默认的构造函数。
约束的最后一个应用是定义两个类型参数的关系。例如,对于类型参数的T和U,约束T:U表示T必须与U相容。
使用约束时,有一点必须记住:泛型的基本作用是提供一个类型安全的方法,使代码可以处理不同类型的数据。约束用得越多,则离这个思想越远,因为约束降低了灵活性。
C#函数式程序设计之其他泛型类型
除了方法与类外,结构体、委托和接口也可以使用类型参数。结构体和接口使用类型参数是显而易见的,其用法与类相似:
public struct MyPoint<T> where T : struct
{
public MyPoint(T x, T y)
{
this.x = x;
this.y = y;
}
private readonly T x;
public T X
{
get
{
return x;
}
}
private readonly T y;
public T Y
{
get
{
return y;
}
}
public interface IListItem<T>
{
T Value { get; }
ListItem<T> Prepend(T value);
}
}
即使是委托,其用法也丝毫没有令人吃惊的地方:
public delegate R CreateDelegate<T, R>(T param);
public class ParameterFactory<T, R>
{
CreateDelegate<T, R> createDelegate;
public ParameterFactory(CreateDelegate<T, R> createDelegate)
{
this.createDelegate = createDelegate;
}
}
使用了泛型后,这些委托几乎可以代表任何函数。
C#函数式程序设计之协变与逆变
如果一个操作保留了类型原来的顺序,则成为协变,如果颠倒它们的顺序,则称为逆变。所谓的类型顺序是指:通用类型的顺序值比专用类型的顺序值强。下面这个例子说明C#支持协变,首先定义一个对象数组:
object[] objects = new object[3];
objects[0] = new object();
objects[1]="Just a string";
objects[2]=10;
可以把不同的值插入到这个数组中,因为所有数据最终都是派生自.NET中的Object类型。换言之,Object是一个非常通用的类型,即它是一个强类型。接下来说明.NET支持协变,它把一个弱类型的值赋给强类型的变量:
变量objects属于object[]类型,它可以保存实际类型为string[]的值。仔细想想,我们希望如此,但是结果不是这样的,毕竟,虽然string派生自object,但是string[]并不是派生自object[]。尽管如此,由于本例中C#支持协变,这个赋值是可行的。
说明逆变思想需要一个比较复杂的例子:
public class Person:IPerson
{
public Person() { }
}
public class Woman : Person
{
public Woman() { }
}
Woman是从Person派生出来的类,现在分析如下两个函数:
static void WorkWithPerson(Person person)
{ }
static void WorkWithWonman(Woman woman)
{ }
其中一个函数作用于Woman类,另一个函数比较通用,作用于Person类。从Woman类可以定义以下两个委托和函数:
delegate void AcceptWomanDelegate(Woman person);
static void DoWork(Woman woman, AcceptWomanDelegate acceptWoman)
{
acceptWoman(woman);
}
DoWork函数接受一个Woman参数和一个函数引用,后者也接受一个Woman参数。DoWork函数把Woman实例传递给委托。元素类型大小为:Person比Woman强,WorkWithPerson比WorkWithWoman强,为了应用逆变,在此认为WorkWithPerson比AcceptWomanDelegate强,看以下三行代码:
Woman woman = new Woman();
DoWork(woman, WorkWithWonman);
DoWork(woman, WorkWithPerson);
首先创建一个Woman实例,然后调用DoWork函数,把Woman实例和WorkWithWoman方法的引用地址传递给DoWork。后者显然是与委托类型AcceptWomanDelegate相容——两者都只有一个Woman类型参数,没有返回值。但第三行代码有点怪,根据AcceptWomanDelegate的要求,WorkWithPerson方法接受一个Person参数,而不是一个Woman参数。虽然如此,WorkWithPerson还是与委托类型相容,这是逆变的缘故。
因此,在委托类型下,强类型可以保存在弱类型的变量中。
变异也能应用在泛型中。如下代码:
List<object> objectList = new List<object>();
List<string> stringList = new List<string>();
objectList = stringList;
以上代码并没有得到C#的支持,编译器会报如下错误:
在C#和.NET4.0中,泛型的变异支持已删除,现在要使用泛型类型参数,可以用新增的关键字 in 和 out。这两个关键字定义或限制某个类型参数的数据流动方向,允许变异发生。