F# 项目
在之前的几篇文章介绍的代码都在交互窗口（fsi.exe）里运行，但平常开发的软件程序可能含有大类类型和函数定义，代码不可能都在一个文件里。下面我们来看VS里提供的F#项目模板。
F#项目模板有以下几种类型（以VS2015为例）：
- Silverlight库创建Silverlight的类库
- 教程模板是一个控制台应用程序，里面包含了F#的示例，可通过这个项目快速了解F#相关内容。
- “可移植库”则可创建用于多平台的库，支持的平台在括号里说明。
- “库”用于创建类库
- “控制台应用程序”大家就熟悉了。
- 安卓项目为安装了Xamarin创建的，请忽略。
我们创建一个控制台应用程序来说明，下图为程序的Program.fs文件及运行结果：
我们添加一行代码（图中蓝框中）防止运行结束自动退出，这个应用程序默认是把参数打印出来，而运行时参数为空，所以结果为一空数组（[||]）。
其中ignore函数用于丢弃System.Console.ReadKey()结果。
现在项目中除了AssemblyInfo.fs外，只有Program.fs一个文件，下面我们先了解模块的相关信息再创建其他文件。
模块
模块简介
模块（Module）是F#程序代码的基本组织单位。默认情况下，每个F#代码文件（后缀为.fs）对应一个模块，且必须在文件开头指定模块名称。
创建模块
我们创建File1.fs文件时，默认会在开头添加module File1，当然也可自己改成其他名称。
module File1
let x = 1
在其他模块中使用File1.x进行访问。
文件顺序
F#项目中的文件是有顺序要求的，在上面的文件无法访问下面的模块。我们可以使用Alt+上/下箭头进行调整文件顺序，或在文件上点击右键进行操作：
嵌套模块
模块中可嵌套模块，但定义内层模块需要在模块名后使用等号（=），且内层模块的内容必须比它的上层模块缩进一级。
module TopLevelModel
module NestedModule = //第一层嵌套模块
let i = 1
module NestedModuleInNestedModule = //第二层嵌套模块
let i = 2
使用模块
若想不使用模块名访问模块中的值时，则可使用open关键字进行打开。但有两个需要注意的地方：
强制显示访问
在上一章介绍的集合模块中，我们从未使用open List或者open Seq这样的操作。
使用F12转到Seq的代码定义文件可以发现Seq模块使用了
[<RequireQualifiedAccess>]（强制显示访问）。
附加了此特性的模块在使用时必须使用模块名访问，因为几个集合模块中有大部分函数名称是相同的，若设置此特性而可同时打开了多个模块，则函数名称将会冲突。
自动打开
而我们在使用printfn和ignore函数时，均不需要打开相关模块，是因为在他们所属模块附加了[<AutoOpen>]（自动打开）的特性。像Operators模块里有我们常用的运算符，为了方便使用，添加了自动打开的特性。
我们在自定义模块时可根据需要使用这两个特性。
命名空间
命名空间（Namespace）和模块类似，不同的是命名空间里不能直接定义值，只能定义类型。（与C#中的命名空间一样，可以想象我们无法在C#的命名空间中直接定义一个方法，而需要首先定义一个类。）
但F#中的命名空间不能像模块那样嵌套，但可以在同一文件中定义多个命名空间。
namespace PlayingCards
type Suit = Spade | Club | Diamond | Heart
namespace PlayingCards.Poker
type PokerPlayer = {Name:string; Money:int; Position:int}
上面的代码在一个文件中使用两个命名空间分别定义了一个类型。
其中Suit为可区分联合（Discriminated Union）类型；PokerPlayer为记录（Record）类型。将在下一篇介绍。
应用程序入口
在F#中，程序从程序集的最后一个文件开始执行，而且必须是一个模块。但最后一个模块的名称可省略。
也可以使用[<EntryPoint>]特性应用于最后一个代码文件的最后一个函数，使其成为程序入口点而无需显示调用。
可查看控制台应用程序项目的模板：
[<EntryPoint>]
let main argv =
printfn "%A" argv
0
main函数的参数是一个数组（通常可自定义为字符串数组），是应用程序的运行参数，返回的整数则为程序的退出代码（exit code）。
若不使用[<EntryPoint>]，则需要在最后调用该函数，否则并不会自动调用该函数。
let main (argv:string[]) =
printfn "%A" argv
System.Console.ReadKey(true) |> ignore
0
main [||]
控制台应用程序通常在结束之前使用System.Console.ReadKey()方法来防止运行完成自动退出。
扩展模块
可以通过创建一个同名模块，在其中添加值来对原有模块进行扩展。
在介绍常用函数时，我们提到Seq模块没有提供rev函数，现在自己实现以对Seq模块进行扩展。
open System.Collections.Generic
module Seq =
/// 反转Seq中的元素
let rec rev (s : seq<'a>) =
let stack = new Stack<'a>()
s |> Seq.iter stack.Push
seq {
while stack.Count > 0 do
yield stack.Pop()
}
其中使用了.NET框架中的泛型栈集合类型（System.Collections.Generic.Stack<T>）。
与C#互相调用
F#代码和C#代码（包括VB.NET）一样，都编译成MSIL，在CLR运行。（可参考文章《.NET框架》）所以，两种语言之间可以方便地互相调用。
程序集的引用大家都熟悉，但C#和F#中又有一些独立的东西不能互相使用，下面简单介绍一下在互相调用中常见的问题。
F#调用C#代码
本节涉及操作需要创建两个项目，一个C#的类库项目，一个F#的控制台项目。然后F#项目引用C#项目。
dynamic：在F#中访问C#的动态类型
在.NET4.0，C#引入了dynamic关键字使得可以像使用动态语言一样来使用C#。但在F#中并不支持dynamic关键字和动态类型，在引用C#编译的程序集时，则变成了Object类型。
我们知道dynamic在Microsoft.CSharp.dll程序集中实现，在F#中可以通过引用此程序集，通过反射等操作自己实现对动态类型及属性的访问。
而我在平常一般使用第三方库FSharp.Interop.Dynamic(Nuget)。代码示例：
//C#代码，命名空间CSharpForFSharp
public class CSharpClass
{
public dynamic TestDynamic()
{
return "5566";
}
}
在F#中调用：
//F#代码，位于F#项目的Program.fs
open FSharp.Interop.Dynamic
open CSharpForFSharp //C#项目中的命名空间
[<EntryPoint>]
let main argv =
let cc = CSharpClass()
let str = cc.TestDynamic()
printfn "%A" (str?Length) //使用?替代.
System.Console.Read()|>ignore
0
打开FSharp.Interop.Dynamic命名空间，F#中可使用?来访问动态类型的属性和方法。
调用带有 ref 和 out 参数的函数
在C#中，有ref和out两个关键字来修饰函数的参数，使函数可以进行引用传递和返回多个值。若要在F#中调用，则有一些不同。
带有ref参数或者out参数的函数，因为参数值可能在函数中发生改变，需要在F#先定义一个可变值类型，并使用寻址操作符（&）进行传入。
// C#代码，位于命名空间CSharpForFSharp
public class CSharpClass
{
public static bool OutRefParams(out int x, ref int y)
{
x = 100;
y = y * y;
return true;
}
}
在F#中调用：
// F#代码，位于F#项目的Program.fs
open CSharpForFSharp
let mutable x,y = 0,0
CSharpClass.OutRefParams(&x,&y)
返回true并对x和y进行了改变。
带有out的参数在C#中可以使用未赋值的变量传入，所以在F#中除了寻址传入的方法，还可以直接忽略该参数，则该函数在F#中成为了多返回值（即返回tuple）的形式：
let successful, result = Int32.TryParse(str)
Int32.TryParse返回了两个值，第一个总是函数返回值，而后是out参数。
柯里化C#的方法
因为C#中的函数无论有多少个参数，在F#中调用时都视为一个tuple参数，所以无法柯里化和使用函数管道符（|>）操作。
在F#中可以使用FuncConvert类将.NET中的函数转换成F#中的函数。
let join : string*string list -> string = System.String.Join
let curryJoin = FuncConvert.FuncFromTupled join
[ 1..10 ]
|> List.map string
|> curryJoin "*" // "1*2*3*4*5*6*7*8*9*10"
let joinStar = curryJoin "*" // joinStar类型为：string list -> string
以上代码将System.String.Join转化为F#中的函数，因为该方法具有多个重载，所以第一行代码用来指定一个要转换的重载。
其实FuncConvert类也可以在C#中使用，需要添加FSharp.Core程序集，有兴趣的可以自己尝试。
C#调用F#代码
本节涉及操作需要创建两个项目，一个F#的类库项目，一个C#的控制台项目。然后C#项目引用F#项目，因为涉及到F#中独有类型，还需要引用FSharp.Core程序集。
若要在UWP项目中引用F#项目，需要通过“可移植库”模板创建项目。
因为C#中的类型比F#少了很多，所以很多C#不支持的类型均使用类来代替，使用时只需像使用类一样使用它就行了。而模块，在C#中则为静态类。
F#中的函数
需要注意的是，若在F#将函数作为参数或返回值，则F#中的函数在C#中将会变成
FSharpFunc<_,_>对象（位于FSharp.Core程序集的Microsoft.FSharp.Core命名空间）。
//F# 代码，位于TestModule模块
open System
type MathUtilities =
static member GetAdder() =
(fun x y z -> Int32.Parse(x) + Int32.Parse(y) + Int32.Parse(z))
GetAdder函数返回一个将三个字符串转成int再相加的函数，在C#中调用此函数：
FSharpFunc<string, FSharpFunc<string, FSharpFunc<string, int>>> ss = MathUtilities.GetAdder();
var ret = ss.Invoke("123").Invoke("45").Invoke("67");
F#中的string -> string -> string -> int类型函数在C#中变成了FSharpFunc <string, FSharpFunc <string, FSharpFunc <string, int>>>。
这是因为C#中的不支持函数柯里化，如果F#中的函数需要更多的参数，在C#中调用就很麻烦了。虽然在F#使用很方便，但若需要编写供C#使用的程序集，尽量不要使用这些功能。
命名规范
通过上面的了解，至少可以简单地使用F#和C#互相调用。但有个地方可能使有强迫症的程序员很难受：F#模块中的函数命名使用的是驼峰式（camelCase），在C#中类的方法则使用PascalCase命名规范。
F#模块在编译成静态类后，在C#中使用变得不一致。在F#中提供了CompiledName特性用来指定编译后的名称。
在第一篇中提到的F#中可用“`` ``”来使任何字符串作为变量（值）的名称，若想在C#中调用这类值（不符合变量命名规则），也需要用CompiledName指定编译后的名称，否则无法调用。
module TestModule
[<CompiledName("Add")>]
let add = fun a b -> a+b
[<CompiledName("IsSeven")>]
let ``7?`` i = i % 7 = 0
在C#中调用：
int i = TestModule.Add(3,4);
var b = TestModule.IsSeven(7);
本文发表于博客园。 转载请注明源链接：http://www.cnblogs.com/hjklin/p/fs-for-cs-dev-5.html。