【C#杂谈】当Grasshopper中的C# Scriptable电池遇到LinQ，抛弃Python的理由又多了一条

LinQ的全称Language Integrated Query，是一种将数据库理念，比如常用的查找（Select）、排序（Order By）、条件过滤（Where）等延伸到一般编程中的技术路径。

Grasshopper的日常使用其中也包含了大量数据传递/使用的过程，比如按一定规律生成一系列点、将一系列直线按某种条件过滤掉等。虽然Grasshopper自带的运算器可以实现这些功能，但是有时候需要拖入大量的电池来实现一个简单的过滤逻辑。比如要从一堆点里选出X坐标大于1且小于5的点，如果只使用Grasshopper自带的电池，就需要用到下列的电池组

这时候Python就能派上大用场了：使用Python电池，一行就搞定了

	a = [pt for pt in x if pt.X > 1 and pt.X < 5]

虽然，C# Scriptable电池也能做得到这一点…… 但是这代码量可能就得多一点了

	var list = new List<Point3d>();foreach (var item in x)if (item.X > 1 && item.X < 5)list.Add(item);A = list;

所以，很多时候，对于这类纯粹的数据操作（不涉及到几何运算、复杂对象操作）而言，Python往往获得了更多的人的青睐 —— 既能少写代码，又能让代码看起来更酷，列表生成式的逻辑表达也十分清楚。

反观C#的代码，foreach循环套一个if条件判断，代码量比Python多，看起来也平平无奇，没有亮点嘛。

但是，C#真的如此吗？

加上System.Linq命名空间，C#也能变得很酷：

using System.Linq;
// ... ...A = x.Where(pt => pt.X > 1 && pt.X < 5);

下面是过滤处理100,000个数据点时，各个代码的效率对比，作为对照组，下面两个电池不做过滤，直接原路输出数据，作为对照。

Python的对照组居然比过滤后需要的时间更多？这是因为Python电池在运行时需要把来自Grasshopper内置的对象转换成为Python对象之后，才能在Python电池里处理，然后在输出时又要转回Grasshopper的对象，这需要对象被转换两次。因为过滤后的点的数量会变少，所以转换对象数量变少了，电池的运行时间就会变短。

Grasshopper本身就是C#写的，所以C# Scriptable电池在使用过程中不存在类似于Python一样的对象转换的过程，因此直接将点的列表原封不动地传出所需要的时间更少。

using System.Linq;

哪里能用Linq？

System.Linq命名空间里包含了对IEnumerable接口的一系列的扩展方法，只要对象遵循IEnumerable接口（你能想到的所有的存储多个对象的存储结构都会遵循这个接口，比如List、Array、Dictionary、Stack、Queue、……），都能直接使用Linq。

换句话说，无论哪都能用Linq，只要你想。

匿名函数

匿名函数又叫Lambda函数，语法为

(参数类型 参数名称, ...) => { 函数体 };

参数由逗号分隔，函数的返回值类型由函数体内的返回值确定，如果没有返回值则返回类型是void。

lambda函数是Linq使用的精髓，它能让Linq语法更简练、更有逻辑。比如前面中用来过滤的.Where()函数中就是用了过滤条件的lambda函数

	pt => pt.X > 1 && pt.X < 5

写全其完整版本就是

	(Point3d pt) => {return (pt.X > 1 && pt.X < 5);}

也就是这个函数是“输入参数是Point3d类型，返回值是bool类型”的一个匿名函数。

因为只有一个参数，且参数类型由.Where()前的IEnumerable中包含的对象类型确定了（此处，x的类型是List<Point3d>，因此可以确定函数的参数类型为Point3d），所以可以省略( )。因为函数体只有一行表达式，所以可以省略{ }。

在x.Where()执行时，会将来自列表x的所有的每一个对象作为输入参数，执行一遍这个匿名函数，如果返回值是true，则保留该对象，返回值是false则滤掉该对象，最终只会留下

“将对象作为输入放入Lambda函数中，返回值是true”

的这一批对象。

x.Where( pt => pt.X > 1 && pt.X < 5 ) 差不多等价于

bool Lambda_Func(Point3d pt) 
{return (pt.X > 1 && pt.X < 5)
}foreach (var item in x)
{if (Lambda_Func(item))// 接收这个对象else // 滤掉这个对象
}		

当然，也可以不用匿名函数，因为.Where()接收的是一个函数参数，也可以这样：

bool FilterFunction(Point3d pt) 
{return (pt.X > 1 && pt.X < 5)
}var filteredPoints = x.Where( FilterFunction );

把我们的过滤条件变成一个有名字（FilterFunction）的函数，既然有名字就不能叫“匿名”函数了，不过作用还是一样的。

由于大概率这类函数仅仅会用到这一次（过滤完数据之后就不会用到了），所以很多时候我们并不会费劲地给这个函数起个名字，直接使用匿名函数构造一个只用一次的函数就可以了。而且还能让逻辑变得更清晰。

Select

使用Select()可以将IEnumerable中的对象作为参数，转换整个IEnumerable的对象类型。简单点来说，这是一个单行foreach。

看下列的代码，直接复制到 https://dotnetfiddle.net/ 去执行（这是一个在线编译器，可以方便测试小代码）

using System;
using System.Collections.Generic;
using System.Linq;public class Program
{public static void Main(){var i = new List<int>{ 1, 2, 3, 4, 5, 6 };var j = i.Select(num => Math.Sqrt(num));foreach (var jtem in j) Console.WriteLine(jtem.ToString());}
}

可以看到，通过一个Select命令将i中的整数通过匿名函数num => Math.Sqrt(num)“投影”到了j中去，相当于i中每一个对象都被扔到匿名函数中执行了一遍，将结果放到了j中去。有些时候这种操作叫做管道。这是很典型的函数式编程的思想。

为什么这种操作叫做SELECT呢，这是因为实践当中它一般是不会涉及计算的，一半它是用来批量获取一个类中的某个特定属性，比如所有点的X坐标：

List<Point3d> pointList = new List<Point3d>(); 
// ... ... ...
// ... ... ... 填满这个点的列表
// .... . ...
var pointX = pointList.Select( p => p.X );

这样就十分的简单、高效。

Where

最开始的例子就提到了使用Where的最常用的情况了。只需给出一个“返回值是bool”的匿名函数，就能把原数据中“匿名函数返回为true”的对象选出来。

在 https://dotnetfiddle.net/ 中试试看这段代码：【选择所有的偶数】

using System;
using System.Collections.Generic;
using System.Linq;public class Program
{public static void Main(){var i = new List<int>{ 1, 2, 3, 4, 5, 6 };var j = i.Where( n => n%2 == 0 );foreach (var jtem in j) Console.WriteLine(jtem.ToString());}
}

OrderBy

以某种方式排序，它用到的匿名函数所需要的返回值是一个“可比较”的类型，比如int、double等。一个直观的例子，比如我们想要对一堆点排序，但是点由X、Y、Z三个坐标值构成，我们要以什么排序呢？那这里匿名函数就要返回这个 “排序的依据” 。

比如我们这以Y坐标为依据来排列点的顺序：

电池中的代码仅有一行：

	A = x.OrderBy(pt => pt.Y); // 匿名函数返回值为 Y 坐标，用于作为排序依据

返回啥就会按照啥来排序。

OrderByDescending

跟OrderBy一样，但是是从大到小排。

倒序排列。

ToList 和 ToArray

前面提到的所有的Linq语法的结果都是一个IEnumerable对象，不支持通过序号去访问其中的对象，比如x[10]。但是我们很多时候需要这样的功能，所以怎么把Linq的语法结果换成我们常用的List或者Array呢，就是使用ToList()和ToArray()。

它们不需要输入任何参数。

var i = new List<int>{ 1, 2, 3, 4, 5, 6 };
var j = i.Where( n => n%2 == 0 );  // j 是一个 IEnumerable<int> 类型List<double> doubleList = j.ToList();   // 转换成为 List<int>
// ... ...

将它们连起来

Linq语法最有优势的一点就是它能连起来使用，让整个数据流逻辑变得清晰无比：

比如在Grasshopper从一堆点里：

• 挑出来X在1到5之间
• Y在2到8之间
• 并以这些点为圆心画一个圆，其半径为它自己的X坐标与Y坐标的差值
• 将这些圆以圆心的Y坐标排序 （小到大）
• 将这些圆放到List中去

当我想到要拖多少个电池的时候，我已经不想说话了，那将会是一个灾难。

但是用Linq：

List<Circle> circleList = x.Where(pt => pt.X > 1 && pt.X < 5).Where(pt => pt.Y > 2 && pt.Y < 8).Select(pt => new Circle(pt, Math.Abs(pt.X - pt.Y))).OrderBy(c => c.Center.Y).ToList();

妙啊！

自从用熟了Linq，在Grasshopper中Python电池已经吃灰好些日子了……