FSherp RSS

如何在Visual Studio 2008中编译F#程序

Myshuiyue — 20 Feb 2009 10:50:25

在Visual Studio 2008中,编译F#程序时,会出现警告(但不是错误),但是由于这个警告却使你的程序无法运行,不过大多数据这些警告都会有提示,提示你用.NET里的函数代替F#中的某些函数,但是这些.NET中的函数又不能像在C#中那样使用.

例如:

#light

let "]
let two = "two " :: one
let three = "three " :: two
let rightWayRound = List.rev three
let printList l =
List.iter print_string l
print_newline()
let main() =
printList one
printList two
printList three
printList rightWayRound
main()

上面的程序在Visual Studio 2008编译时,会出现警告,提示List.iter print_string l一行中print_string要用Console.Write()代替,但是如果直接把print_string直接用Console.Write()或Console.Write也还是不行.

那么到底如果使用Console.Write()代替print_string在Viusal Studio 2008中通过编译呢,

注意Console.Wirite有多个重载版本,重载时要指明版本,这要用到匿名函数并对参数进行注解

所以上面的List.iter print_string l

可改写为List.iter (fun (x:string) -> Console.Write(x)) l

这样就可以通过编译了.

增强我们的Visual Studio（更新中）

Myshuiyue — 18 Dec 2008 16:06:44

这位同事是用Java的，最近的一个.NET项目中，他来帮我们做。所以他也开始使用VS2005了，我觉得他至少具有一条Java开发人员的典型特征——对微软相当鄙夷，这个也就罢了，跟我没多大关系。其后在开发过程中，他经常抱怨VS2005不好用，又说Eclipse如何如何好用云云。说实话，本来我对微软及其产品也没有太多好感，但毕竟跟VS朝夕相处，日久生情，于是经常是他说VS哪个地方不好用，我就会为VS进行一番辩护。一段时间下来，至少也向他证明了，Eclipse的大部分功能VS2005也具备了；同时，不得不承认，VS2005的IDE有其不足。

于是我通过google找到一篇文章 Visual Studio vs Eclipse，想看看两者究竟对比如何。这篇文章里Jon Skeet更青睐于Eclipse，他提到了以下几点：

定位类型/资源
重载智能感知
组织引入
JUnit集成
导航链接
SourceSafe集成
结构差异比较
保存时编译
组合的文件和类浏览器

Jon Skeet认为，在上述方面Eclipse要强于VS2005，同时他也提到了VS2005的一些解决方案。

1、DPack

DPack是一组用于VS 2003/2005的免费工具。其目标是极大地提高开发人员的生产力，自动化重复过程，对VS的一些特性进行扩展。它包含多个浏览器工具，帮助开发人员对类、方法和程序集类型快速定位。DPack也包括增强了的书签功能，各种代码导航工具以及改进了的Surround with功能。来看几幅截图：

1.1 代码浏览器

使用便利的对话框帮助开发人员快速定位到代码成员，如方法和属性。

它与VS2005中的“Find Symbol”不同。因为它是即时更新的搜索——当你键入时，列表会即时更新。

1.2 文件浏览器

使用便利的对话框帮助开发人员快速定位到任意数量的文件。

1.3 解决方案浏览器

解决方案浏览器是类浏览器和文件浏览器的结合。

1.4 框架（Framework）浏览器

定位到一个类型，及其相应的命名空间和程序集。

1.5 计数书签（Numbered bookmark）

计数书签帮我们通过数字设置和定位书签。每个文件共有10个，从0到9。

1.6 Surround With

Surround With特性帮助我们用一些最常用的代码结构来包含选中代码。

1.7 代码导航

代码导航功能帮助我们在代码元素间跳转。

1.8 解决方案统计数据

解决方案统计工具帮助我们评估整个解决方案的体积。包括文件数，代码行数等。

1.9 解决方案备份工具

备份工具可用来备份整个解决方案或其中的单个项目。

1.10 支持选项

1.11 键盘架构

该插件确实非常方便好用，强烈推荐！

2. TestDriven.NET

我们可以单独使用NUnit，但这需要经常在VS和NUnit间切换，TestDriven.NET与VS集成，可以免除此痛。

3. GhostDoc

GhostDoc是Visual Studio的一个免费插件，可以帮助开发人员编写XML格式的注释文档。我曾翻译过一篇对其介绍的小文，有兴趣看看。

4. PInvoke.NET

PInvoke.NET是一个wiki，用于建立正确的P/Invoke签名。

先写这些，大家手头有什么好东东，也来一起推荐吧，把我们的VS打造为更好的IDE！

更新:2007-10-23

5. VSSDK Assist

芭蕉兄提供,一个用于扩展VS的可视化工具集,目标是提供扩展VS的工具和指导.

6. Microsoft Visual Studio 2005 IDE Enhancements

主要功能:

Index Find
代码结构查看器
文件比较

下载请点击这里.园子里的介绍页面链接.

更新:2007-10-24

7. PowerToys for the Class Designer and Distributed System Designer

这组Add-In增强了VS2005中已有的类设计器和分布式系统设计器的功能。

8. Bordecal.ImportsSorter add-in for Visual Studio 2005

我们在文件的开头可能会引入多个命名空间，包括.NET Frameword的，第三方，我们自己的，如果手动写还好些，如果是采用快捷键Shift+Alt+F10导入的，就可能比较乱了，该Add-In就可以帮我们来整理排序。其排序规则一定程度上还可定制。

9. SlickEdit Gadgets for Microsoft Visual Studio 2005

几个颇有意思的小玩意儿。

10. CoolCommands for Visual Studio 2005 RTM

在VS中添加多个有用的命令。

11. Resource Refactoring Tool

为开发人员提供一种简单的方式,将代码中的字符串硬编码提取到资源文件中。

12. NUnit Code Snippets for Visual Studio 2005

针对NUnit的一些Code Snippet。

13. MRU Cleaner v1.0.0.5

MRU即Most Recently Used, 指VS中的Recent Files和Recent Projects列表。在开发过程中，对于有些项目/文件，我们可能以后不再打开了；或者已经移除了；或者是通过添加已存在的项目命令打开的，我们都不希望在MRU列表中看到，该add-in可以帮助我们进行整理。

14. Clipboard Manager

维护剪贴板的内容，而且可以将这些内容“持久化”到机器上，非常方便！

15. CodeRush Xpress for C#

它包含了Code Rush和Refactor! Pro中的一些特性，这些特性包括增强的导航、选择工具、代码创建功能以及强大的重构支持。

最后，推荐两个链接，这里有大量有用的东东：

Scott Hanselman's 2005 Ultimate Developer and Power Users Tool List

Visual Studio 2005 Add-ins List on en.csharp-online.net

另：很感谢这位同事，他的偏执给我留下了很深的印象。我想作为一个程序员，是应该具备一定的偏执，它一定程度上反映了对程序的热爱，唯有热爱，才能有所成就。

F#探险之旅（八）：使用F#开发Windows应用程序

Myshuiyue — 18 Dec 2008 16:06:01

我们身在何处？

前面写过的随笔主要关注的是F#与FP的基本概念，对UI涉及很少。我们知道，没有UI就没法与用户进行交互，所以写两篇随笔来了解一下这方面的内容。本文主要关注的是如何使用F#开发WinForm应用程序，后面还会介绍如何使用F#开发ASP.NET应用程序。

不过说真的，我对WinForm开发了解不多，所以如果有不妥之处，欢迎您的指正。

WinForm中的基础类型是System.Windows.Forms.Form类，通过它我们可以创建一个窗体，在窗体上我们可以根据需要进行绘制。绘制的时候我们可以选择使用.NET提供的API手工“画”出一些图形，比如像素着色、直线、圆等等，也可以使用.NET里面的一些标准控件，比如文本框、按钮等等。接下来基于Windows应用的事件驱动的特性，通过事件（Event）和事件处理函数（Event Handler）使用户可与程序进行交互。另外，如果标准控件或窗体不能满足需要，我们还可以对其进行扩展，创建用户控件和自定义控件。

下面就来看看如何实现这些过程。

分析

在使用C#开发的WinForm应用中可以看到，我们创建的新窗体类继承了System.Windows.Forms.Form类，在程序的入口函数Main中，有一行关键的代码：

C# Code
Application.Run(new MainForm());

也就是说创建Form类的一个实例，传给Application.Run方法，程序由此开始执行。使用C#开发的一大优势在于VS IDE提供的窗体设计器，这样就可以在设计时设置窗体和控件的属性，VS会为我们生成代码，从而大大提高了开发效率。

遗憾的是，VS还没有为F#提供这样的设计时支持，也就是说我们必须手工编写所有的代码，那如果界面很复杂，不得累死啊？也不尽然。首先考虑下面的简化了的三层架构示意图：

这里并不是说程序一定要分为三层，或者说三个Project，而是说从逻辑上大体可以这样来看。大部分情况下，与设计器相关的只有UI层（不要忘了其它地方VS也可以生成代码），如果UI相当简单，完全手工编写这些代码也没什么大问题，如果UI相当复杂，就得考虑别的办法了。

F#基于.NET平台，在这一点上，它与C#、VB.NET是平等的，这一次我们又可以获益于它的互操作性（Interoperability）了！既然C#类库可被F#调用，如果我们把窗体类放在一个类库内不就可以了吗？这样一方面我们可以利用VS的设计时支持，另一方面又可利用F#带来的好处，岂不妙哉？退一步讲，我们也没必要非得使用F#开发UI部分，完全可以使用C#开发UI，其余部分使用F#开发，这也是不错的方法。

总结上面的分析，可以得到这样的结论：在开发WinForm应用时使用F#，如果UI非常简单（比如画出一条数学曲线或者只有两三个控件的小工具等），我们完全可以手工编写所有代码；如果UI比较复杂，我们使用C#开发UI类库供F#调用，也可以只采用F#编写UI之外部分的代码。

下面我们来讨论下这三种方法的具体实现。

使用F#手工编写所有UI代码

前面写过的一篇使用F#绘制Mandelbrot集合就是这么做的，因为窗体上根本就没有任何控件，此时需要处理Paint事件完成窗体的绘制。这里再提供一个简单的例子，使用WebBrowser控件创建简单的浏览器：

F# Code - Simple Web Browser

像这样的小工具，也没必要兴师动众，劳驾C#了。试试浏览一下博客园：

注意：看看上面例子的事件处理函数是怎么写的，比如go按钮的Click事件。我们知道C#中控件的事件处理函数一般有两个参数sender（:object）和e（:EventArgs），这里却只有一个，这是因为对于标准的.NET事件，F#会忽略第一个参数。

在F#中使用C#开发的UI类库

前段时间看到一个例子，是使用C#中获取本机的进程信息，感觉它难易适中，就用它做例子吧。在原文中，只有两个主要的文件，一是工具类ProcessValidation.cs，一是窗体类Form1.cs，现在我们就是要把Form1分为两部分，UI设计器相关的部分放在C#类库中，后台的代码则采用F#编写，顺便把ProcessValidation类也改为F#代码。

不过这里我按照自己的习惯给它们重新命名了，窗体是ProcessChecker，工具类是processHelper，然后在processFinder使用其中的窗体和控件，最后在Program类中定义了入口函数（FsSamples.UI中的其它文件可以略过）。

这个过程比较简单，不过有个小问题。在C#中定义的窗体类中，各个控件在默认情况下是private的，如何在processFinder中使用呢？要想把它们暴露出来有几种方法，一是把private改为public，这样虽然简单，不过不是一个好的practice；二是把控件封装为public的属性，这样做如果控件少还比较好办，多了也很麻烦；我这里采用的是第三种方法（来自Allen Lee的建议），即把控件的private修饰符改为protected，然后继承该窗体，这样仍有比较好的封装性，操作起来也比较简单，只要选中要修改的控件，把它们的Modifiers属性设置为Protected就可以了。（下载示例代码）

值得一提的是，在Application.Run方法之前，要添加一行代码：

F# Code
Application.EnableVisualStyles()

这样就可以使用XP/Vista的可视化样式了。程序的运行效果为：

仅使用F#开发UI之外的代码

得益于F#与其它.NET语言良好的互操作性，我们可以在C#中开发UI部分，然后调用F#类库，这个过程跟调用C#开发的类库相比没有很大的区别，在此就不赘述了。

其它

关于WinForm开发的主题还有创建用户控件、自定义控件等，这方面已经有大量的资料了，相信使用本文的方法，开发起来也不会很难:)

小结

本文主要讨论了如何使用F#开发Windows应用程序。通过分析，确定了三种主要的方法，重点讨论了如何在F#中利用VS中的窗体设计器，这会使WinForm程序的开发简单不少。其中的一个例子是processFinder，它可以获取当前机器上的进程和应用程序信息。

（下载示例代码）
（要了解本人所写的其它F#随笔请查看 F#系列随笔索引）

参考
《Foundations of F#》 by Robert Pickering
《Expert F#》 by Don Syme , Adam Granicz , Antonio Cisternino
Finding and Listing Processes in C#

Fashion Your Firefox

Myshuiyue — 18 Dec 2008 16:05:17

毫无疑问的，我们现在呆在网路上的时间要比走在路上的时间要多。在这里我们也怕堵车:-}，我们都希望能快点找到想要的东西。

还有，时间久了，也想把浏览器打扮地漂亮点儿。嗯，Mozilla推出了一个Add-on精选包——Fashion Your Firefox，也许能满足一下这方面的需求吧。

1. Finder and Seeker

就是更简单地找到更合适的信息，StumbleUpon很不错；

2. Social Butterfly

给那些热衷于网络交际的人们准备的，通讯录、分享照片、发布公告等等；

3. ShutterBug

在线浏览和分享图片和视频，Cooliris确实很酷；

4. Digital Pack Rat

方便地收藏站点、书签、博客。。。；

5. Rock Star

哈，把摇滚歌手放在Firefox来吧；

6. Decorator

来把Firefox打扮一下，Noia和ColorfulTabs；

7. Shopaholic

购物狂们的选择；

8. News Junkie

发生在世界各地的最新闻和天气预报，每天早上喝点Morning Coffee；

9. Executive Assistant

我只是一个普通的程序员，现在也可以有小秘啦，ReminderFox给一个TodoList，还有Glue也很棒；

F#探险之旅（七）：在F#中进行单元测试

Myshuiyue — 18 Dec 2008 16:04:36

单元测试是开发者编写的一小段代码，用于检验被测代码的一个很小的、很明确的功能是否正确。通常情况下，一个单元测试（用例）用于判断某个特定条件（或场景）下特定函数的行为。如果想对单元测试的好处有更多的了解，可以看一下单元测试实战。

在.NET社区内，NUnit无疑是最经典的单元测试工具，要了解它的用法，建议看一下园子里的一篇很棒的文章NUnit详细使用方法。本文对此不再赘述。另外MbUnit作为后起之秀，也很值得一试。

在F#中， LOP（Language-Oriented Programming）是它的一个亮点，而FsUnit则是LOP的一个很好的实践。FsUnit使用F#开发，用它编写的测试用例会接近于自然语言（英语），在其中我们也可以看到F#对函数进行组合的强大威力。

在本文中，我将通过简单的例子分别对NUnit和FsUnit的基本用法进行介绍。假定我们在开发一个类库MyFsLib，其中有一个模块mathHelper，里面有一些关于数学的函数，现在要做的就是测试这些函数。mathHelper的代码如下：

F# Code - mathHelper的签名
#light
module MyFsLib.MathHelper

/// 获取一个浮点数的平方值
val square: float -> float

/// 获取一个浮点数的立方值
val cube: float -> float

/// 判断一个整数是否为偶数
val isEven: int -> bool

/// 判断一个整数是否为奇数
val isOdd: int -> bool

/// 获取不大于指定正整数的质数数组
val generatePrimes: int -> int array

F# Code - mathHelper的实现
#light
module MyFsLib.MathHelper

open System

let pow x y = Math.Pow(x, y)

let square x = pow x 2.0
let cube x = pow x 3.0

let isEven x = x % 2 = 0
let isOdd x = x % 2 = 1

// Eratosthenes筛法
let generatePrimes n =
    match n with
    | _ when n < 2 -> [||]
    | _ ->
        // Init sieve.
        let sieve = [| for i in 0 .. n do yield true |]
       
        let isPrime index = sieve.[index]
       
        // Check it.
        let upperBound = Convert.ToInt32(Math.Sqrt((float)n))
        for i = 2 to upperBound do
            if isPrime i then
                for j in [i * 2 .. i .. sieve.Length - 1] do
                    sieve.[j] <- false
                   
        let mutable count = 0
        for i = 2 to sieve.Length - 1 do
            if isPrime i then
                count <- count + 1
               
        let primes = Array.create count 0
        let mutable index = 0
        for i = 2 to sieve.Length - 1 do
            if isPrime i then
                primes.[index] <- i
                index <- index + 1
               
        primes

使用NUnit进行单元测试

不要害怕，由于F#植根于.NET平台的本性，你会发现这些测试用例代码都是那么眼熟。

需要废话的是，先添加对”nunit.framework.dll”的引用，而且要为测试类添加一个无参构造函数。

F# Code - NUnit tester
#light
namespace NUnitTester

open NUnit.Framework
open MyFsLib

[>]
type TestCases = class
    new() = {}
   
    [>]
    member this.TestSquare() =
        Assert.AreEqual(0, MathHelper.square(0.0))
        Assert.AreEqual(4, MathHelper.square(2.0))
       
    [>]
    member this.TestGeneratePrimes() =
        let primesLessThan2 = MathHelper.generatePrimes(1)
        CollectionAssert.IsEmpty(primesLessThan2)
       
        let primesNotGreaterThan2 = MathHelper.generatePrimes(2)
        CollectionAssert.IsNotEmpty(primesNotGreaterThan2)
        CollectionAssert.Contains(primesNotGreaterThan2, 2)
        Assert.AreEqual(1, primesNotGreaterThan2.Length)
       
        let primesNotGreaterThan10 = MathHelper.generatePrimes(10)
        CollectionAssert.IsNotEmpty(primesNotGreaterThan10)
        CollectionAssert.Contains(primesNotGreaterThan10, 7)
        Assert.AreEqual(4, primesNotGreaterThan10.Length)
       
    // Other testcases
end

这里只编写了对函数square和generatePrimes的测试。如果你在C#中用过NUnit，看这样的代码就没有任何问题了。测试结果为：

使用FsUnit进行单元测试

FsUnit是一个Specification测试框架。它的目标是将单元测试和行为（函数）的规格尽量简化，并以函数式的风格代替命令式风格的测试代码。

Specification可以翻译为规格说明，就是说测试代码实际上是对待测代码的一条条规格说明。比如对函数square，它求一个数的平方，那么一条规格可以是：”square(2) should equal 4”。好了，惊喜就要来了：

F# Code - FsUnit tester
#light

open FsUnit
open MyFsLib

let squareSpecs =
    specs "Test square" [
        spec "square(0) should equal 0" 
            (MathHelper.square(0.0) |> should equal 0.0) // Pass
        spec "square(2) should equal 2" 
            (MathHelper.square(2.0) |> should equal 2.0) // Fail
    ]
    
let generatePrimes1Specs =
    specs "Test generatePrimes" [
        spec "generatePrimes(1).Length should equal 0"
            (MathHelper.generatePrimes(1).Length |> should equal 0)
    ]
    
let generatePrimes2Specs =
    specs "Test generatePrimes" [
        spec "generatePrimes(2).Length should equal 1"
            (MathHelper.generatePrimes(2).Length |> should equal 1)
        spec "generatePrimes(2) should contain 2"
            (MathHelper.generatePrimes(2) |> should contain 2)
    ]
    
let generatePrimes10Specs =
    specs "Test generatePrimes" [
        spec "generatePrimes(10).Length should equal 4"
            (MathHelper.generatePrimes(10).Length |> should equal 4)
        spec "generatePrimes(10) should contain 7"
            (MathHelper.generatePrimes(10) |> should contain 7)
        spec "generatePrimes(10) should not contain 9"
            (MathHelper.generatePrimes(10) |> should not' (contain 9))
    ]
    
printfn "%s" (Results.summary())

这里没有Assert，有的是should，这两个词给人的感觉可大不一样，而且通过函数的组合，我们可以写出should equal这样的“句子”。这里的测试代码已经比较接近自然语言了。

一条spec就是一条规格说明，它说明待测的函数具有什么样的规格，我们把这些都放在specs中，测试结束后，使用Results.summary函数来显示测试结果：

如果对FsUnit感兴趣，可以到http://code.google.com/p/fsunit/这里来看看。感觉目前它还有些欠缺，比如没有像CollectionAssert这样的测试类，接下来看看能不能扩展一下。

小结

本文介绍了在F#中如何使用NUnit和FsUnit进行单元测试。可以看到两者都很简单，前者简单是因为能很好地延续在C#中的方式，迁移过来不要费多大力气；后者简单是因为它接近自然语言，看起来很亲切。FsUnit值得关注，除了单元测试本身，我们还可以通过它来了解Language-Oriented Programming的相关知识。

（要了解本人所写的其它F#随笔请查看 F#系列随笔索引）

参考

《Foundations of F#》 by Robert Pickering
http://code.google.com/p/fsunit/

Eratosthenes筛法的F#实现

Myshuiyue — 18 Dec 2008 16:03:23

什么是Eratosthenes筛法

考虑一个常见的数论问题，指定一个整数，求出不大于该数的所有质数。我们可以先写一个函数来判断某个整数是否为质数，然后用它逐一判断每个整数，而Eratosthenes筛法比这种方法高效得多。

下面举例来说明它的原理。观察下面的彩图（来自wikipedia），这里是检查120以内的所有质数。首先去掉1，因为1既不是质数也不是合数；然后2是质数，那么2的倍数都肯定不是质数了，所以把2的倍数都涂成红色（它们出局了，这里是质数的游戏...）；接下来3没有被涂掉，所以3是质数，同理把3的倍数涂成绿色；下一个未涂掉的是5，所以5也是质数，同理把5的倍数涂掉；然后再涂掉7的倍数，剩下的就都是质数了。

怎么，只要看2、3、5、7就够了？这里有两个不那么容易确定的问题，一是如何依次断定3、5、7都是质数；二是为何涂掉7的倍数后就完成了。对于问题一，如果一个整数不能被比它小的所有质数整除（这里就是没被涂掉），那么我们就可以断定它是质数。另外，该筛法的依据是，对于整数n，如果它不能被不大于n的平方根(Sqrt(n))的任何质数所整除，那么n就是质数。这样就解决了问题二，对于120以内的整数，如果它不是质数，那么它必定能被不大于10的质数（也就是2、3、5、7）所整除。

这样我们可以确信上述算法是正确的了，下面来看看如何实现它。

Eratosthenes筛法的C#和F#实现

C# Code - Eratosthenes筛法
// 返回不大于n的质数构成的数组
public static int[] SieveOfEratosthenes(int n)
{
    if (n < 2) { return new int[0]; }

    // Init sieve.
    bool[] sieve = new bool[n + 1];
    for (int i = 2; i < sieve.Length; i++) { sieve[i] = true; }

    // Check it.
    int upperBound = Convert.ToInt32(Math.Sqrt(n));
    for (int i = 2; i <= Math.Sqrt(n); i++)
    {
        if (sieve[i])
        {
            for (int j = i + i; j <= n; j += i)
            {
                sieve[j] = false;
            }
        }
    }

    // Count it.
    int count = 0;
    for (int i = 2; i < sieve.Length; i++)
    {
        if (sieve[i])
        {
            count++;
        }
    }

    // Generate the result.
    int[] primes = new int[count];
    int index = 0;
    for (int i = 2; i < sieve.Length; i++)
    {
        if (sieve[i])
        {
            primes[index++] = i;
        }
    }

    return primes;
}

下面是F#实现，其中getInt和main是辅助函数：

F# Code - Eratosthenes筛法
#light
open System

let generatePrimes n = 
    match n with
    | _ when n < 2 -> [||]
    | _ ->
        // Init sieve.
        let sieve = [| for i in 0 .. n do yield true |]
        
        let isPrime index = sieve.[index]
        
        // Check it.
        let upperBound = Convert.ToInt32(Math.Sqrt((float)n))
        for i = 2 to upperBound do
            if isPrime i then
                for j in [i * 2 .. i .. sieve.Length - 1] do
                    sieve.[j] <- false
                    
        let mutable count = 0
        for i = 2 to sieve.Length - 1 do
            if isPrime i then 
                count <- count + 1
                
        let primes = Array.create count 0
        let mutable index = 0
        for i = 2 to sieve.Length - 1 do
            if isPrime i then
                primes.[index] <- i
                index <- index + 1
                
        primes

let getInt() = 
    Convert.ToInt32(Console.ReadLine())
    
let main() =
    let i = getInt()
    let primes = generatePrimes i
    Console.WriteLine("find {0} prime(s)", primes.Length)
    print_any primes
    
main()

Console.Read()

这两段代码也就勉强能实现算法吧，有时间再考虑优化一下。

（要了解本人所写的其它F#随笔请查看 F#系列随笔索引）

参考：

Sieve of Eratosthenes

F#探险之旅（六）：F#代码的组织

Myshuiyue — 18 Dec 2008 16:02:36

前言

是的，我们已经学习了如何在F#中使用各种范式（函数式、命令式、面向对象）进行编程。但是目前还仅限于在单个模块内编写，要知道，不管是采用哪种语言或者范式编程，如果项目规模大了，都不适合把所有代码放在单个模块内。

在常规的.NET项目中（比如C#+ASP.NET），我们往往会选择使用Solution的概念作为整个（独立）问题域的解决方案，Solution以下则是Project、File。这些概念在物理上往往表现为程序集（类库或可执行程序）、类文件等，如果项目和文件数量较多，就该好好考虑如何在组织它们。下面从这三个层次上分别来讨论一下。

Solution层次

这里主要考虑的是Project之间的相互关系，此时基本上我们可以忽略语言的不同，也可以说在这个层次上，语言的影响不大。所以说我们把那些在用C#开发时采用的代码组织原则搬过来用。比如Martin Fowler在《企业应用架构模式》中谈到的内容，比如Robert Martin在《敏捷软件开发》中提到的关于包的设计原则，还包括.NET社区中关于PetShop架构的讨论等等，都可以加以借鉴。关于这方面的内容已有大量相关的讨论，在此不再赘述。

这里只谈一个具体的问题：如何添加对其它程序集的引用。在F# CTP 1.9.6.0之前，添加对程序集的引用需要#I和#r指令，#I用来指定要引用的程序集的目录，#r则用来指定要引用程序集的路径（包含文件名，可以是相对路径或绝对路径）。这两个指令既可以放在代码文件中，也可以放在编译选项中。其中有个小窍门，注册表中.NETFramework节点下包含了各.NET版本的一些信息，其中的AssemblyFoldersEx中有若干个目录信息，如果程序集所在目录出现在AssemblyFoldersEx中，就可以直接使用#r和文件名来添加引用了。

在CTP版本中，可以像常规的C#/VB.NET项目中那样，为项目添加对其它程序集的引用（包括引用同一解决方案中的其它项目）：

而#r只能用于fsx脚本文件或者放在编译选项中。

Project层次

现在假定你已经对上述设计原则有了足够的了解，并运用这些原则完成了设计，下一步就是如何使用F#来实现这些设计。现在我们进入到了Project这个层次，需要考虑Project中各代码实体之间的关系，这些实体可以是物理上的源码文件，也可以是逻辑上的模块、类型、配置等。F#中最基本的组织结构是命名空间和模块，命名空间的概念与C#中的一样。借助于Reflector可以看到模块在编译之后就是静态类，我们在为模块添加成员时要了解，这是在向一个静态类添加成员。关于命名空间和模块的相关知识，强烈推荐Lvxuwen的如何组织程序（上、下）。

File层次

现在考虑源码文件内部的基本问题。在使用函数式编程范式时，除了模块，还可以采用F#的自定义类型，F#中的类型分为两类，一是元组（Tuple）或记录（Record）类型，它们类似于C#中的类；二是Union类型，有时又称为Sum类型。通过Reflector可以看到，元组值是Tuple类型的实例，而Tuple实现了 Microsoft.FSharp.Core.IStructuralHash和System.IComparable接口；记录和Union则直接实现了这两个接口。要了解IStructualHash接口的更多内容，请参考Jome Fisher的文章。

而在使用面向对象编程范式时，我们可以像在C#中那样定义.NET类型，比如接口、类、结构、枚举、委托等等。当然这其中的编程细节比较多（建议看看我前面写过的几篇随笔），而且对于同一问题可以采取不同的方案。这需要我们去多多学习和实战，根据不同的需要作出选择。

这里来看另一个具体的问题：如何使用F#中的签名文件（Signature file）。在学习C语言时，接触过函数原型的概念，它给出了函数的名称、参数类型和返回类型，函数签名的含义与函数原型是一样的。如果我们把模块内的函数签名抽取出来，放在单独的一个文件中，这就是签名文件的由来。它的作用在于，它可以控制模块内函数的访问修饰符。如果要使用签名文件，那么它必须与其控制的模块文件成对出现，并且文件名相同。比如：

F# Code - myModule.fsi
#light
module FsLib.MyModule

/// 获取一个浮点数的平方值
val square: float -> float

/// 获取一个浮点数的立方值
val cube: float -> float

F# Code - myModule.fs
#light
module FsLib.MyModule

open System

let pow x y = Math.Pow(x, y)

let square x = pow x 2.0
let cube x = pow x 3.0

*.fsi即签名文件，这里定义了两个函数的签名：square和cube。*.fs即实现文件，它必须要提供对应的签名文件的所有函数的实现。其它程序集的模块，只能访问*.fsi中具有签名的函数。通过Reflector可以看到，对于myModule.fs中的三个函数，square和cube的修饰符为public，而pow则为internal。

由此看来签名文件的作用很像C#中的接口。但事实上，编译后并没有真正生成接口。需要注意的是，如果要为代码添加XML文档注释，需要加在签名文件（如果模块有的话）而不是模块中。下面来看看如何在代码中添加注释。

常规注释

在F#中，单行注释使用//，而多行注释则使用(* … *)。

XML文档注释

如果为代码添加了文档注释，可以在编译时生成XML文档，然后借助于一些工具（如SandCastle）就可以生成容易使用的帮助文档。在上面的代码中可以看到，直接使用///可以为模块或其成员添加文档注释，这个要比C#中简便一些。同时也完全可以使用C#中那样完整的文档注释格式（比如使用Summary、Param等节点）。

最后，如果要在F#使用C#类库中的代码，可以参考前面写过的一篇随笔：F#命令式编程，了解关于这方面的内容。

F#的Project可以编译为类库或可执行应用程序（控制台应用程序或Windows应用程序）。我打算在后面的随笔就这两方面展开讨论，并尝试一些有实战意义的小型项目，相信到那时对代码组织的认识会更为准确。

小结

在初学F#时，我们可以很随便地将代码放在同一模块内做些尝试或者测试。但我们程序员不该是随便的人，随着项目规模的增大，代码的组织问题会变得越发重要，我们应当越加重视。在VS中进行开发时，整个项目的组织自然地分为了Solution、Project、File三个层次，本文在这三个层次上就代码组织的基本问题做了讨论，写得比较简单，欢迎您来留言讨论。

（要了解本人所写的其它F#随笔请查看 F#系列随笔索引）

参考
《Foundations of F#》 by Robert Pickering
Detailed Release Notes for the F# Sep 2008 CTP release
园子里Lvxuwen的如何组织程序（上、下）
F#先锋维坦的F# CTP 1.9.6.0 发行说明(Release Notes)摘要

理解F#中的模式匹配与活动模式

Myshuiyue — 26 Nov 2008 9:40:57

模式匹配（Pattern Matching）允许我们根据标识符值的不同进行不同的运算，它通常被拿来跟C#中的if…else或switch语法结构相比较，结论往往是模式匹配比后者要更为灵活、强大。那先来分析一下它灵活、强大在哪儿。

为什么说模式匹配是灵活、强大的？

在我前面写过的几篇随笔里面，有几次提到了模式匹配，比如它能够对简单值（整数、字符串）匹配，也可以对.NET类型进行匹配，看下面两个简单的例子：

F# Code - 对简单值和.NET类型进行匹配
// 对简单值进行匹配。
let rec fibonacci x =
    match x with
    | x when x <= 0 -> failwith "x必须是正整数。"
    | 1 -> 1
    | 2 -> 1
    | x -> fibonacci(x - 1) + fibonacci(x - 2)
  
printfn "%i" (fibonacci 2) // -> 1
printfn "%i" (fibonacci 4) // -> 3

// 对.NET类型进行匹配。
open System
let typeToString x =
    match box x with
    | :? Int32 -> "Int32"
    | :? Double -> "Double"
    | :? String -> "String"
    | _ -> "Other Type"

可以看到，这里所用的模式匹配没有给人太多惊喜，不用费多大力气就可以将其转换为if…else或switch结构了。

先别急着离开，列表是FP中的典型数据结构，我们对它应用一下模式匹配看看。

F# Code - 对列表应用模式匹配
// 对列表应用模式匹配。
let listOfList = [[2; 3; 5]; [7; 11; 13]; [17; 19; 23; 29]]

let rec concatenateList list =
    match list with
    | head :: tail -> head @ (concatenateList tail)
    | [] -> []
   
let rec concatenateList2 list =
    if List.nonempty list then
        let head = List.hd list in
        let tail = List.tl list in
        head @ (concatenateList2 tail)
    else
        []
        
let primes = concatenateList listOfList
print_any primes // [2; 3; 5; 7; 11; 13; 17; 19; 23; 29]

listOfList是一个列表的列表，两个函数concatenateList和concatenateList2的功能都是将listOfList的元素连接为一个大的列表，只不过一个用模式匹配方式实现，一个使用if…then…else结构实现。可以看到concatenateList的代码更为简洁，但仅仅如此吗？在concatenateList2中，我们按照传统的看待链表（F#中的列表以链表实现）的方式，将其中的节点一个一个取出来进行处理，这种处理方式是较为具体和细节的；而在concatenateList中我们通过两个简单的模式“head :: tail”和“[]”就覆盖了列表的所有可能，可以说，我们找到了更好地分解列表这种数据结构的方式，从而可以更为通用地处理列表。

类似的，再来看看Union类型的情况。Union类型，有时称为sum类型或discriminated union，可将一组具有不同含义或结构的数据组合在一起。它的一个典型应用是表示一颗树：

F# Code - 对Union类型应用模式匹配
type BinaryTree<'a> =
    | Leaf of 'a
    | Node of BinaryTree<'a> * BinaryTree<'a> 
    
let rec printBinaryTreeValues t =
    match t with
    | Leaf x -> printfn "%i" x
    | Node (l, r) ->
        printBinaryTreeValues l
        printBinaryTreeValues r
        
printBinaryTreeValues (Node ((Node (Leaf 1, Leaf 2)), (Node (Leaf 3, Leaf 4))))

这里通过BinaryTree<'a>定义一个泛型二叉树类型，printBinaryTreeValues函数用于打印其节点的值，这里需要判断节点的类型（子树还是叶子），有趣的是，Leaf和Node自动抽象为“模式”，不需要任何额外的工作。这样就可以看到一些所谓“灵活、强大”的影子了，对于Union类型所表示的数据结构，模式匹配可以极为简单、自然地分解、处理它。

除了列表和Union类型，元组对于模式匹配的“自适应”也是类似的，这些已经够我们解决很多问题了。那对于其它的更复杂的场景或者更特殊的领域，F#还有什么大招呢？你一定能想得到，这就是活动模式。

活动模式（Active Pattern）

活动模式的思想就是把模式匹配语法用于其他更多的数据结构。可以把它分为Single-Case、Multi-Case、Partial这几种类型。我将逐一做出介绍。

Single-Case活动模式

Single-Case是最简单的活动模式形式，它将一个输入值转换为其它的值，比如：

F# Code - Single-Case活动模式
let (|UpperCase|) (x:string) = x.ToUpper()
let result = match "foo" with
             | UpperCase "FOO" -> true
             | _ -> false
             
printfn "%b" result // -> true

这里的UpperCase就是一个模式，它的类型信息为：active recognizer UpperCase: string -> string，可以看到下面求result值的时候可以像前面一样使用模式匹配的语法了，UpperCase “FOO”可以理解为对于输入值”foo”，应用了UpperCase模式后，结果应当为”FOO”，如果确实如此，那么该模式就匹配了，所以result的值为true。

UpperCase模式看起来像是一个函数，不过对于函数来说，没法直接应用模式匹配的语法。

Multi-Case活动模式

F# Code - Multi-Case活动模式
let (|Odd|Even|) x = if x % 2 = 0 then Even else Odd
let isDivisibleByTwo x = match x with Even -> true | Odd -> false
print_any (isDivisibleByTwo 2) // -> true
print_any (isDivisibleByTwo 3) // -> false

这里(|Odd|Even|)就是Multi-Case模式了，Even的类型信息为：active recognizer Even: int -> unit，即它没有返回值，所以在匹配时，直接写Even或Odd就可以了。

Partial活动模式

简单来说，Partial模式就是那些并不总是返回值的模式。比如输入值的范围可能过于庞大，或者对于某些返回值我们并不感兴趣，可以将其忽略。比如，对于自然数来说，只有一小部分是完全平方数或者能够被7整除。

F# Code - Partial活动模式
// Partial Active Patterns
open System
let (|DivisibleBySeven|_|) input = if input % 7 = 0 then Some() else None

let (|IsPerfectSquare|_|) (input : int) =
    let sqrt = int (Math.Sqrt(float input))
    if sqrt * sqrt = input then
        Some()
    else
        None

let describeNumber x =
    match x with
    | DivisibleBySeven & IsPerfectSquare -> 
        printfn "x is divisible by 7 and is a perfect square."
    | DivisibleBySeven                   -> printfn "x is divisible by seven."
    | IsPerfectSquare                    -> printfn "x is a perfect square."
    | _                                  -> printfn "x looks normal."
    
describeNumber 49 // x is divisible by 7 and is a perfect square.
describeNumber 35 // x is divisible by seven.
describeNumber 25 // x is a perfect square.
describeNumber 20 // x looks normal.

自然数有很多特性，而在函数describeNumber中，我们只关注它是否是完全平方数或者7的倍数，其它的就都舍弃不管了。

应用

我们来看看如何使用活动模式来操作XML文档。

F# Code - 应用活动模式操作XML文档
// 定义针对XML节点的模式
let (|Node|Leaf|) (node : #System.Xml.XmlNode) =
     if node.HasChildNodes then
         Node (node.Name, { for x in node.ChildNodes -> x })
     else
         Leaf (node.InnerText)

// 打印XML节点的函数 
let printXml node =
     let rec printXml indent node =
         match node with
         | Leaf (text) -> printfn "%s%s" indent text
         | Node (name, nodes) ->
             printfn "%s%s:" indent name
             nodes |> Seq.iter (printXml (indent + "    "))
     printXml "" node
     
// 定义XML节点
let doc =
    let temp = new System.Xml.XmlDocument()
    let text =  "
                 
                     1
                     3
                 
                 2
                 4
             "
    temp.LoadXml(text)
    temp

printXml (doc.DocumentElement :> System.Xml.XmlNode)

这里首先定义针对XML节点的模式，然后应用该模式来递归打印出一个XML节点及其子节点的信息。

可以看到使用活动模式，寥寥数语就可以描述出XML节点的通用数据结构来了，这为接下来对节点的操作提供了良好的基础，而且我们回归了问题本身——XML文档，而不需要关注具体的编程细节。

小结

这里先是介绍了F#中模式匹配的用法，这个可以理解为使用F#内置的模式，这样我们就可以处理F#中的值和特定的数据结构，比如列表、Union类型和元组等；接下来更进一步，活动模式把模式匹配的语法用到了其他更多的数据结构，这样模式的应用范围得到了很大的扩展。而且通过活动模式，我们可以将问题域转换为一套术语来表达，从而脱离编程细节回归到问题域本身，这也就有了一些LOP（Language-Oriented Programming）的特点，事实上，活动模式正是F#中LOP的实现方式之一。这个我将在后面的随笔做更深入的讨论。

（要了解本人所写的其它F#随笔请查看 F#系列随笔索引）

参考
超越F#基础——活动模式 by Robert Pickering；
Introduction to F# Active Patterns by Chris Smith；

在F#中进行单元测试

Myshuiyue — 18 Nov 2008 13:53:26

F# Code - mathHelper signature
#light
module MyFsLib.MathHelper

/// 获取一个浮点数的平方值
val square: float -> float

/// 获取一个浮点数的立方值
val cube: float -> float

/// 判断一个整数是否为偶数
val isEven: int -> bool

/// 判断一个整数是否为奇数
val isOdd: int -> bool

/// 获取不大于指定正整数的质数数组
val generatePrimes: int -> int array

F# Code - mathHelper implementation
#light
module MyFsLib.MathHelper

open System

let pow x y = Math.Pow(x, y)

let square x = pow x 2.0
let cube x = pow x 3.0

let isEven x = x % 2 = 0
let isOdd x = x % 2 = 1

let generatePrimes n =
    match n with
    | _ when n < 2 -> [||]
    | _ ->
        // Init sieve.
        let sieve = [| for i in 0 .. n do yield true |]
       
        let isPrime index = sieve.[index]
       
        // Check it.
        let upperBound = Convert.ToInt32(Math.Sqrt((float)n))
        for i = 2 to upperBound do
            if isPrime i then
                for j in [i * 2 .. i .. sieve.Length - 1] do
                    sieve.[j] <- false
                   
        let mutable count = 0
        for i = 2 to sieve.Length - 1 do
            if isPrime i then
                count <- count + 1
               
        let primes = Array.create count 0
        let mutable index = 0
        for i = 2 to sieve.Length - 1 do
            if isPrime i then
                primes.[index] <- i
                index <- index + 1
               
        primes