前言

面向对象的思想已经非常成熟，而使用C#的程序员对面向对象也是非常熟悉，所以我就不对面向对象进行介绍了，在这篇文章中将只会介绍面向对象在F#中的使用。

F#是支持面向对象的函数式编程语言，所以你用C#能做的，用F#也可以做，而且通常代码还会更为简洁。我们先看下面这个用C#定义的类，然后用F#来定义。

//定义一个二维点[DebuggerDisplay("({X}, {Y})")]public class Point2D{    // 用于统计已实例化的数量private static int count = 0;    // 原点public readonly Point2D OriginalPoint = new Point2D(0, 0);    // 完整属性Xprivate double x;    public double X{        get { return this.x; }        set { this.x = value; }}    // 自动属性Ypublic double Y { get; set; }    // 到原点的距离public double LengthToOriginal{        get { return this.GetDistance(this.OriginalPoint); }}    // 默认构造函数public Point2D() : this(0,0) {}    // 包含两个参数的构造函数public Point2D(double x, double y)    {        this.X = x;        this.Y = y;count++; // 创建新点时，数量递增1}    // 将(x,y)数值转为Point2D对象的静态方法public static Point2D FromXY(double x, double y)    {        return new Point2D(x, y);}    // 计算到指定点的距离public virtual double GetDistance(Point2D point)    {        var xDif = this.X - point.X;        var yDif = this.Y - point.Y;        var distance = Math.Sqrt(xDif * xDif + yDif * yDif);        return distance;}    //重写ToString方法public override string ToString()    {        return String.Format("Point2D({0}, {1})", this.X, this.Y);}
}

定义类

在F#中定义类不需要class关键字，除非定义一个空的类。

type Point2D() = class          //定义一个空类endtype internal Point2D() = class //定义一个空的internal类endtype Point2D() =                //定义一个只包含字段x的类let mutable x = 0.0

不像C#，在F#中，类的访问修饰符默认是public的，所以internal就需要手动指定。并且，在F#，不支持protected访问修饰符，在F#中应该使用接口，对象表达式和高阶函数来实现类似功能。

字段（Field）

在上一例代码中我们已经定义了一个字段x，但类中用let定义的字段（包括后面介绍的函数）均为private的。若需要定义其他访问修饰符的字段，需要使用val定义。

type Point2D() =    [<DefaultValue>] val mutable public x : float

其中DefaultValue特性用于将支持零值初始化的类型（具有零值的基元类型、可为null的类等）字段初始化为零值。

属性（Property）和索引器

使用member关键字定义属性，注意F#中的属性需要有一个对象标识符（类似C#中的this）作为前缀。

type Point2D() =    let mutable x = 0.0// 定义属性X，其中set为private的。member this.X with get()  = x                  and private set(v) = x <- v    member val Y = 0.0 with get, set    //自动属性

在F#中，this也可以使用其他名称来代替。除了this（C++和C#的习惯），有的人还使用self（Python等的习惯）、me（VB.NET的习惯）等。若不需要在属性或方法内部使用到，一般还习惯使用__（两个下划线）来作为对象标识符。

而像C#set方法中的value，F#中也需要自己指定，如例子中使用v。当然get和set都可以省略使之成为只写或只读属性。

遗憾的是自动属性中不支持分别定义访问修饰符（如C#中的{get; private set}），只能使用完整属性来定义。

方法（Method）

方法同样使用member定义，而静态方法只需在member前添加static关键字。

type Point2D() =……  //因为篇幅省略属性X,Y的代码// 定义一个函数来获取指定点到当前点的距离member this.GetDistance (point:Point2D) =        let xDif = this.X - point.X        let yDif = this.Y - point.Y        let distance = sqrt (xDif**2. + yDif**2.)        distance    static member FromXY (x:double, y:double) =        let point = Point2D()point.X <- xpoint.Y <- ypoint

重载方法

F#类中的方法重载与C#一样，只需重新定义一个同名成员函数，且签名不同即可。下面实现一个接受int类型的FromXY方法：

static member FromXY (x:int, y:int) =Point2D.FromXY(float x,float y)     

返回目录

构造函数与实例化

F#中有两种构造函数，一为主构造函数（也称隐式构造函数），上面例子中在类型定义后面的()即表示一个无参构造函数。

另一种构造函数（显示定义）是可选的，在类里定义一个new函数即可。但new函数必须满足以下条件：

• 返回类型必须为该类

• 不使用member和对象标识符。

• 使用一个元组或unit作为参数。

我们改造上面的代码：

type Point2D (xValue:double, yValue:double) =    let mutable x = xValue    member val Y = yValue with get, set    new() = Point2D(0.0,0.0)

其中，调用无参构造函数时，则使用主构造函数实例化，且两个参数均为0.0。

若要为构造函数添加访问修饰符，写在其之前即可。

type internal Point2D internal (xValue:double, yValue:double) =    private new() = Point2D(0.0,0.0)

需要注意的是，在类型定义之后若不提供主构造函数，F#并不像C#那样有一个无参的构造函数。

下面的代码能通过编译，但你无法进行实例化：

type Point2D = class end

在类中的let绑定会在调用主构造函数时运行，但如果需要在主构造函数中执行其他操作，需要使用do绑定。

type Point2D(xValue:double, yValue:double) =    let mutable x = xValue    static let mutable count = 0docount <- count + 1

注意let代码和do代码必须在member之前。而do语句中必须返回unit，可使用ignore函数丢弃返回值。

非静态的do语句会在实例化时执行，而静态的do语句会在第一次使用该类型时执行。而在没有主构造函数的类中，无法使用let和do语句。

如果需要在do语句中访问其他方法，则需要类级别的对象标识符，在类型定义后使用as关键字指定；若想在非主构造函数中执行额外的代码，使用then关键字：

type Point2D (xValue:double, yValue:double) as self =    do  //省略其他代码self.Print "在主构造函数中。"new() as this= //主构造函数中使用self，此处用this。定义为任何名称都可以Point2D(0.0,0.0)then this.Print "在无参构造函数中。"member this.Print str = printfn "%s" str

但这样有一个问题：在执行do代码访问Print函数时，需要self已经实例化好，但因为Y自动属性，编译时会在do后面插入一个Y@字段（即Y的back-end字段），此时并未初始化。即违反了“先定义后引用”的原则。

所以，若在构造函数中需要访问类中的方法，只能将Y也更改为完整属性，并且x和y字段的let绑定必须在do之前。

实例化

在上面代码中的new()构造函数中，实例化了一个Point2D(0.0,0.0)对象。在F#中，实例化时可以不使用new关键字，但有特例，在后面会介绍。

在C#中，我们可以使用对象初始化器（Object Initializers）在初始化时对属性进行赋值，在F#中，也有类似功能：

var pt = new Point2D() {X = 3.0};   //C#中使用对象初始化器

let pt = Point2D(X=3.0)         //F#中使用对象初始化器，注意此处调用的是无参构造函数

到此，可将上面的FromXY方法进行简化：

static member FromXY (x:double, y:double) =Point2D(x,y)

抽象类（Abstract Class）和密封（Sealed）

要将类定义为抽象类或密封类，只需要在类定义前加上[<AbstractClass>]或[<Sealed>]特性。

抽象方法和虚方法

在F#中，没有提供virtual关键字来定义虚方法。而使用定义一个抽象方法，并提供默认实现来代替。

type Point2D(xValue:double, yValue:double) as this=……    // 实现开头C#代码中的GetDistance虚方法，此处省略其他代码abstract GetDistance : point:Point2D -> doubledefault this.GetDistance(point) =        let xDif = this.X - point.X        let yDif = this.Y - point.Y          let distance = sqrt (xDif**2. + yDif**2.)distance

关键字abstract用来定义抽象方法，只给出函数签名，并且函数名前不需使用对象标识符；而default默认实现语句中也不需使用member关键字。

与C#一样，在派生类中进行override关键字重写基类中的虚方法：

type Point2D(xValue:double, yValue:double) =……    //重写Object类中的ToString虚方法，此处省略其他代码override this.ToString() = sprintf "Point2D(%f, %f)" this.X this.Y

在C#中，若要重写非虚方法，可使用new关键字。F#中没有此关键字，但仍然可以重写非虚方法，只是编译器会给出警告。类的继承与接口的实现在下一篇中介绍。

索引器（Indexer）及切片（Slice）

索引器

索引器，顾名思义就是可以使用索引来操作对象。在F#中，只需定义一个名为Item的属性或方法即可让该类的对象使用索引器。当然，若Item定义为方法，则索引器为只读的。

我们用下来的代码定义一个可变的字符串类。

open System.Collections.Generic type WordBuilder(startingLetters : string) =    let m_letters = new List<char>(startingLetters)member this.Itemwith get idx   = m_letters.[idx]and  set idx c = m_letters.[idx] <- cmember this.Word = new string (m_letters.ToArray())let wb = WordBuilder("I Love C#")
wb.[7] <- 'F'printfn "%s" wb.Word    //输出为："I Love F#"

注意在使用索引访问时，需要使用点访问（.[]）。

切片

切片和索引器类似，不过索引器访问的是一个元素，而切片访问的是数据的集合。实现切片访问需要添加GetSlice方法，切片是只读的。

open System.Collections.Generic type WordBuilder(startingLetters : string) =…… //其他代码省略member this.GetSlice(lower:int option,upper:int option) =letters |> Seq.skip (lower.Value)|> Seq.take (upper.Value - lower.Value + 1)|> Seq.toArray      let wb = WordBuilder("I Love C#")
printfn "%A" wb.[2..5]      //输出为：[|'L'; 'o'; 'v'; 'e'|]

此切片方法并未实现完整，但已可了解实现方法。注意GetSlice的参数必须是'a option泛型类型， 其中option类型将在后面再介绍，可理解为类似于Nullable<int>。

返回目录

结语

通过以上的介绍，熟悉C#面向对象的朋友内容应该能了解F#与C#间语法的差别了。至少也可以将C#代码按面向对象的风格翻译成F#代码了，下面是文章开头C#代码的F#版本：

open System.Diagnostics[<DebuggerDisplay("({X}, {Y})")>]type Point2D (xValue:double, yValue:double) as self =    let mutable x = xValue   

 static let mutable count = 0    doself.OriginalPoint2 <- new Point2D()count <- count + 1member __.OriginalPoint with get () = Point2D()    member this.LengthToOriginal with get () = this.GetDistance(this.OriginalPoint)        new() = Point2D(0.0,0.0)    member __.X with        get()  = x                and private set(v) = x <- v    member val Y = yValue with get, set    // 一个虚函数：获取指定点到当前点的距离abstract GetDistance : point:Point2D -> double    default this.GetDistance(point) =        let xDif = this.X - point.X        let yDif = this.Y - point.Y        let distance = sqrt (xDif**2. + yDif**2.)distance        static member FromXY (x:double, y:double) =Point2D(x,y)        override this.ToString() = sprintf "Point2D(%f, %f)" this.X this.Y

需要注意的是C#代码中的OriginalPoint公开字段在此处以只读属性实现。主要是因为：

• F#中的let绑定的字段只能为private，无法设置为public。

• val绑定的显示字段（包括自动属性）需要在主构造函数中初始化，而OriginalPoint的类型也为Point2D，在此会形成递归调用而引发StackOverflowException异常。

最后再简单说下类中let和val的区别：

• let始终是private的，且需要有主构造函数才能定义，因为let语句在主构造函数中运行（同do语句）。

• val默认为public的，并且可添加修饰符使之成为internal或private的。若有主构造函数，需要为val字段添加DefaultValue特性。val与member关键字结合使用，可声明自动属性。

• 在类中访问val字段，需要使用对象标识符，而let字段不需要。

注意，此DefaultValue位于Microsoft.FSharp.Core命名空间，不要和C#中常用的位于System.ComponentModel的DefaultValue混淆。

相关文章：

• 如果你也会C#，那不妨了解下F#（1）：F# 数据类型

• 如果你也会C#，那不妨了解下F#（2）：数值运算和流程控制语法

• 如果你也会C#，那不妨了解下F#（3）：F#集合类型和其他核心类型

• 如果你也会C#，那不妨了解下F#（4）：了解函数及常用函数

• 如果你也会C#，那不妨了解下F#（5）：模块、与C#互相调用

• 【送书活动】机器学习项目开发实战

• 《机器学习项目开发实战》送书活动结果公布

• F#年度调查结果概述
  

原文地址：http://www.cnblogs.com/hjklin/p/fs-for-cs-dev-6.html

.NET社区新闻，深度好文，微信中搜索dotNET跨平台或扫描二维码关注