.NET并发编程之函数闭包

淩亂°似流年 2022-10-15 10:46 191阅读 0赞

函数式编程  
一个函数输出当做另一个函数输入。有时候一个复杂问题，我们拆分成很多个步骤函数，这些函数组合起来调用解决一个复杂问题。

在C\#中不支持函数组合，但可以直接像这样调用B(A(n))，这也是函数组合，但这不利于阅读，人们习惯从左往右阅读，而不是相反的方向。通过创建扩展方法可以任何组合两个函数，像下面这样

1  
Func<A,C> Compose<A,B,C>(this Func<A.B> f ,Func<B,C> g)=>(n)=>g(f(n))  
上述代码为泛型委托Func<a,b>创建了一个扩展Compose的扩展方法，以泛型委托Func<b,c>为输入参数，返回组合后的函数Func<a,c>。创建一个高阶函数Compose把不利于阅读的隐藏起来。

在F\#中就非常方便的使用函数组合。举个例子，将一个列表中数字增加4再乘以3，构建这两个步骤的函数（当然利用C\#linq或F\#map可以直接(x+4)\*3，这里主要演示两个功能函数如何组合起来）。

1  
2  
3  
4  
5  
letadd4x=x+4  
letmulitply3x=x\*3  
letlist=\[0..10\]  
letnewList=List.map(funx->mulitply3(add4(x)))list  
letnewList2=list|>List.map(add4>>mulitply3  
在F\#中使用>>中缀运算符来使函数组合可以从左到右阅读，更加精炼、简洁。

闭包的应用  
闭包可以让函数访问其所在的外部函数中的参数和变量，即使在其外部函数被返回之后。在js中经常会出现闭包的场景，在C\#和F\#中，编译器使用闭包来增加和扩展变量的范围。

C\#在.NET2.0后引入闭包。在lambda和匿名方法中得到充分的使用。像下面的匿名函数引用变量a，访问和管理变量a的状态。如果不用闭包，就需要额外创建一个类函数来调用。

1  
2  
strings="freevariable";  
Func<string,string>lambda=value=>a+""+value;  
以下载图片更新窗体PictureBox控件为例：

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
void UpdateImage(string url)  
\{  
System.Windows.Forms.PictureBox picbox = this.pictureBox1;  
var client = new WebClient();  
client.DownloadDataCompleted += (o, e) =>  
\{  
if (picbox != null)  
\{  
using (var ms = new MemoryStream(e.Result))  
\{  
picbox.Image = Image.FromStream(ms);  
\}  
\}  
\};  
client.DownloadDataAsync(new Uri(url));  
//picbox = null;  
\}  
因为是异步下载，UPdateImage方法返回后，图片还未下载完成，但picbox变量仍然可以使用。这就是变量捕获。lambda表达式捕获了局部变量image，因此它仍停留在作用域中。但捕获的变量值是在运行时确定的，而不是在捕获时，最后一句如果放开，将不能更新窗体。运行时picbox为null了，在F\#中不存在null的概念，所以也不会出现此类错误。

多线程环境中的闭包使用。猜测下面的代码运行结果如何？

1  
2  
3  
4  
5  
for (int i = 1; i < 10; i++)  
\{  
Task.Factory.StartNew(()=>Console.WriteLine("\{0\}-\{1\}",  
Thread.CurrentThread.ManagedThreadId,i));  
\}  
不会按期望的那样打印1-9，因为他们共享变量i，调用时i的值可能已经被循环修改了。印证上面说的捕获的变量值是在运行时确定的。

这种情况就很难搞，给并行编程带来了头疼的问题，变量可变，这不废话吗，变量不会变就不叫变量了。在C\#中解决此类问题的一个方法就是为每个任务创建创建和捕获一个新的临时变量，这样它就能保留捕获时的值。在F\#中不存在这个问题，它的For循环每次创建一个新的不可变值。

记忆化函数缓存  
一些函数会频繁的使用相同的参数去调用。我们可以将用相同的参数调用函数的结果存储起来，以便下次调用直接返回结果。例如对图片每个像素做处理，一张图片可能相同像素的会有很多，通过缓存可以直接返回上次计算结果。  
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 static Func<T, R> Memoize<T, R>(Func<T, R> func) where T : IComparable  
\{  
Dictionary<T, R> cache = new Dictionary<T, R>();  
return arg =>  
\{  
if (cache.ContainsKey(arg))  
return cache\[arg\];  
return (cache\[arg\] = func(arg));  
\};  
\}  
  
// 线程安全的函数缓存  
public static Func<T, R> MemoizeThreadSafe<T, R>(Func<T, R> func) where T : IComparable  
\{  
ConcurrentDictionary<T, R> cache = new ConcurrentDictionary<T, R>();  
return arg => cache.GetOrAdd(arg, a => func(a));  
\}  
  
// 利用延迟提高性能的函数缓存  
public static Func<T, R> MemoizeLazyThreadSafe<T, R>(Func<T, R> func) where T : IComparable  
\{  
ConcurrentDictionary<T, Lazy<R>> cache = new ConcurrentDictionary<T, Lazy<R>>();  
return arg => cache.GetOrAdd(arg, a => new Lazy<R>(() => func(a))).Value;  
\}  
上述示例代码中有三个版本的函数记忆化。调用像下面这样

public static string Greeting(string name)  
\{  
return $"Warm greetings \{name\}, the time is \{DateTime.Now.ToString("hh:mm:ss")\}";  
\}

public static void RunDemoMemoization()  
\{  
var greetingMemoize = Memoize<string, string>(Greeting);  
Console.WriteLine(greetingMemoize("Richard"));  
Console.WriteLine(greetingMemoize("Paul"));  
Console.WriteLine(greetingMemoize("Richard"));  
\}  
线程安全字典ConcurrentDictionary可以保证只向集合里添加一个相同值，但函数求值可能会被执行多次，所以利用.NET4之后的延迟对象加载技术。在真正需要使用对象时候才去实例化（通过访问延迟对象的Value属性），而且是线程安全的。