Linq递归用法(摘录)

.net framework 3.5 有了Linq使得对委托有了更多的支持，下面让我们来看几个有趣的示例．通常情况下，我们实现一个递归算法要写

一个函数，同时还有调用的几行代码．

　　现在来看使用Linq的如何实现简洁的代码，代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using NUnit.Framework;

namespace WindowsFormsApplication1
{
/// <summary>
/// TestRecursionWithLINQ
/// </summary>
/// <remark>Author : PetterLiu 2009-03-29 11:28 http://wintersun.cnblogs.com/ </remark>
[TestFixture]
public class TestRecursionWithLINQ
{

/// <summary>
/// Factorials this instance.
/// </summary>
/// <remark>Author : PetterLiu 2009-03-29 11:28 http://wintersun.cnblogs.com/ </remark>
[Test]
public void Factorial()
{
Func<int, int> fib = null;
fib = n => (n == 1) ? 1 : fib(n - 1) * n;
Console.WriteLine(fib(5));
}

/// <summary>
/// Fibonaccis this instance.
/// </summary>
/// <remark>Author : PetterLiu 2009-03-29 11:28 http://wintersun.cnblogs.com/ </remark>
[Test]
public void Fibonacci()
{
Func<int, int> fib = null;
fib = n => n > 1 ? fib(n - 1) + fib(n - 2) : n;
Console.WriteLine(fib(6));
}

/// <summary>
/// Recursions the get files.
/// </summary>
/// <remark>Author : PetterLiu 2009-03-29 11:27 http://wintersun.cnblogs.com/ </remark>
[Test]
public void RecursionGetFiles()
{
var RecGetFiles =
Functional.Y<string, IEnumerable<string>>
(f => d => Directory.GetFiles(d).Concat(Directory.GetDirectories(d).SelectMany(f)));

foreach (var f in RecGetFiles(Directory.GetCurrentDirectory()))
Console.WriteLine(f);

}

/// <summary>
/// Factorial2s this instance.
/// </summary>
/// <remark>Author : PetterLiu 2009-03-29 11:28 http://wintersun.cnblogs.com/ </remark>
[Test]
public void Factorial2()
{
var dd = Functional.Y<int, int>(h => m => (m == 1) ? 1 : h(m - 1) * m);
Console.WriteLine(dd(5));
}
}

/// <summary>
/// Functional
/// </summary>
/// <remark>Author : Wes Dyer</remark>
public class Functional
{
/// <summary>
///delegate Func<A, R>
/// </summary>
private delegate Func<A, R> Recursive<A, R>(Recursive<A, R> r);
/// <summary>
/// Ys the specified f.
/// </summary>
/// <typeparam name="A"></typeparam>
/// <typeparam name="R"></typeparam>
/// <param name="f">The f.</param>
/// <returns></returns>
public static Func<A, R> Y<A, R>(Func<Func<A, R>, Func<A, R>> f)
{
Recursive<A, R> rec = r => a => f(r(r))(a);
return rec(rec);
}
}
}

Factorial是阶乘，接着是Fibonacci数列．之后把这个定义为一个名叫Funcional类，其中包含一个static方法．Factorial2使用这个类

再实现阶乘，是不是简单的多．接着是RecursionGetFiles一个实际的应用，递归遍历文件夹取得文件名列表．像树型结构算法都可以用

它来实现，是不是很有趣？

其中几个关键方法可以参考：
Func<(Of <(T, TResult>)>) 委托
封装一个具有一个参数并返回 TResult 参数指定的类型值的方法。
Enumerable.SelectMany<(Of <(TSource, TResult>)>) 方法 (IEnumerable<(Of <(TSource>)>), Func<(Of <(TSource, IEnumerable<

(Of <(TResult>)>)>)>))
将序列的每个元素投影到 IEnumerable<(Of <(T>)>) 并将结果序列合并为一个序列。
Enumerable.Concat<(Of <(TSource>)>) 方法
连接两个序列。

Action<int, int, int> Fibonacci_A = (firstNum, secondNum, boundNum) =>
{
int exchangeNum = firstNum + secondNum;
firstNum = secondNum;
secondNum = exchangeNum ;

if (secondNum > boundNum)
{
return;
}
else
{
Console.WriteLine(exchangeNum );
MethodBase.GetCurrentMethod().Invoke(null, new object[] { firstNum, secondNum ,boundNum});
}
};

Fibonacci_A(0,1,200);
Func<int,int> Fibonacci_B = n =>
{
if ((n == 0) || (n == 1))
{
return 1;
}
return (Convert.ToInt32(MethodBase.GetCurrentMethod().Invoke(null, new object[] { n - 2 }))
+Convert.ToInt32(MethodBase.GetCurrentMethod().Invoke(null, new object[] { n - 1 })));
};

for (int i = 0; i < 10; i++)
{
Console.WriteLine(Fibonacci_B(i));
}为了实现委托自身的递归调用两个函数都通过反射来实现。