C#函数式编程

提起函数式编程，你们必定想到的是语法高度灵活和动态的LISP,Haskell这样古老的函数式语言，往近了说ruby,javascript，F#也是函数式编程的流行语言。然而自从.net支持了lambda表达式，C#虽然做为一种指令式程序设计语言，在函数式编程方面也绝不逊色。咱们在使用c#编写代码的过程当中，有意无心的都会使用高阶函数，组合函数，纯函数缓存等思想，连表达式树这样的idea也来自函数式编程思想。因此接下来咱们把经常使用的函数式编程场景作个总结，有利于咱们在程序设计过程当中灵活应用这些技术，拓展咱们的设计思路和提升代码质量。

　　1、高阶函数

　　高阶函数通俗的来说：某个函数中使用了函数做为参数，这样的函数就称为高阶函数。根据这样的定义，.net中大量使用的LINQ表达式，Where,Select,SelectMany,First等方法都属于高阶函数，那么咱们在本身写代码的时候何时会用到这种设计？

　　举例：设计一个计算物业费的函数，var fee=square*price, 而面积(square)根据物业性质的不一样，计算方式也不一样。民用住宅,商业住宅等须要乘以不一样的系数，根据这样的需求咱们试着设计下面的函数：

　　民用住宅面积：

1 2 3 4

public Func< int , int , decimal > SquareForCivil() {      return (width,hight)=>width*hight; }

　　商业住宅面积：

1 2 3 4

public Func< int , int , decimal > SquareForBusiness() {      return (width, hight) => width * hight*1.2m; }

　　这些函数都有共同的签名：Func<int,int,decimal>,因此咱们能够利用这个函数签名设计出计算物业费的函数：

1 2 3 4

public decimal PropertyFee( decimal price, int width, int hight, Func< int , int , decimal > square) {      return price*square(width, hight); }

　　是否是很easy,写个测试看看

1 2 3 4 5 6 7 8 9 10 11 12

[Test] public void Should_calculate_propertyFee_for_two_area() {      //Arrange      var calculator = new PropertyFeeCalculator();      //Act      var feeForBusiness= calculator.PropertyFee(2m,2, 2, calculator.SquareForBusiness());      var feeForCivil = calculator.PropertyFee(1m, 2, 2, calculator.SquareForCivil());      //Assert      feeForBusiness.Should().Be(9.6m);      feeForCivil.Should().Be(4m); }

　　2、惰性求值

　　C#在执行过程使用严格求值策略，所谓严格求值是指参数在传递给函数以前求值。这个解释是否是仍是有点不够清楚？咱们看个场景：有一个任务须要执行，要求当前内存使用率小于80%，而且上一步计算的结果<100，知足这个条件才能执行该任务。

　　咱们能够很快写出符合这个要求的C#代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public double MemoryUtilization()   {       //计算目前内存使用率       var pcInfo = new ComputerInfo();       var usedMem = pcInfo.TotalPhysicalMemory - pcInfo.AvailablePhysicalMemory;       return ( double )(usedMem / Convert.ToDecimal(pcInfo.TotalPhysicalMemory));   }      public int BigCalculatationForFirstStep()   {       //第一步运算       System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2));       Console.WriteLine( "big calulation" );       FirstStepExecuted = true ;       return 10;   }      public void NextStep( double memoryUtilization, int firstStepDistance)   { //下一步运算       if (memoryUtilization<0.8&&firstStepDistance<100)       {           Console.WriteLine( "Next step" );       }   }

　　在执行NextStep的时候须要传入内存使用率和第一步(函数BigCalculatationForFirstStep)的计算结果，如代码所示，第一步操做是一个很费时的运算，可是因为C#的严格求值策略，对于语句if(memoryUtilization<0.8&&firstStepDistance<100)来说，即便内存使用率已经大于80%了，第一步操做还得执行，很显然，若是内存使用率大于80%,值firstStepDistance已经不重要了，彻底能够不用计算。

　　因此惰性求值是指：表达式或者表达式的一部分只有当真正须要它们的结果时才会对它们进行求值。咱们尝试用高阶函数来重写这个需求：

1 2 3 4 5 6 7

public void NextStepWithOrderFunction(Func< double > memoryUtilization,Func< int > firstStep) {      if (memoryUtilization() < 0.8 && firstStep() < 100)      {          Console.WriteLine( "Next step" );      } }

　　代码很简单，就是用一个函数表达式来代替函数值，若是if (memoryUtilization() < 0.8..这句不知足，后面的函数也不会执行。微软在.net4.0版本中加入了Lazy<T>类，你们能够在有这种需求的场景下使用这个机制。

　　3、函数柯里化(Curry)

　　柯里化也称做局部套用。定义：是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，而且返回接受余下的参数且返回结果的新函数的技术,ps：为何官方解释这么绕口？

　　看到这样的定义估计你们也很难明白这是这么一回事，因此咱们从curry的原理讲起：

　　写一个两个数相加的函数：

1 2 3 4

public Func< int , int , int > AddTwoNumber() {      return (x, y) => x + y; }

　　ok, 如何使用这个函数？

1	var result= _curringReasoning.AddTwoNumber()(1,2);

　　1+2=3，调用很简单。需求升级，咱们须要一个函数，这个函数要求输入一个参数(number)，算出10+输入的参数(number)的结果。估计有人要说了，这需求上面的代码彻底能够实现啊，第一个参数你传入10不就完了么，ok,若是你是这样想的，我也是迫不得已。还有人可能说了，再写一个重载，只要一个参数便可，实际状况是不允许，咱们在调用别人提供的api,没法添加剧载。能够看到局部套用的使用场景不是一种很广泛的场景，因此在合适的场景配合合适的技术才是最好的设计，咱们来看局部套用的实现：

1 2 3 4 5

public Func< int , Func< int , int >> AddTwoNumberCurrying() {      Func< int , Func< int , int >> addCurrying = x => y => x + y;      return addCurrying; }

　　表达式x => y => x + y获得的函数签名为Func<int, Func<int, int>>,这个函数签名很是清楚，接收一个int类型的参数，获得一个Func<int,int>类型的函数。此时若是咱们再调用：

1 2 3 4 5 6

//Act var curringResult = curringReasoning.AddTwoNumberCurrying()(10); var result = curringResult(2);    //Assert result.Should().Be(12);

　　这句话：var curringResult = curringReasoning.AddTwoNumberCurrying()(10); 生成的函数就是只接收一个参数(number)，且能够计算出10+number的函数。

　　一样的道理，三个数相加的函数：

1 2 3 4

public Func< int , int , int , int > AddThreeNumber() {      return (x, y, z) => x + y + z; }

　　局部套用版本：

1 2 3 4 5

public Func< int ,Func< int ,Func< int , int >>> AddThreeNumberCurrying() {      Func< int , Func< int , Func< int , int >>> addCurring = x => y => z => x + y + z;      return addCurring; }

　　调用过程：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

[Test] public void Three_number_add_test() {      //Arrange      var curringReasoning = new CurryingReasoning();         //Act      var result1 = curringReasoning.AddThreeNumber()(1, 2, 3);      var curringResult = curringReasoning.AddThreeNumberCurrying()(1);      var curringResult2 = curringResult(2);      var result2 = curringResult2(3);            //Assert      result1.Should().Be(6);      result2.Should().Be(6); }

　　当函数参数多了以后，手动局部套用愈来愈不容易写，咱们能够利用扩展方法自动局部套用：

1 2 3 4 5 6 7 8 9

public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>( this Func<T1, T2, TResult> func) {      return x => y => func(x, y); }    public static Func<T1, Func<T2, Func<T3, TResult>>> Curry<T1, T2, T3, TResult>( this Func<T1, T2, T3,TResult> func) {      return x => y => z=>func(x, y,z); }

　　一样的道理，Action<>签名的函数也能够自动套用

　　有了这些扩展方法，使用局部套用的时候就更加easy了

1 2 3 4 5 6 7 8 9 10 11 12 13

[Test] public void Should_auto_curry_two_number_add_function() {      //Arrange      var add = _curringReasoning.AddTwoNumber();      var addCurrying = add.Curry();         //Act      var result = addCurrying(1)(2);         //Assert      result.Should().Be(3); }

　　好了，局部套用就说到这里，stackoverflow有几篇关于currying使用的场景和定义的文章,你们能够继续了解。

　　函数式编程还有一些重要的思想，例如：纯函数的缓存，所为纯函数是指函数的调用不受外界的影响，相同的参数调用获得的值始终是相同的。尾递归，单子，代码即数据(.net中的表达式树)，部分应用，组合函数，这些思想有的我也仍然在学习中，有的还在思考其最佳使用场景，因此再也不总结，若是哪天领会了其思想会补充。

　　4、设计案例

　　最后我仍是想设计一个场景，把高阶函数，lambda表达式，泛型方法结合在一块儿，我之因此设计这样的例子是由于如今不少的框架，开源的项目都有相似的写法，也正是由于各类技术和思想结合在一块儿，才有了极富有表达力而且很是优雅的代码。

　　需求：设计一个单词查找器，该查找器能够查找某个传入的model的某些字段是否包含某个单词，因为不一样的model具备不一样的字段，因此该查找须要配置，而且能够充分利用vs的智能提示。

　　这个功能其实就两个方法：

1 2 3 4 5 6 7 8 9 10 11 12 13

private readonly List<Func< string , bool >> _conditions;    public WordFinder<TModel> Find<TProperty>(Func<TModel,TProperty> expression) {      Func< string , bool > searchCondition = word => expression(_model).ToString().Split( ' ' ).Contains(word);      _conditions.Add(searchCondition);      return this ; }    public bool Execute( string wordList) {      return _conditions.Any(x=>x(wordList)); }

　　使用：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

[Test] public void Should_find_a_word() {      //Arrange      var article = new Article()      {          Title = "this is a title" ,          Content = "this is content" ,          Comment = "this is comment" ,          Author = "this is author"      };         //Act      var result = Finder.For(article)          .Find(x => x.Title)          .Find(x => x.Content)          .Find(x => x.Comment)          .Find(x => x.Author)          .Execute( "content" );         //Assert      result.Should().Be( true ); }

　　该案例自己不具备实用性，可是你们能够看到，正是各类技术的综合应用才设计出极具语义的api, 若是函数参数改成Expression<Func<TModel,TProperty>> 类型，咱们还能够读取到具体的属性名称等信息。