F#探险之旅（四）：面向对象编程（中）

F#系列随笔索引

对象表达式（Object Expressions）

F#中的OOP语法很简洁，而对象表达式则正是这种简洁性的核心所在。通过对象表达式，我们可以创建抽象类或接口的轻量级实现，也可以对一个具体的类进行继承。换言之，可以在实现抽象类或接口，或者继承具体类的同时创建新类型的一个实例。下面来看如何对泛型接口IComparer<’T>应用对象表达式。

#light
open System
open System.Collections.Generic

let revStringComparer =
    { new IComparer<string>
        with
            Compare(s1, s2) =
                let rev (s : string) =
                    new string(Array.rev(s.ToCharArray()))
                let reversed = rev s1
                reversed.CompareTo(rev s2)
    }

let winners = [| "Sandie Shaw"; "Bucks Fizz"; "Dana International"; "Abba" |]

print_any winners
print_newline()
Array.Sort(winners, revStringComparer)
print_any winners

运行结果为

[|"Sandie Shaw"; "Bucks Fizz"; "Dana International"; "Abba"|]
[|"Abba"; "Dana International"; "Sandie Shaw"; "Bucks Fizz"|]

这里演示了实现IComparer的过程，该接口有一个方法Compare，它接受两个参数并通过返回值来表示参数比较的结果。它是泛型接口，这里的类型参数为string，可以在标识符revStringComparer定义的第二行看到。从标识符的名字也可以了解到，它是将参数颠倒后进行比较，运行结果的第二行印证了这一点。可以看到“在实现接口的同时返回一个实例”。

看看多重继承的情况。在C#中，一个类不能继承多个类，却可以同时实现多个接口，F#也是一样的。要注意的是，如果同时继承类并实现接口，须将类的部分房子最前面；而且必须在第一个类/接口定义完毕之后才能开始第二个接口的实现。

#light
open System
open System.Drawing
open System.Windows.Forms

let makeNumberControl(n: int) =
    { new Control(Tag = n, Width = 32, Height = 16) 
      with
          override x.OnPaint(e) =
              let font = new Font(FontFamily.Families.[1], 12.0F)
              e.Graphics.DrawString(n.ToString(), font, Brushes.Black, 
                  new PointF(0.0F, 0.0F))
            
      interface IComparable 
      with
          CompareTo(other) =
              let otherCtrl = other :?> Control in
              let n1 = otherCtrl.Tag :?> int in
              n.CompareTo(n1) }
    
let numberCtrls =
    let temp = new ResizeArray<Control>()
    let random = new Random()
    for index = 1 to 10 do
        temp.Add(makeNumberControl(random.Next(100)))
    temp.Sort()
    let height = ref 0
    temp |> Seq.iter
        (fun c ->
            c.Top <- !height
            height := c.Height + !height)
    temp.ToArray()
    
let myForm =
    let temp = new Form() in
    temp.Controls.AddRange(numberCtrls);
    temp
    
[<STAThread>]
do Application.Run(myForm)

在对象表达式makeNumberControl中，它继承了Control类，同时也实现了IComparable接口。这里可以看到，在CompareTo方法中根据控件的Tag值进行比较，在调用Sort方法（ResizeArray即泛型类List<’T>）时会根据Compare方法对控件进行排序。排序完成后，依次呈现这些控件，如下图：


对象表达式是一种强大的机制，可以帮助我们快速而简洁地将非F#库中的对象引入F#代码。它的缺点则是没法添加额外的属性或方法。这也是在前面的例子中为何使用Tag属性来存放n的值。

定义接口

接口仅包含抽象的方法和属性。它为所有实现它的类定义了一份“契约”。F#中接口的概念与C#中的相同，在此不再赘述。如：

type MyInterface = interface
    abstract ChangeState : int -> unit
end

实现接口

实现接口的语法也很简单。仍以上面的接口为例：

type MyImpl = class
    val mutable state : int
    new() = { state = 0 }
    interface MyInterface with
        member x.ChangeState y = x.state <- y
    end
end

let impl = new MyImpl()
let inter = impl :> MyInterface

let printIntAndNewLine i =
    print_int i
    print_newline()

let main() =
    inter.ChangeState 1
    printIntAndNewLine impl.state
    inter.ChangeState 2
    printIntAndNewLine impl.state

main()

运行结果为：

1
2

不知你有没有注意到，在调用ChangeState方法前，我们先将impl转换为了MyInterface类型，否则不能调用。这是因为接口在F#中是显式实现的，如果希望不经转换就可以直接调用接口的方法，只能在类中在显式地添加这个方法:-(

类、字段和显式的构造函数

前面我们主要还是使用非F#库中的类，现在来看看如何定义自己的类。

#light
type EmptyClass = class
end

let emptyItem = new EmptyClass()

嗯，很明显，这里试图定义一个类，然后创建它的一个实例。不过编译器不允许你这么做，它会告诉你：“error FS0191: No constructors are available for the type 'EmptyClass'”。没有构造函数？如果你是C#程序员就会觉得奇怪了。事实上，F#没有提供默认的构造函数这种机制，我们必须得手工添加一个，构造函数的名字总是为new。

type EmptyClass = class
    new() = {}
end

另外，默认的构造函数容易使得字段不能正确地初始化，会给程序带来隐患，而在F#中的构造函数必须初始化所有字段。使用val关键字定义字段，在下面的类MyFile中，它拥有两个字段，path和innerFile，两个字段在构造函数内进行初始化。

#light
open System.IO

type MyFile = class
    val path : string
    val innerFile : FileInfo
    new() = new MyFile("default.txt")
    new(p) =
        { path = p; 
          innerFile = new FileInfo(p) }
end

我们还可以看到，这个类有两个构造函数，也就是说构造函数可以重载。观察构造函数new(p)，它有一部分在{}内，这个代码块称为构造函数的初始化块，在这里唯一能做的事情就是初始化字段。如果想做更多的事情，就要在后面加then添加其它代码：

type MyFile2 = class
    val path : string
    val innerFile : FileInfo
    new(p) as x =
        { path = p;
          innerFile = new FileInfo(p) }
        then
        if not x.innerFile.Exists then
            let textFile = x.innerFile.CreateText()
            textFile.Dispose()
end

new(p)后面加了as x，这样就可以在后面的代码中引用当前的对象了。then后面的代码首先检查文件是否存在，如果不存在就创建一个新文件。

注意：上面两个类MyFile和MyFile2中的字段都是只读的，如果需要修改它们，可以在字段名字前面添加关键字mutable，如val mutable innerFile；同时它们的访问修饰符都是public，在下一篇文章将介绍如何在类中定义属性。

思考：在函数式编程（下）中，曾介绍过自定义的记录类型，比如

type couple = { him : string; her : string }

那么这里的couple类和上面的MyFile类主要有哪些区别呢？请出我们的老朋友.NET Reflector来吧。在Reflector中打开编译过的F#程序集可以看到，couple的类型定义为：

public sealed class couple : IStructuralHash, IComparable

这是一个sealed类，这意味着无法继承它，其中的her和him都是只读属性。
而MyFile的定义则是：

public class MyFile

这个就跟C#中常规类的定义一致了，其中的path和innerFile都是只读属性。

隐式的类构造（Implicit Class Construction）

除了上面的显式构造函数，F#还支持隐式的类构造语法，这样的语法更为紧凑。它允许在定义类的成员前执行一系列的let值绑定语句，这些绑定属于类的私有部分。

#light
open System.IO

type MyOtherFile(path) = class
    let innerFile = new FileInfo(path)
    member x.InnerFile = innerFile
end

我觉得对于前面的（显式的类构造）MyFile类定义，这里的MyOtherFile类当然更为紧凑，看起来在定义类的同时就定义了构造函数，随后马上初始化了字段，不过这里的innerFile已经是私有的了，所以再添加一个属性InnerFile来公开innerFile字段。

隐式的类构造要比等价的显式类构造代码少很多，但是有时必须要用显式的类构造，比如编写拥有多个构造函数的类的时候。

小结

本文首先介绍了强大的对象表达式机制，通过它，我们可以快速地创建抽象类或接口的轻量级实现；接下来是定义和实现接口；最后介绍了如何创建和实例化一个类，在创建类实例的时候，我们既可以采用显式的构造函数，也可以采用更为紧凑的“隐式的类构造”机制。

F#系列随笔索引

注意：本文中的代码均在F# 1.9.4.17版本下编写，在F# CTP 1.9.6.0版本下可能不能通过编译。

参考：
《Foundations of F#》 by Robert Pickering
《Expert F#》 by Don Syme , Adam Granicz , Antonio Cisternino
《F# Specs》