C#函数式程序设计之泛型

秒速五厘米 2022-08-27 02:27 162阅读 0赞

在面向对象语言中，我们可以编写一个元素为某个专用类型（可能需要为此创建一个ListElement）的List类，或者使用一个非常通用、允许添加任何类型元素的基类（在.NET中，首先想到的是System.Object）。这两种方法都有缺点。使用通用类型的基类时，很可能会把不相容的元素添加到列表中；如果使用元素为专用类型的列表，只是推迟此问题的发生，因为实际类型是在最后封装到这个类中。泛型提供了这个问题的解决方法。

一般而言，一个泛型类型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");  
错误如下：  
![161109157303573.png][]  
  
尽管这个例子很简单，但它说明泛型的一个作用：不是使用类型对象的参数，而是在调用中显式说明类型，这回启动严格的类型检查。  
另一方面，许多程序员认为直接使用显式类型过于草率，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的类型参数，因此，上例会报错：  
  
![161141221054154.png][]  
泛型语法的最后一个部分是多个类型参数。在任何情况下，只要使用类型参数，就不会只有一个。看下面的代码：  
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\#的支持，编译器会报如下错误：  
![171153060211149.png][]  
在C\#和.NET4.0中，泛型的变异支持已删除，现在要使用泛型类型参数，可以用新增的关键字 in 和 out。这两个关键字定义或限制某个类型参数的数据流动方向，允许变异发生。

[161109157303573.png]: /images/20220824/de60d9b925784b0aae1c5b7e7a7491f7.png
[161141221054154.png]: /images/20220824/fbf83a9e20584fd4a5c7ae6560da2727.png
[171153060211149.png]: /images/20220824/113c8b703c3647f4bf5b67de43e0230d.png